diff --git a/README.md b/README.md index b72adf7..357ae92 100644 --- a/README.md +++ b/README.md @@ -124,7 +124,7 @@ I considered how many types of nodes are needed to represent a function in the e EntryArgumentNode: A node used to obtain the entry argument variables of a function. - ExecContextNode: A node used to obtain the context variables of the execution engine. + ExecContextNode: A node used to obtain the context variables of the execution engine. (Legacy — kept for backward compatibility; new code does not need to construct it explicitly because codegen auto-injects exec_ctx for functions registered via `RegisterReadOnlyCFuncWithExecCtx`.) ConstValueNode: Scalar constant node. @@ -309,9 +309,9 @@ The library is designed around a "compile once, execute from many threads" patte Recommended pattern for parallel execution: one shared `ExecEngine` plus one `ExecContext` per worker thread. # Attention -1. If you need to allocate memory that you cannot manage yourself and require the execution engine to manage it for you, you need to use the ExecContextNode. The ExecContext structure corresponding to ExecContextNode contains an arena. By using it to allocate memory, the memory will be automatically released when the execution is complete. +1. If you need to allocate memory that you cannot manage yourself and require the execution engine to manage it for you, register your C function with `RegisterReadOnlyCFuncWithExecCtx`. The function should accept a trailing `void* ctx` parameter (which is the `ExecContext` pointer); the AST does **not** pass it explicitly — codegen automatically forwards the per-execution context. The `ExecContext` carries an arena, so memory allocated through `exec_ctx->arena` is freed automatically when execution ends. -You can refer to test/exec_context_node_test.cc for more details. For example: +For example: ```c++ using namespace jitfusion; @@ -330,13 +330,14 @@ U32ListStruct CreateU32List(void* ctx) { int main() { std::unique_ptr func_registry; FunctionRegistryFactory::CreateFunctionRegistry(&func_registry); - FunctionSignature sign("create_u32_list", {ValueType::kPtr}, ValueType::kU32List); - func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast(CreateU32List)); - - auto args_node = std::unique_ptr(new ExecContextNode); - std::vector> create_func_args; - create_func_args.emplace_back(std::move(args_node)); - auto create_func_node = std::unique_ptr(new FunctionNode("create_u32_list", std::move(create_func_args))); + // User-visible signature has no trailing kPtr; the trailing exec_ctx is + // injected by codegen at every call site. + FunctionSignature sign("create_u32_list", {}, ValueType::kU32List); + func_registry->RegisterReadOnlyCFuncWithExecCtx(sign, reinterpret_cast(CreateU32List)); + + // No ExecContextNode in the AST — codegen wires exec_ctx through. + auto create_func_node = std::unique_ptr( + new FunctionNode("create_u32_list", std::vector>{})); ExecEngine exec_engine; auto st = exec_engine.Compile(create_func_node, func_registry); diff --git a/athena/README.md b/athena/README.md index 20b659f..c846159 100644 --- a/athena/README.md +++ b/athena/README.md @@ -38,7 +38,7 @@ when condition1 { Note: Variables modified inside `when` branches must maintain the same type as their original declaration. Nested `when` blocks are also supported. -* 5.You can obtain the input parameter pointer through the entry_arg name, access the ExecContext via exec_ctx and obtain the output parameter pointer through the output name. +* 5.You can obtain the input parameter pointer through the `entry_arg` name and the output parameter pointer through the `output` name. (The `exec_ctx` identifier is also still recognised as a legacy keyword that materialises the `ExecContext` pointer; new code does not need to pass it because functions registered via `RegisterReadOnlyCFuncWithExecCtx` get it injected by codegen.) * 6.Comments are supported in two C/C++ styles: * Line comments start with `//` and extend to the end of the line. diff --git a/athena/test/const_value_test.cc b/athena/test/const_value_test.cc index 082dd64..d46f561 100644 --- a/athena/test/const_value_test.cc +++ b/athena/test/const_value_test.cc @@ -62,9 +62,9 @@ TEST(ConstValueTest, ListMergeOptimizeTest) { std::string code = R"( a = [1, 2, 3]; b = [1, 2, 3]; - c = ListAdd(a, b, exec_ctx); - d = ListAdd(b, a, exec_ctx); - e = ListAdd(c, d, exec_ctx); + c = ListAdd(a, b); + d = ListAdd(b, a); + e = ListAdd(c, d); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; diff --git a/athena/test/exec_error_test.cc b/athena/test/exec_error_test.cc index fb584ae..3bc7896 100644 --- a/athena/test/exec_error_test.cc +++ b/athena/test/exec_error_test.cc @@ -27,7 +27,7 @@ TEST(ExecErrorTest, SingleExpressionRuntimeError) { std::string code = R"( a = [1, 2, 3]; b = [4, 5]; - r = ListAdd(a, b, exec_ctx); + r = ListAdd(a, b); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; @@ -43,7 +43,7 @@ TEST(ExecErrorTest, WithExecContextRuntimeError) { std::string code = R"( a = [1, 2, 3]; b = [4, 5]; - r = ListAdd(a, b, exec_ctx); + r = ListAdd(a, b); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); ExecContext exec_ctx(4096); @@ -74,7 +74,7 @@ TEST(ExecErrorTest, BatchExecutePartialFailure) { store(output, 0, r); )"; std::string code2 = R"( - r = ListAdd([1, 2, 3], [4, 5], exec_ctx); + r = ListAdd([1, 2, 3], [4, 5]); )"; std::string code3 = R"( a = load(entry_arg, 0); diff --git a/athena/test/pipeline_test.cc b/athena/test/pipeline_test.cc index 2ae1614..7d75ff1 100644 --- a/athena/test/pipeline_test.cc +++ b/athena/test/pipeline_test.cc @@ -81,8 +81,8 @@ TEST(FilterTest, Test1) { EXPECT_TRUE(func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast(LoadI32List)).ok()); std::string code = R"( a = load(entry_arg, 0); - b = GenLargeBitmap(a, 3, exec_ctx); - FilterByBitmap(a, b, exec_ctx); + b = GenLargeBitmap(a, 3); + FilterByBitmap(a, b); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; @@ -101,8 +101,8 @@ TEST(FilterTest, Test2) { std::string code = R"( a = load(entry_arg, 0); b = load(entry_arg, 1); - c = GenLargeBitmap(a, b, exec_ctx); - FilterByBitmap(a, c, exec_ctx); + c = GenLargeBitmap(a, b); + FilterByBitmap(a, c); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; @@ -122,9 +122,9 @@ TEST(CustomPassTest, CommutativeCallCanonicalizerPass1) { std::string code = R"( a = load(entry_arg, 0); b = load(entry_arg, 1); - c = ListAdd(a, b, exec_ctx); - d = ListAdd(b, a, exec_ctx); - e = ListAdd(c, d, exec_ctx); + c = ListAdd(a, b); + d = ListAdd(b, a); + e = ListAdd(c, d); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; @@ -143,9 +143,9 @@ TEST(CustomPassTest, CommutativeCallCanonicalizerPass2) { std::string code = R"( a = [1, 2, 3]; b = [4, 5, 6]; - c = ListAdd(a, b, exec_ctx); - d = ListAdd(b, a, exec_ctx); - e = ListAdd(c, d, exec_ctx); + c = ListAdd(a, b); + d = ListAdd(b, a); + e = ListAdd(c, d); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; diff --git a/athena/test/ref_node_test.cc b/athena/test/ref_node_test.cc index 8009d68..4b6fe30 100644 --- a/athena/test/ref_node_test.cc +++ b/athena/test/ref_node_test.cc @@ -282,7 +282,7 @@ TEST(RefNodeTest, RefNodeWithListOperations) { std::string code = R"( a = load(entry_arg, 0); b = load(entry_arg, 1); - c = ListAdd(a, b, exec_ctx); + c = ListAdd(a, b); d = Len(c); e = Len(a) + Len(b); store(output, 0, CastF32(d)); diff --git a/benchmark/bench_common.h b/benchmark/bench_common.h index f947ae2..514b595 100644 --- a/benchmark/bench_common.h +++ b/benchmark/bench_common.h @@ -126,8 +126,9 @@ inline std::unique_ptr MakeListUnaryCall(const std::string& func_name, // Convenience alias kept for readability. inline std::unique_ptr MakeListSumExpr(int list_len) { return MakeListUnaryCall("Sum", list_len); } -// Build `func_name(list, exec_ctx)` — one-arg list kernels that require an -// ExecContext pointer (arithmetic/basic kernels that allocate output lists). +// Build `func_name(list)` — one-arg list kernels that allocate output lists. +// (The C-level kernel still takes a trailing exec_ctx pointer; codegen now +// auto-injects it, so the user-visible AST has no ctx node.) inline std::unique_ptr MakeListUnaryCtxCall(const std::string& func_name, int list_len) { std::vector values; values.reserve(list_len); @@ -136,11 +137,10 @@ inline std::unique_ptr MakeListUnaryCtxCall(const std::string& func_na } std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, exec_ctx)` — unary kernels that only accept float lists +// Build `func_name(list)` — unary kernels that only accept float lists // (ListCeil, ListFloor, ListRound). inline std::unique_ptr MakeListUnaryCtxCallF64(const std::string& func_name, int list_len) { std::vector values; @@ -150,11 +150,10 @@ inline std::unique_ptr MakeListUnaryCtxCallF64(const std::string& func } std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, scalar_int, exec_ctx)` — list-scalar broadcast. +// Build `func_name(list, scalar_int)` — list-scalar broadcast. inline std::unique_ptr MakeListScalarCtxCall(const std::string& func_name, int list_len, int64_t scalar_val) { std::vector values; values.reserve(list_len); @@ -164,11 +163,10 @@ inline std::unique_ptr MakeListScalarCtxCall(const std::string& func_n std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantValueNode(scalar_val)); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, scalar, exec_ctx)` — bitwise list-scalar. +// Build `func_name(list, scalar)` — bitwise list-scalar. // Bitwise kernels are only registered for unsigned integer types. inline std::unique_ptr MakeListScalarCtxCallU64(const std::string& func_name, int list_len, uint64_t scalar_val) { @@ -180,11 +178,10 @@ inline std::unique_ptr MakeListScalarCtxCallU64(const std::string& fun std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantValueNode(scalar_val)); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, list, exec_ctx)` — bitwise list-list. +// Build `func_name(list, list)` — bitwise list-list. inline std::unique_ptr MakeListListCtxCallU64(const std::string& func_name, int list_len) { std::vector lhs; std::vector rhs; @@ -197,11 +194,10 @@ inline std::unique_ptr MakeListListCtxCallU64(const std::string& func_ std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(lhs))); args.emplace_back(new ConstantListValueNode(std::move(rhs))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, list, exec_ctx)` — element-wise list-list. +// Build `func_name(list, list)` — element-wise list-list. inline std::unique_ptr MakeListListCtxCall(const std::string& func_name, int list_len) { std::vector lhs; std::vector rhs; @@ -214,11 +210,10 @@ inline std::unique_ptr MakeListListCtxCall(const std::string& func_nam std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(lhs))); args.emplace_back(new ConstantListValueNode(std::move(rhs))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, scalar, scalar, exec_ctx)` — the IfEqual / +// Build `func_name(list, scalar, scalar)` — the IfEqual / // IfLess / etc. family: "for each element, if cond(elem, pivot) pick a else b". inline std::unique_ptr MakeListIfSelectCall(const std::string& func_name, int list_len) { std::vector values; @@ -230,7 +225,6 @@ inline std::unique_ptr MakeListIfSelectCall(const std::string& func_na args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantValueNode(static_cast(list_len / 2))); args.emplace_back(new ConstantValueNode(static_cast(-1))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } diff --git a/benchmark/bench_list_agg.cc b/benchmark/bench_list_agg.cc index 7afb117..705d716 100644 --- a/benchmark/bench_list_agg.cc +++ b/benchmark/bench_list_agg.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-30 16:07:33 * @Last Modified by: victorika - * @Last Modified time: 2026-04-30 16:07:33 + * @Last Modified time: 2026-05-11 16:58:15 */ // C. List aggregation + C-group. See bench_compile.cc for the split overview. @@ -10,15 +10,15 @@ namespace { -using ::jitfusion::bench::CompileOrDie; -using ::jitfusion::bench::MakeListUnaryCall; -using ::jitfusion::bench::MakeRegistry; using ::jitfusion::ConstantListValueNode; using ::jitfusion::ConstantValueNode; using ::jitfusion::ExecContext; using ::jitfusion::ExecNode; using ::jitfusion::FunctionNode; using ::jitfusion::RetType; +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeListUnaryCall; +using ::jitfusion::bench::MakeRegistry; // ============================================================================= // C. List aggregation — kernel cost vs. list length @@ -237,12 +237,11 @@ std::unique_ptr MakeGroupKeysList(int len, int distinct) { return std::unique_ptr(new ConstantListValueNode(std::move(values))); } -// Build `GroupIndex(keys_list, exec_ctx)` — the only non-sugar group node in -// the family; its kernel is the 2-arg form. +// Build `GroupIndex(keys_list)` — the only non-sugar group node in +// the family. std::unique_ptr MakeGroupIndexNode(int len, int distinct) { std::vector> args; args.emplace_back(MakeGroupKeysList(len, distinct)); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode("GroupIndex", std::move(args))); } @@ -288,7 +287,7 @@ void BM_Execute_GroupCount(benchmark::State& state) { } BENCHMARK(BM_Execute_GroupCount)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096}); -// Helper: build the sugar-form call `func_name(keys_or_values, GroupIndex(...), exec_ctx)`. +// Helper: build the sugar-form call `func_name(keys_or_values, GroupIndex(...))`. // The keys list drives GroupIndex; the same list is also fed as values/keys // to the aggregate under test. That's fine because all aggregates accept // integer lists and we measure compute time, not numerical content. @@ -296,7 +295,6 @@ std::unique_ptr MakeGroupSugarCall(const std::string& func_name, int l std::vector> args; args.emplace_back(MakeGroupKeysList(len, distinct)); args.emplace_back(MakeGroupIndexNode(len, distinct)); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } diff --git a/benchmark/bench_list_basic.cc b/benchmark/bench_list_basic.cc index f408901..33e45b7 100644 --- a/benchmark/bench_list_basic.cc +++ b/benchmark/bench_list_basic.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-30 16:07:33 * @Last Modified by: victorika - * @Last Modified time: 2026-04-30 16:07:33 + * @Last Modified time: 2026-05-11 16:58:35 */ // G. List basic (shape manipulation) + H. List element-wise unary. // See bench_compile.cc for the split overview. @@ -11,18 +11,18 @@ namespace { -using ::jitfusion::bench::CompileOrDie; -using ::jitfusion::bench::MakeListListCtxCall; -using ::jitfusion::bench::MakeListUnaryCall; -using ::jitfusion::bench::MakeListUnaryCtxCall; -using ::jitfusion::bench::MakeListUnaryCtxCallF64; -using ::jitfusion::bench::MakeRegistry; using ::jitfusion::ConstantListValueNode; using ::jitfusion::ConstantValueNode; using ::jitfusion::ExecContext; using ::jitfusion::ExecNode; using ::jitfusion::FunctionNode; using ::jitfusion::RetType; +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeListListCtxCall; +using ::jitfusion::bench::MakeListUnaryCall; +using ::jitfusion::bench::MakeListUnaryCtxCall; +using ::jitfusion::bench::MakeListUnaryCtxCallF64; +using ::jitfusion::bench::MakeRegistry; // ============================================================================= // G. List basic — shape-manipulation kernels @@ -163,7 +163,7 @@ void BM_Execute_ListMurmurHash3X8632(benchmark::State& state) { } BENCHMARK(BM_Execute_ListMurmurHash3X8632)->Arg(256)->Arg(4096); -// ListConcat(listA, listB, ctx). +// ListConcat(listA, listB). void BM_Execute_ListConcat(benchmark::State& state) { const int len = static_cast(state.range(0)); auto reg = MakeRegistry(); @@ -181,7 +181,7 @@ void BM_Execute_ListConcat(benchmark::State& state) { } BENCHMARK(BM_Execute_ListConcat)->Arg(256)->Arg(4096); -// CrossJoin(stringlist a, stringlist b, string sep, ctx) — produces a +// CrossJoin(stringlist a, stringlist b, string sep) — produces a // length-(|a| * |b|) stringlist of "a[i] + sep + b[j]". Output size is // quadratic in the input length, so we sweep the per-side length from 16..256 // (yielding 256..65536 output elements) instead of the usual 256/4096 sweep @@ -201,7 +201,7 @@ void BM_Execute_CrossJoin(benchmark::State& state) { args.emplace_back(new ConstantListValueNode(std::move(a))); args.emplace_back(new ConstantListValueNode(std::move(b))); args.emplace_back(new ConstantValueNode(std::string("_"))); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("CrossJoin", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -218,7 +218,7 @@ void BM_Execute_CrossJoin(benchmark::State& state) { } BENCHMARK(BM_Execute_CrossJoin)->Arg(16)->Arg(64)->Arg(256); -// ZipConcat(stringlist a, stringlist b, string sep, ctx) — per-position +// ZipConcat(stringlist a, stringlist b, string sep) — per-position // concatenation, output length equals |a| (== |b|). Linear cost in input // length, so it shares the standard 256/4096 sweep with the other linear // list kernels. @@ -237,7 +237,7 @@ void BM_Execute_ZipConcat(benchmark::State& state) { args.emplace_back(new ConstantListValueNode(std::move(a))); args.emplace_back(new ConstantListValueNode(std::move(b))); args.emplace_back(new ConstantValueNode(std::string(":"))); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ZipConcat", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -284,7 +284,7 @@ void BM_Execute_ListIn(benchmark::State& state) { BENCHMARK(BM_Execute_ListIn)->Arg(256)->Arg(4096); // ============================================================================= -// H. List element-wise unary (func(list, ctx) -> list) +// H. List element-wise unary (func(list) -> list) // ============================================================================= #define JITFUSION_DEFINE_LIST_UNARY_BM(NAME) \ diff --git a/benchmark/bench_list_compare.cc b/benchmark/bench_list_compare.cc index 80a7ef9..85d12f7 100644 --- a/benchmark/bench_list_compare.cc +++ b/benchmark/bench_list_compare.cc @@ -84,7 +84,7 @@ JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLessEqual); #undef JITFUSION_DEFINE_LIST_IFSELECT_BM -// IfByBitmap(packed_bitmap, value_list, alt_scalar, ctx). +// IfByBitmap(packed_bitmap, value_list, alt_scalar). // For each element i: packed_bitmap bit i set ? value_list[i] : alt_scalar. // `packed_bitmap` is a U8List of ceil(len/8) bytes, LSB = first element. void BM_Execute_IfByBitmap(benchmark::State& state) { @@ -100,7 +100,6 @@ void BM_Execute_IfByBitmap(benchmark::State& state) { args.emplace_back(new ConstantListValueNode(std::move(bitmap))); args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantValueNode(static_cast(-1))); - args.emplace_back(new jitfusion::ExecContextNode()); std::unique_ptr node(new FunctionNode("IfByBitmap", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -117,11 +116,11 @@ void BM_Execute_IfByBitmap(benchmark::State& state) { } BENCHMARK(BM_Execute_IfByBitmap)->Arg(4096); -// FilterByBitmap(value_list, packed_bitmap, ctx) — sugar form. +// FilterByBitmap(value_list, packed_bitmap) — sugar form. // // The `packed_bitmap` is ceil(values.size() / 8) bytes; each byte encodes 8 // elements (LSB = first element). 0x55 (0b01010101) gives 4 ones per byte → -// every other element is kept. The 3-arg sugar auto-derives `bits_cnt` via +// every other element is kept. The 2-arg sugar auto-derives `bits_cnt` via // CountBits(bitmap) at codegen time, so we no longer have to precompute and // pass the popcount explicitly (and can no longer get it wrong). void BM_Execute_FilterByBitmap(benchmark::State& state) { @@ -136,7 +135,6 @@ void BM_Execute_FilterByBitmap(benchmark::State& state) { std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantListValueNode(std::move(bitmap))); - args.emplace_back(new jitfusion::ExecContextNode()); std::unique_ptr node(new FunctionNode("FilterByBitmap", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); diff --git a/benchmark/bench_list_indexing.cc b/benchmark/bench_list_indexing.cc index ec14f15..6b656e3 100644 --- a/benchmark/bench_list_indexing.cc +++ b/benchmark/bench_list_indexing.cc @@ -2,22 +2,22 @@ * @Author: victorika * @Date: 2026-05-06 12:48:50 * @Last Modified by: victorika - * @Last Modified time: 2026-05-06 12:48:50 + * @Last Modified time: 2026-05-11 16:58:25 */ // K. List indexing kernels: lookup / compact / gather. // // Kernel overview: -// ListLookupIndex(a, b, ctx) : for each element in a, find its first +// ListLookupIndex(a, b) : for each element in a, find its first // occurrence in b, return the position // (u32max on miss). Built on a hash // table over b. -// ListCompactPositions(raw, ctx) : given a U32 list produced by +// ListCompactPositions(raw) : given a U32 list produced by // ListLookupIndex, return the positions // in `a` that hit (i.e. the indices // themselves, filtered by "not miss"). -// ListCompactIndex(raw, ctx) : same filter, but returns the looked-up +// ListCompactIndex(raw) : same filter, but returns the looked-up // b-side indices directly. -// ListGather(values, idx, dflt, ctx) : out[k] = (idx[k] < values.len) ? +// ListGather(values, idx, dflt) : out[k] = (idx[k] < values.len) ? // values[idx[k]] : dflt. The typical // join-realign kernel. @@ -40,7 +40,7 @@ using ::jitfusion::RetType; using ::jitfusion::bench::CompileOrDie; using ::jitfusion::bench::MakeRegistry; -// Build `ListLookupIndex(a, b, ctx)` where both are i64 lists of length `len`. +// Build `ListLookupIndex(a, b)` where both are i64 lists of length `len`. // Half of a's keys hit in b (pattern chosen to exercise both hit and miss // branches of the inner loop). std::unique_ptr MakeLookupIndexCall(int len) { @@ -49,13 +49,13 @@ std::unique_ptr MakeLookupIndexCall(int len) { a.reserve(len); b.reserve(len); for (int i = 0; i < len; ++i) { - a.push_back(i); // keys 0..len-1 - b.push_back(i * 2); // keys 0,2,4,... — only even keys from a will hit + a.push_back(i); // keys 0..len-1 + b.push_back(i * 2); // keys 0,2,4,... — only even keys from a will hit } std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(a))); args.emplace_back(new ConstantListValueNode(std::move(b))); - args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode("ListLookupIndex", std::move(args))); } @@ -94,7 +94,7 @@ void BM_Execute_ListCompactPositions(benchmark::State& state) { auto reg = MakeRegistry(); std::vector> args; args.emplace_back(MakeRawLookupList(len)); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ListCompactPositions", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -116,7 +116,7 @@ void BM_Execute_ListCompactIndex(benchmark::State& state) { auto reg = MakeRegistry(); std::vector> args; args.emplace_back(MakeRawLookupList(len)); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ListCompactIndex", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -133,7 +133,7 @@ void BM_Execute_ListCompactIndex(benchmark::State& state) { } BENCHMARK(BM_Execute_ListCompactIndex)->Arg(256)->Arg(4096); -// ListGather(values, idx, default, ctx). `idx` is arranged so +// ListGather(values, idx, default). `idx` is arranged so // every lookup hits (j < values.len) — the common hot path. void BM_Execute_ListGather(benchmark::State& state) { const int len = static_cast(state.range(0)); @@ -150,7 +150,7 @@ void BM_Execute_ListGather(benchmark::State& state) { args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantListValueNode(std::move(idx))); args.emplace_back(new ConstantValueNode(static_cast(-1))); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ListGather", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -281,7 +281,7 @@ void BM_Execute_FindSorted_AllMiss(benchmark::State& state) { } BENCHMARK(BM_Execute_FindSorted_AllMiss)->Arg(256)->Arg(4096); -// Bucketize(values, boundaries, ctx). Per-element cost is +// Bucketize(values, boundaries). Per-element cost is // O(log |boundaries|), so we sweep both axes: // * values length: 256, 4096 (matches the rest of the file) // * bucket count : 16, 256 (representative for feature-engineering use) @@ -308,7 +308,7 @@ void BM_Execute_Bucketize(benchmark::State& state) { std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantListValueNode(std::move(boundaries))); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("Bucketize", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); diff --git a/doc/function.md b/doc/function.md index e65094b..2ff374d 100644 --- a/doc/function.md +++ b/doc/function.md @@ -270,7 +270,7 @@ Type Conversion Functions ## StringConcat Concatenating two strings returns a new string. - string StringConcat(string lhs, string rhs, ptr exec_ctx) + string StringConcat(string lhs, string rhs) ## StringCmp Compares two strings lexicographically. The sign of the result is the sign of the difference between the values of the first pair of characters (both interpreted as unsigned char) that differ in the strings being compared. @@ -290,33 +290,33 @@ Check if the string contains the specified substring. Returns 1 if found, 0 othe ## CastString Convert numeric value to string. - string CastString(u8, ptr exec_ctx) - string CastString(i8, ptr exec_ctx) - string CastString(u16, ptr exec_ctx) - string CastString(i16, ptr exec_ctx) - string CastString(u32, ptr exec_ctx) - string CastString(i32, ptr exec_ctx) - string CastString(u64, ptr exec_ctx) - string CastString(i64, ptr exec_ctx) - string CastString(f32, ptr exec_ctx) - string CastString(f64, ptr exec_ctx) + string CastString(u8) + string CastString(i8) + string CastString(u16) + string CastString(i16) + string CastString(u32) + string CastString(i32) + string CastString(u64) + string CastString(i64) + string CastString(f32) + string CastString(f64) # List Type Functions ## ListConcat Concatenating two lists returns a new list. - u8list ListConcat(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListConcat(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListConcat(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListConcat(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListConcat(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListConcat(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListConcat(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListConcat(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListConcat(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListConcat(f64list lhs, f64list rhs, ptr exec_ctx) - stringlist ListConcat(stringlist lhs, stringlist rhs, ptr exec_ctx) + u8list ListConcat(u8list lhs, u8list rhs) + u16list ListConcat(u16list lhs, u16list rhs) + u32list ListConcat(u32list lhs, u32list rhs) + u64list ListConcat(u64list lhs, u64list rhs) + i8list ListConcat(i8list lhs, i8list rhs) + i16list ListConcat(i16list lhs, i16list rhs) + i32list ListConcat(i32list lhs, i32list rhs) + i64list ListConcat(i64list lhs, i64list rhs) + f32list ListConcat(f32list lhs, f32list rhs) + f64list ListConcat(f64list lhs, f64list rhs) + stringlist ListConcat(stringlist lhs, stringlist rhs) ## CrossJoin Cartesian-product string concatenation. Given an outer list `a`, an inner list `b` @@ -330,7 +330,7 @@ Example: `CrossJoin(["1","2","3"], ["a","b","c"], "_") == If either input list is empty, the result is empty. Numeric lists are not accepted directly — convert them to `stringlist` first via `CastStringList`. - stringlist CrossJoin(stringlist a, stringlist b, string sep, ptr exec_ctx) + stringlist CrossJoin(stringlist a, stringlist b, string sep) ## ZipConcat Per-position string concatenation. Pairs up `a[i]` with `b[i]` and produces a @@ -344,7 +344,7 @@ The two input lists must have equal length; a length mismatch is reported via Numeric lists are not accepted directly — convert them to `stringlist` first via `CastStringList`. - stringlist ZipConcat(stringlist a, stringlist b, string sep, ptr exec_ctx) + stringlist ZipConcat(stringlist a, stringlist b, string sep) ## in Check if it is in the list. @@ -477,17 +477,17 @@ Calculate the median of a pre-sorted list. For even-length lists, returns the av ## GroupIndex Assign each element in `keys` a dense group id in first-appearance order, starting from 0. Duplicate keys get the same id, so the resulting `u32list` has the same length as `keys` and is the shared input of every other `Group*` function below. - u32list GroupIndex(u8list keys, ptr exec_ctx) - u32list GroupIndex(i8list keys, ptr exec_ctx) - u32list GroupIndex(u16list keys, ptr exec_ctx) - u32list GroupIndex(i16list keys, ptr exec_ctx) - u32list GroupIndex(u32list keys, ptr exec_ctx) - u32list GroupIndex(i32list keys, ptr exec_ctx) - u32list GroupIndex(u64list keys, ptr exec_ctx) - u32list GroupIndex(i64list keys, ptr exec_ctx) - u32list GroupIndex(f32list keys, ptr exec_ctx) - u32list GroupIndex(f64list keys, ptr exec_ctx) - u32list GroupIndex(stringlist keys, ptr exec_ctx) + u32list GroupIndex(u8list keys) + u32list GroupIndex(i8list keys) + u32list GroupIndex(u16list keys) + u32list GroupIndex(i16list keys) + u32list GroupIndex(u32list keys) + u32list GroupIndex(i32list keys) + u32list GroupIndex(u64list keys) + u32list GroupIndex(i64list keys) + u32list GroupIndex(f32list keys) + u32list GroupIndex(f64list keys) + u32list GroupIndex(stringlist keys) ## GroupCount Return the number of distinct groups encoded in a `group_index` produced by `GroupIndex`. Returns 0 for empty input. @@ -495,75 +495,75 @@ Return the number of distinct groups encoded in a `group_index` produced by `Gro u32 GroupCount(u32list group_index) ## GroupKeys -Return the distinct keys in first-appearance order, one per group. The output length equals the number of distinct groups. `keys` and `group_index` must have the same length; `group_index` is typically the result of `GroupIndex(keys, exec_ctx)`. - - u8list GroupKeys(u8list keys, u32list group_index, ptr exec_ctx) - i8list GroupKeys(i8list keys, u32list group_index, ptr exec_ctx) - u16list GroupKeys(u16list keys, u32list group_index, ptr exec_ctx) - i16list GroupKeys(i16list keys, u32list group_index, ptr exec_ctx) - u32list GroupKeys(u32list keys, u32list group_index, ptr exec_ctx) - i32list GroupKeys(i32list keys, u32list group_index, ptr exec_ctx) - u64list GroupKeys(u64list keys, u32list group_index, ptr exec_ctx) - i64list GroupKeys(i64list keys, u32list group_index, ptr exec_ctx) - f32list GroupKeys(f32list keys, u32list group_index, ptr exec_ctx) - f64list GroupKeys(f64list keys, u32list group_index, ptr exec_ctx) - stringlist GroupKeys(stringlist keys, u32list group_index, ptr exec_ctx) +Return the distinct keys in first-appearance order, one per group. The output length equals the number of distinct groups. `keys` and `group_index` must have the same length; `group_index` is typically the result of `GroupIndex(keys)`. + + u8list GroupKeys(u8list keys, u32list group_index) + i8list GroupKeys(i8list keys, u32list group_index) + u16list GroupKeys(u16list keys, u32list group_index) + i16list GroupKeys(i16list keys, u32list group_index) + u32list GroupKeys(u32list keys, u32list group_index) + i32list GroupKeys(i32list keys, u32list group_index) + u64list GroupKeys(u64list keys, u32list group_index) + i64list GroupKeys(i64list keys, u32list group_index) + f32list GroupKeys(f32list keys, u32list group_index) + f64list GroupKeys(f64list keys, u32list group_index) + stringlist GroupKeys(stringlist keys, u32list group_index) ## GroupSum Per-group sum of `values`. The output has one entry per distinct group, in the same order as `GroupKeys`. Signed integers promote to `i64`, unsigned to `u64`, floats to `f64` — matching the ungrouped `Sum`. `values.len` must equal `group_index.len`. - i64list GroupSum(i8list values, u32list group_index, ptr exec_ctx) - i64list GroupSum(i16list values, u32list group_index, ptr exec_ctx) - i64list GroupSum(i32list values, u32list group_index, ptr exec_ctx) - i64list GroupSum(i64list values, u32list group_index, ptr exec_ctx) - u64list GroupSum(u8list values, u32list group_index, ptr exec_ctx) - u64list GroupSum(u16list values, u32list group_index, ptr exec_ctx) - u64list GroupSum(u32list values, u32list group_index, ptr exec_ctx) - u64list GroupSum(u64list values, u32list group_index, ptr exec_ctx) - f64list GroupSum(f32list values, u32list group_index, ptr exec_ctx) - f64list GroupSum(f64list values, u32list group_index, ptr exec_ctx) + i64list GroupSum(i8list values, u32list group_index) + i64list GroupSum(i16list values, u32list group_index) + i64list GroupSum(i32list values, u32list group_index) + i64list GroupSum(i64list values, u32list group_index) + u64list GroupSum(u8list values, u32list group_index) + u64list GroupSum(u16list values, u32list group_index) + u64list GroupSum(u32list values, u32list group_index) + u64list GroupSum(u64list values, u32list group_index) + f64list GroupSum(f32list values, u32list group_index) + f64list GroupSum(f64list values, u32list group_index) ## GroupMax Per-group maximum of `values`. Output type matches the input element type (no promotion, same rule as the ungrouped `Max`). `values.len` must equal `group_index.len`. - u8list GroupMax(u8list values, u32list group_index, ptr exec_ctx) - i8list GroupMax(i8list values, u32list group_index, ptr exec_ctx) - u16list GroupMax(u16list values, u32list group_index, ptr exec_ctx) - i16list GroupMax(i16list values, u32list group_index, ptr exec_ctx) - u32list GroupMax(u32list values, u32list group_index, ptr exec_ctx) - i32list GroupMax(i32list values, u32list group_index, ptr exec_ctx) - u64list GroupMax(u64list values, u32list group_index, ptr exec_ctx) - i64list GroupMax(i64list values, u32list group_index, ptr exec_ctx) - f32list GroupMax(f32list values, u32list group_index, ptr exec_ctx) - f64list GroupMax(f64list values, u32list group_index, ptr exec_ctx) + u8list GroupMax(u8list values, u32list group_index) + i8list GroupMax(i8list values, u32list group_index) + u16list GroupMax(u16list values, u32list group_index) + i16list GroupMax(i16list values, u32list group_index) + u32list GroupMax(u32list values, u32list group_index) + i32list GroupMax(i32list values, u32list group_index) + u64list GroupMax(u64list values, u32list group_index) + i64list GroupMax(i64list values, u32list group_index) + f32list GroupMax(f32list values, u32list group_index) + f64list GroupMax(f64list values, u32list group_index) ## GroupMin Per-group minimum of `values`. Output type matches the input element type (no promotion, same rule as the ungrouped `Min`). `values.len` must equal `group_index.len`. - u8list GroupMin(u8list values, u32list group_index, ptr exec_ctx) - i8list GroupMin(i8list values, u32list group_index, ptr exec_ctx) - u16list GroupMin(u16list values, u32list group_index, ptr exec_ctx) - i16list GroupMin(i16list values, u32list group_index, ptr exec_ctx) - u32list GroupMin(u32list values, u32list group_index, ptr exec_ctx) - i32list GroupMin(i32list values, u32list group_index, ptr exec_ctx) - u64list GroupMin(u64list values, u32list group_index, ptr exec_ctx) - i64list GroupMin(i64list values, u32list group_index, ptr exec_ctx) - f32list GroupMin(f32list values, u32list group_index, ptr exec_ctx) - f64list GroupMin(f64list values, u32list group_index, ptr exec_ctx) + u8list GroupMin(u8list values, u32list group_index) + i8list GroupMin(i8list values, u32list group_index) + u16list GroupMin(u16list values, u32list group_index) + i16list GroupMin(i16list values, u32list group_index) + u32list GroupMin(u32list values, u32list group_index) + i32list GroupMin(i32list values, u32list group_index) + u64list GroupMin(u64list values, u32list group_index) + i64list GroupMin(i64list values, u32list group_index) + f32list GroupMin(f32list values, u32list group_index) + f64list GroupMin(f64list values, u32list group_index) ## GroupAvg Per-group average of `values`. Output is always `f64list` with one entry per distinct group, matching the ungrouped `Avg`. `values.len` must equal `group_index.len`. - f64list GroupAvg(u8list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(i8list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(u16list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(i16list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(u32list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(i32list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(u64list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(i64list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(f32list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(f64list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(u8list values, u32list group_index) + f64list GroupAvg(i8list values, u32list group_index) + f64list GroupAvg(u16list values, u32list group_index) + f64list GroupAvg(i16list values, u32list group_index) + f64list GroupAvg(u32list values, u32list group_index) + f64list GroupAvg(i32list values, u32list group_index) + f64list GroupAvg(u64list values, u32list group_index) + f64list GroupAvg(i64list values, u32list group_index) + f64list GroupAvg(f32list values, u32list group_index) + f64list GroupAvg(f64list values, u32list group_index) ## GetAt Get the element at the specified index from the list. Returns the default value (0 for numeric types) if the index is out of bounds. @@ -582,45 +582,45 @@ Get the element at the specified index from the list. Returns the default value ## Unique Remove duplicate elements from the list while preserving the original order. Returns a new list containing only the first occurrence of each element. - u8list Unique(u8list src, ptr exec_ctx) - u16list Unique(u16list src, ptr exec_ctx) - u32list Unique(u32list src, ptr exec_ctx) - u64list Unique(u64list src, ptr exec_ctx) - i8list Unique(i8list src, ptr exec_ctx) - i16list Unique(i16list src, ptr exec_ctx) - i32list Unique(i32list src, ptr exec_ctx) - i64list Unique(i64list src, ptr exec_ctx) - f32list Unique(f32list src, ptr exec_ctx) - f64list Unique(f64list src, ptr exec_ctx) - stringlist Unique(stringlist src, ptr exec_ctx) + u8list Unique(u8list src) + u16list Unique(u16list src) + u32list Unique(u32list src) + u64list Unique(u64list src) + i8list Unique(i8list src) + i16list Unique(i16list src) + i32list Unique(i32list src) + i64list Unique(i64list src) + f32list Unique(f32list src) + f64list Unique(f64list src) + stringlist Unique(stringlist src) ## SortAsc Return the sorted list in ascending order. - u8list SortAsc(u8list unsorted, ptr exec_ctx) - u16list SortAsc(u16list unsorted, ptr exec_ctx) - u32list SortAsc(u32list unsorted, ptr exec_ctx) - u64list SortAsc(u64list unsorted, ptr exec_ctx) - i8list SortAsc(i8list unsorted, ptr exec_ctx) - i16list SortAsc(i16list unsorted, ptr exec_ctx) - i32list SortAsc(i32list unsorted, ptr exec_ctx) - i64list SortAsc(i64list unsorted, ptr exec_ctx) - f32list SortAsc(f32list unsorted, ptr exec_ctx) - f64list SortAsc(f64list unsorted, ptr exec_ctx) + u8list SortAsc(u8list unsorted) + u16list SortAsc(u16list unsorted) + u32list SortAsc(u32list unsorted) + u64list SortAsc(u64list unsorted) + i8list SortAsc(i8list unsorted) + i16list SortAsc(i16list unsorted) + i32list SortAsc(i32list unsorted) + i64list SortAsc(i64list unsorted) + f32list SortAsc(f32list unsorted) + f64list SortAsc(f64list unsorted) ## SortDesc Return the sorted list in descending order. - u8list SortDesc(u8list unsorted, ptr exec_ctx) - u16list SortDesc(u16list unsorted, ptr exec_ctx) - u32list SortDesc(u32list unsorted, ptr exec_ctx) - u64list SortDesc(u64list unsorted, ptr exec_ctx) - i8list SortDesc(i8list unsorted, ptr exec_ctx) - i16list SortDesc(i16list unsorted, ptr exec_ctx) - i32list SortDesc(i32list unsorted, ptr exec_ctx) - i64list SortDesc(i64list unsorted, ptr exec_ctx) - f32list SortDesc(f32list unsorted, ptr exec_ctx) - f64list SortDesc(f64list unsorted, ptr exec_ctx) + u8list SortDesc(u8list unsorted) + u16list SortDesc(u16list unsorted) + u32list SortDesc(u32list unsorted) + u64list SortDesc(u64list unsorted) + i8list SortDesc(i8list unsorted) + i16list SortDesc(i16list unsorted) + i32list SortDesc(i32list unsorted) + i64list SortDesc(i64list unsorted) + f32list SortDesc(f32list unsorted) + f64list SortDesc(f64list unsorted) ## Truncate Return the truncated list. @@ -640,480 +640,480 @@ Return the truncated list. ## ListAdd Return a new list after adding a number to all elements in the list. - u8list ListAdd(u8list src, u8 add, ptr exec_ctx) - u16list ListAdd(u16list src, u16 add, ptr exec_ctx) - u32list ListAdd(u32list src, u32 add, ptr exec_ctx) - u64list ListAdd(u64list src, u64 add, ptr exec_ctx) - i8list ListAdd(i8list src, i8 add, ptr exec_ctx) - i16list ListAdd(i16list src, i16 add, ptr exec_ctx) - i32list ListAdd(i32list src, i32 add, ptr exec_ctx) - i64list ListAdd(i64list src, i64 add, ptr exec_ctx) - f32list ListAdd(f32list src, f32 add, ptr exec_ctx) - f64list ListAdd(f64list src, f64 add, ptr exec_ctx) + u8list ListAdd(u8list src, u8 add) + u16list ListAdd(u16list src, u16 add) + u32list ListAdd(u32list src, u32 add) + u64list ListAdd(u64list src, u64 add) + i8list ListAdd(i8list src, i8 add) + i16list ListAdd(i16list src, i16 add) + i32list ListAdd(i32list src, i32 add) + i64list ListAdd(i64list src, i64 add) + f32list ListAdd(f32list src, f32 add) + f64list ListAdd(f64list src, f64 add) Add two lists element-wise and return a new list. Both lists must have equal length. - u8list ListAdd(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListAdd(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListAdd(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListAdd(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListAdd(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListAdd(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListAdd(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListAdd(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListAdd(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListAdd(f64list lhs, f64list rhs, ptr exec_ctx) + u8list ListAdd(u8list lhs, u8list rhs) + u16list ListAdd(u16list lhs, u16list rhs) + u32list ListAdd(u32list lhs, u32list rhs) + u64list ListAdd(u64list lhs, u64list rhs) + i8list ListAdd(i8list lhs, i8list rhs) + i16list ListAdd(i16list lhs, i16list rhs) + i32list ListAdd(i32list lhs, i32list rhs) + i64list ListAdd(i64list lhs, i64list rhs) + f32list ListAdd(f32list lhs, f32list rhs) + f64list ListAdd(f64list lhs, f64list rhs) ## ListSub Return a new list after subtracting a number to all elements in the list. - u8list ListSub(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListSub(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListSub(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListSub(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListSub(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListSub(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListSub(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListSub(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListSub(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListSub(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListSub(u8list lhs, u8 rhs) + u16list ListSub(u16list lhs, u16 rhs) + u32list ListSub(u32list lhs, u32 rhs) + u64list ListSub(u64list lhs, u64 rhs) + i8list ListSub(i8list lhs, i8 rhs) + i16list ListSub(i16list lhs, i16 rhs) + i32list ListSub(i32list lhs, i32 rhs) + i64list ListSub(i64list lhs, i64 rhs) + f32list ListSub(f32list lhs, f32 rhs) + f64list ListSub(f64list lhs, f64 rhs) Subtract two lists element-wise and return a new list. Both lists must have equal length. - u8list ListSub(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListSub(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListSub(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListSub(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListSub(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListSub(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListSub(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListSub(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListSub(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListSub(f64list lhs, f64list rhs, ptr exec_ctx) + u8list ListSub(u8list lhs, u8list rhs) + u16list ListSub(u16list lhs, u16list rhs) + u32list ListSub(u32list lhs, u32list rhs) + u64list ListSub(u64list lhs, u64list rhs) + i8list ListSub(i8list lhs, i8list rhs) + i16list ListSub(i16list lhs, i16list rhs) + i32list ListSub(i32list lhs, i32list rhs) + i64list ListSub(i64list lhs, i64list rhs) + f32list ListSub(f32list lhs, f32list rhs) + f64list ListSub(f64list lhs, f64list rhs) ## ListMul Return a new list after multiplying all elements in the list by a number. - u8list ListMul(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListMul(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListMul(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListMul(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListMul(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListMul(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListMul(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListMul(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListMul(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListMul(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListMul(u8list lhs, u8 rhs) + u16list ListMul(u16list lhs, u16 rhs) + u32list ListMul(u32list lhs, u32 rhs) + u64list ListMul(u64list lhs, u64 rhs) + i8list ListMul(i8list lhs, i8 rhs) + i16list ListMul(i16list lhs, i16 rhs) + i32list ListMul(i32list lhs, i32 rhs) + i64list ListMul(i64list lhs, i64 rhs) + f32list ListMul(f32list lhs, f32 rhs) + f64list ListMul(f64list lhs, f64 rhs) Multiply two lists element-wise and return a new list. Both lists must have equal length. - u8list ListMul(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListMul(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListMul(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListMul(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListMul(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListMul(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListMul(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListMul(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListMul(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListMul(f64list lhs, f64list rhs, ptr exec_ctx) + u8list ListMul(u8list lhs, u8list rhs) + u16list ListMul(u16list lhs, u16list rhs) + u32list ListMul(u32list lhs, u32list rhs) + u64list ListMul(u64list lhs, u64list rhs) + i8list ListMul(i8list lhs, i8list rhs) + i16list ListMul(i16list lhs, i16list rhs) + i32list ListMul(i32list lhs, i32list rhs) + i64list ListMul(i64list lhs, i64list rhs) + f32list ListMul(f32list lhs, f32list rhs) + f64list ListMul(f64list lhs, f64list rhs) ## ListDiv Return a new list after dividing all elements in the list by a given number. - u8list ListDiv(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListDiv(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListDiv(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListDiv(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListDiv(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListDiv(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListDiv(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListDiv(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListDiv(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListDiv(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListDiv(u8list lhs, u8 rhs) + u16list ListDiv(u16list lhs, u16 rhs) + u32list ListDiv(u32list lhs, u32 rhs) + u64list ListDiv(u64list lhs, u64 rhs) + i8list ListDiv(i8list lhs, i8 rhs) + i16list ListDiv(i16list lhs, i16 rhs) + i32list ListDiv(i32list lhs, i32 rhs) + i64list ListDiv(i64list lhs, i64 rhs) + f32list ListDiv(f32list lhs, f32 rhs) + f64list ListDiv(f64list lhs, f64 rhs) Divide two lists element-wise and return a new list. Both lists must have equal length. - u8list ListDiv(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListDiv(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListDiv(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListDiv(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListDiv(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListDiv(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListDiv(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListDiv(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListDiv(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListDiv(f64list lhs, f64list rhs, ptr exec_ctx) + u8list ListDiv(u8list lhs, u8list rhs) + u16list ListDiv(u16list lhs, u16list rhs) + u32list ListDiv(u32list lhs, u32list rhs) + u64list ListDiv(u64list lhs, u64list rhs) + i8list ListDiv(i8list lhs, i8list rhs) + i16list ListDiv(i16list lhs, i16list rhs) + i32list ListDiv(i32list lhs, i32list rhs) + i64list ListDiv(i64list lhs, i64list rhs) + f32list ListDiv(f32list lhs, f32list rhs) + f64list ListDiv(f64list lhs, f64list rhs) ## ListMod Return a new list after applying the modulus operation to all elements in the list with a given number. - u8list ListMod(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListMod(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListMod(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListMod(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListMod(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListMod(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListMod(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListMod(i64list lhs, i64 rhs, ptr exec_ctx) + u8list ListMod(u8list lhs, u8 rhs) + u16list ListMod(u16list lhs, u16 rhs) + u32list ListMod(u32list lhs, u32 rhs) + u64list ListMod(u64list lhs, u64 rhs) + i8list ListMod(i8list lhs, i8 rhs) + i16list ListMod(i16list lhs, i16 rhs) + i32list ListMod(i32list lhs, i32 rhs) + i64list ListMod(i64list lhs, i64 rhs) Apply the modulus operation element-wise on two lists and return a new list. Both lists must have equal length. - u8list ListMod(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListMod(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListMod(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListMod(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListMod(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListMod(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListMod(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListMod(i64list lhs, i64list rhs, ptr exec_ctx) + u8list ListMod(u8list lhs, u8list rhs) + u16list ListMod(u16list lhs, u16list rhs) + u32list ListMod(u32list lhs, u32list rhs) + u64list ListMod(u64list lhs, u64list rhs) + i8list ListMod(i8list lhs, i8list rhs) + i16list ListMod(i16list lhs, i16list rhs) + i32list ListMod(i32list lhs, i32list rhs) + i64list ListMod(i64list lhs, i64list rhs) ## ListBitwiseAnd Return a new list after performing a bitwise AND operation between all elements in the list and a given number. - u8list ListBitwiseAnd(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListBitwiseAnd(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListBitwiseAnd(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListBitwiseAnd(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListBitwiseAnd(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListBitwiseAnd(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListBitwiseAnd(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListBitwiseAnd(i64list lhs, i64 rhs, ptr exec_ctx) + u8list ListBitwiseAnd(u8list lhs, u8 rhs) + u16list ListBitwiseAnd(u16list lhs, u16 rhs) + u32list ListBitwiseAnd(u32list lhs, u32 rhs) + u64list ListBitwiseAnd(u64list lhs, u64 rhs) + i8list ListBitwiseAnd(i8list lhs, i8 rhs) + i16list ListBitwiseAnd(i16list lhs, i16 rhs) + i32list ListBitwiseAnd(i32list lhs, i32 rhs) + i64list ListBitwiseAnd(i64list lhs, i64 rhs) Perform a bitwise AND operation element-wise on two lists and return a new list. Both lists must have equal length. - u8list ListBitwiseAnd(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListBitwiseAnd(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListBitwiseAnd(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListBitwiseAnd(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListBitwiseAnd(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListBitwiseAnd(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListBitwiseAnd(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListBitwiseAnd(i64list lhs, i64list rhs, ptr exec_ctx) + u8list ListBitwiseAnd(u8list lhs, u8list rhs) + u16list ListBitwiseAnd(u16list lhs, u16list rhs) + u32list ListBitwiseAnd(u32list lhs, u32list rhs) + u64list ListBitwiseAnd(u64list lhs, u64list rhs) + i8list ListBitwiseAnd(i8list lhs, i8list rhs) + i16list ListBitwiseAnd(i16list lhs, i16list rhs) + i32list ListBitwiseAnd(i32list lhs, i32list rhs) + i64list ListBitwiseAnd(i64list lhs, i64list rhs) ## ListBitwiseOr Return a new list after performing a bitwise OR operation between all elements in the list and a given number. - u8list ListBitwiseOr(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListBitwiseOr(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListBitwiseOr(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListBitwiseOr(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListBitwiseOr(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListBitwiseOr(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListBitwiseOr(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListBitwiseOr(i64list lhs, i64 rhs, ptr exec_ctx) + u8list ListBitwiseOr(u8list lhs, u8 rhs) + u16list ListBitwiseOr(u16list lhs, u16 rhs) + u32list ListBitwiseOr(u32list lhs, u32 rhs) + u64list ListBitwiseOr(u64list lhs, u64 rhs) + i8list ListBitwiseOr(i8list lhs, i8 rhs) + i16list ListBitwiseOr(i16list lhs, i16 rhs) + i32list ListBitwiseOr(i32list lhs, i32 rhs) + i64list ListBitwiseOr(i64list lhs, i64 rhs) Perform a bitwise OR operation element-wise on two lists and return a new list. Both lists must have equal length. - u8list ListBitwiseOr(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListBitwiseOr(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListBitwiseOr(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListBitwiseOr(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListBitwiseOr(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListBitwiseOr(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListBitwiseOr(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListBitwiseOr(i64list lhs, i64list rhs, ptr exec_ctx) + u8list ListBitwiseOr(u8list lhs, u8list rhs) + u16list ListBitwiseOr(u16list lhs, u16list rhs) + u32list ListBitwiseOr(u32list lhs, u32list rhs) + u64list ListBitwiseOr(u64list lhs, u64list rhs) + i8list ListBitwiseOr(i8list lhs, i8list rhs) + i16list ListBitwiseOr(i16list lhs, i16list rhs) + i32list ListBitwiseOr(i32list lhs, i32list rhs) + i64list ListBitwiseOr(i64list lhs, i64list rhs) ## ListBitwiseXor Return a new list after performing a bitwise XOR operation between all elements in the list and a given number. - u8list ListBitwiseXor(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListBitwiseXor(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListBitwiseXor(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListBitwiseXor(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListBitwiseXor(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListBitwiseXor(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListBitwiseXor(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListBitwiseXor(i64list lhs, i64 rhs, ptr exec_ctx) + u8list ListBitwiseXor(u8list lhs, u8 rhs) + u16list ListBitwiseXor(u16list lhs, u16 rhs) + u32list ListBitwiseXor(u32list lhs, u32 rhs) + u64list ListBitwiseXor(u64list lhs, u64 rhs) + i8list ListBitwiseXor(i8list lhs, i8 rhs) + i16list ListBitwiseXor(i16list lhs, i16 rhs) + i32list ListBitwiseXor(i32list lhs, i32 rhs) + i64list ListBitwiseXor(i64list lhs, i64 rhs) Perform a bitwise XOR operation element-wise on two lists and return a new list. Both lists must have equal length. - u8list ListBitwiseXor(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListBitwiseXor(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListBitwiseXor(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListBitwiseXor(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListBitwiseXor(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListBitwiseXor(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListBitwiseXor(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListBitwiseXor(i64list lhs, i64list rhs, ptr exec_ctx) + u8list ListBitwiseXor(u8list lhs, u8list rhs) + u16list ListBitwiseXor(u16list lhs, u16list rhs) + u32list ListBitwiseXor(u32list lhs, u32list rhs) + u64list ListBitwiseXor(u64list lhs, u64list rhs) + i8list ListBitwiseXor(i8list lhs, i8list rhs) + i16list ListBitwiseXor(i16list lhs, i16list rhs) + i32list ListBitwiseXor(i32list lhs, i32list rhs) + i64list ListBitwiseXor(i64list lhs, i64list rhs) ## ListExp Return a new list after performing the exp operation on all elements in the list. - f64list ListExp(u8list src, ptr exec_ctx) - f64list ListExp(u16list src, ptr exec_ctx) - f64list ListExp(u32list src, ptr exec_ctx) - f64list ListExp(u64list src, ptr exec_ctx) - f64list ListExp(i8list src, ptr exec_ctx) - f64list ListExp(i16list src, ptr exec_ctx) - f64list ListExp(i32list src, ptr exec_ctx) - f64list ListExp(i64list src, ptr exec_ctx) - f32list ListExp(f32list src, ptr exec_ctx) - f64list ListExp(f64list src, ptr exec_ctx) + f64list ListExp(u8list src) + f64list ListExp(u16list src) + f64list ListExp(u32list src) + f64list ListExp(u64list src) + f64list ListExp(i8list src) + f64list ListExp(i16list src) + f64list ListExp(i32list src) + f64list ListExp(i64list src) + f32list ListExp(f32list src) + f64list ListExp(f64list src) ## ListLog Return a new list after performing the log operation on all elements in the list. - f64list ListLog(u8list src, ptr exec_ctx) - f64list ListLog(u16list src, ptr exec_ctx) - f64list ListLog(u32list src, ptr exec_ctx) - f64list ListLog(u64list src, ptr exec_ctx) - f64list ListLog(i8list src, ptr exec_ctx) - f64list ListLog(i16list src, ptr exec_ctx) - f64list ListLog(i32list src, ptr exec_ctx) - f64list ListLog(i64list src, ptr exec_ctx) - f32list ListLog(f32list src, ptr exec_ctx) - f64list ListLog(f64list src, ptr exec_ctx) + f64list ListLog(u8list src) + f64list ListLog(u16list src) + f64list ListLog(u32list src) + f64list ListLog(u64list src) + f64list ListLog(i8list src) + f64list ListLog(i16list src) + f64list ListLog(i32list src) + f64list ListLog(i64list src) + f32list ListLog(f32list src) + f64list ListLog(f64list src) ## ListLog2 Return a new list after performing the log2 operation on all elements in the list. - f64list ListLog2(u8list src, ptr exec_ctx) - f64list ListLog2(u16list src, ptr exec_ctx) - f64list ListLog2(u32list src, ptr exec_ctx) - f64list ListLog2(u64list src, ptr exec_ctx) - f64list ListLog2(i8list src, ptr exec_ctx) - f64list ListLog2(i16list src, ptr exec_ctx) - f64list ListLog2(i32list src, ptr exec_ctx) - f64list ListLog2(i64list src, ptr exec_ctx) - f32list ListLog2(f32list src, ptr exec_ctx) - f64list ListLog2(f64list src, ptr exec_ctx) + f64list ListLog2(u8list src) + f64list ListLog2(u16list src) + f64list ListLog2(u32list src) + f64list ListLog2(u64list src) + f64list ListLog2(i8list src) + f64list ListLog2(i16list src) + f64list ListLog2(i32list src) + f64list ListLog2(i64list src) + f32list ListLog2(f32list src) + f64list ListLog2(f64list src) ## ListLog10 Return a new list after performing the log10 operation on all elements in the list. - f64list ListLog10(u8list src, ptr exec_ctx) - f64list ListLog10(u16list src, ptr exec_ctx) - f64list ListLog10(u32list src, ptr exec_ctx) - f64list ListLog10(u64list src, ptr exec_ctx) - f64list ListLog10(i8list src, ptr exec_ctx) - f64list ListLog10(i16list src, ptr exec_ctx) - f64list ListLog10(i32list src, ptr exec_ctx) - f64list ListLog10(i64list src, ptr exec_ctx) - f32list ListLog10(f32list src, ptr exec_ctx) - f64list ListLog10(f64list src, ptr exec_ctx) + f64list ListLog10(u8list src) + f64list ListLog10(u16list src) + f64list ListLog10(u32list src) + f64list ListLog10(u64list src) + f64list ListLog10(i8list src) + f64list ListLog10(i16list src) + f64list ListLog10(i32list src) + f64list ListLog10(i64list src) + f32list ListLog10(f32list src) + f64list ListLog10(f64list src) ## ListCeil Return a new list after performing the ceil operation on all elements in the list. - f32list ListCeil(f32list src, ptr exec_ctx) - f64list ListCeil(f64list src, ptr exec_ctx) + f32list ListCeil(f32list src) + f64list ListCeil(f64list src) ## ListFloor Return a new list after performing the floor operation on all elements in the list. - f32list ListFloor(f32list src, ptr exec_ctx) - f64list ListFloor(f64list src, ptr exec_ctx) + f32list ListFloor(f32list src) + f64list ListFloor(f64list src) ## ListRound Return a new list after performing the round operation on all elements in the list. - f32list ListRound(f32list src, ptr exec_ctx) - f64list ListRound(f64list src, ptr exec_ctx) + f32list ListRound(f32list src) + f64list ListRound(f64list src) ## ListMin Return a new list after performing the min operation between each element in the list and a given number. - u8list ListMin(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListMin(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListMin(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListMin(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListMin(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListMin(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListMin(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListMin(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListMin(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListMin(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListMin(u8list lhs, u8 rhs) + u16list ListMin(u16list lhs, u16 rhs) + u32list ListMin(u32list lhs, u32 rhs) + u64list ListMin(u64list lhs, u64 rhs) + i8list ListMin(i8list lhs, i8 rhs) + i16list ListMin(i16list lhs, i16 rhs) + i32list ListMin(i32list lhs, i32 rhs) + i64list ListMin(i64list lhs, i64 rhs) + f32list ListMin(f32list lhs, f32 rhs) + f64list ListMin(f64list lhs, f64 rhs) ## ListMax Return a new list after performing the max operation between each element in the list and a given number. - u8list ListMax(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListMax(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListMax(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListMax(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListMax(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListMax(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListMax(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListMax(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListMax(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListMax(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListMax(u8list lhs, u8 rhs) + u16list ListMax(u16list lhs, u16 rhs) + u32list ListMax(u32list lhs, u32 rhs) + u64list ListMax(u64list lhs, u64 rhs) + i8list ListMax(i8list lhs, i8 rhs) + i16list ListMax(i16list lhs, i16 rhs) + i32list ListMax(i32list lhs, i32 rhs) + i64list ListMax(i64list lhs, i64 rhs) + f32list ListMax(f32list lhs, f32 rhs) + f64list ListMax(f64list lhs, f64 rhs) ## GenLargeBitmap Return a bitmap representation after performing a greater-than comparison on all elements in the list. - u8list GenLargeBitmap(u8list, u8, ptr exec_ctx) - u8list GenLargeBitmap(u16list, u16, ptr exec_ctx) - u8list GenLargeBitmap(u32list, u32, ptr exec_ctx) - u8list GenLargeBitmap(u64list, u64, ptr exec_ctx) - u8list GenLargeBitmap(i8list, i8, ptr exec_ctx) - u8list GenLargeBitmap(i16list, i16, ptr exec_ctx) - u8list GenLargeBitmap(i32list, i32, ptr exec_ctx) - u8list GenLargeBitmap(i64list, i64, ptr exec_ctx) - u8list GenLargeBitmap(f32list, f32, ptr exec_ctx) - u8list GenLargeBitmap(f64list, f64, ptr exec_ctx) + u8list GenLargeBitmap(u8list, u8) + u8list GenLargeBitmap(u16list, u16) + u8list GenLargeBitmap(u32list, u32) + u8list GenLargeBitmap(u64list, u64) + u8list GenLargeBitmap(i8list, i8) + u8list GenLargeBitmap(i16list, i16) + u8list GenLargeBitmap(i32list, i32) + u8list GenLargeBitmap(i64list, i64) + u8list GenLargeBitmap(f32list, f32) + u8list GenLargeBitmap(f64list, f64) Return a bitmap representing the results of greater-than comparisons for each element in the two lists. Both lists must have equal length. - u8list GenLargeBitmap(u8list, u8list, ptr exec_ctx) - u8list GenLargeBitmap(u16list, u16list, ptr exec_ctx) - u8list GenLargeBitmap(u32list, u32list, ptr exec_ctx) - u8list GenLargeBitmap(u64list, u64list, ptr exec_ctx) - u8list GenLargeBitmap(i8list, i8list, ptr exec_ctx) - u8list GenLargeBitmap(i16list, i16list, ptr exec_ctx) - u8list GenLargeBitmap(i32list, i32list, ptr exec_ctx) - u8list GenLargeBitmap(i64list, i64list, ptr exec_ctx) - u8list GenLargeBitmap(f32list, f32list, ptr exec_ctx) - u8list GenLargeBitmap(f64list, f64list, ptr exec_ctx) + u8list GenLargeBitmap(u8list, u8list) + u8list GenLargeBitmap(u16list, u16list) + u8list GenLargeBitmap(u32list, u32list) + u8list GenLargeBitmap(u64list, u64list) + u8list GenLargeBitmap(i8list, i8list) + u8list GenLargeBitmap(i16list, i16list) + u8list GenLargeBitmap(i32list, i32list) + u8list GenLargeBitmap(i64list, i64list) + u8list GenLargeBitmap(f32list, f32list) + u8list GenLargeBitmap(f64list, f64list) ## GenLargeEqualBitmap Return a bitmap representation after performing a greater-than or equal comparison on all elements in the list. - u8list GenLargeEqualBitmap(u8list, u8, ptr exec_ctx) - u8list GenLargeEqualBitmap(u16list, u16, ptr exec_ctx) - u8list GenLargeEqualBitmap(u32list, u32, ptr exec_ctx) - u8list GenLargeEqualBitmap(u64list, u64, ptr exec_ctx) - u8list GenLargeEqualBitmap(i8list, i8, ptr exec_ctx) - u8list GenLargeEqualBitmap(i16list, i16, ptr exec_ctx) - u8list GenLargeEqualBitmap(i32list, i32, ptr exec_ctx) - u8list GenLargeEqualBitmap(i64list, i64, ptr exec_ctx) - u8list GenLargeEqualBitmap(f32list, f32, ptr exec_ctx) - u8list GenLargeEqualBitmap(f64list, f64, ptr exec_ctx) + u8list GenLargeEqualBitmap(u8list, u8) + u8list GenLargeEqualBitmap(u16list, u16) + u8list GenLargeEqualBitmap(u32list, u32) + u8list GenLargeEqualBitmap(u64list, u64) + u8list GenLargeEqualBitmap(i8list, i8) + u8list GenLargeEqualBitmap(i16list, i16) + u8list GenLargeEqualBitmap(i32list, i32) + u8list GenLargeEqualBitmap(i64list, i64) + u8list GenLargeEqualBitmap(f32list, f32) + u8list GenLargeEqualBitmap(f64list, f64) Return a bitmap representing the results of greater-than or equal comparisons for each element in the two lists. Both lists must have equal length. - u8list GenLargeEqualBitmap(u8list, u8list, ptr exec_ctx) - u8list GenLargeEqualBitmap(u16list, u16list, ptr exec_ctx) - u8list GenLargeEqualBitmap(u32list, u32list, ptr exec_ctx) - u8list GenLargeEqualBitmap(u64list, u64list, ptr exec_ctx) - u8list GenLargeEqualBitmap(i8list, i8list, ptr exec_ctx) - u8list GenLargeEqualBitmap(i16list, i16list, ptr exec_ctx) - u8list GenLargeEqualBitmap(i32list, i32list, ptr exec_ctx) - u8list GenLargeEqualBitmap(i64list, i64list, ptr exec_ctx) - u8list GenLargeEqualBitmap(f32list, f32list, ptr exec_ctx) - u8list GenLargeEqualBitmap(f64list, f64list, ptr exec_ctx) + u8list GenLargeEqualBitmap(u8list, u8list) + u8list GenLargeEqualBitmap(u16list, u16list) + u8list GenLargeEqualBitmap(u32list, u32list) + u8list GenLargeEqualBitmap(u64list, u64list) + u8list GenLargeEqualBitmap(i8list, i8list) + u8list GenLargeEqualBitmap(i16list, i16list) + u8list GenLargeEqualBitmap(i32list, i32list) + u8list GenLargeEqualBitmap(i64list, i64list) + u8list GenLargeEqualBitmap(f32list, f32list) + u8list GenLargeEqualBitmap(f64list, f64list) ## GenEqualBitmap Return a bitmap representation after performing a equal comparison on all elements in the list. - u8list GenEqualBitmap(u8list, u8, ptr exec_ctx) - u8list GenEqualBitmap(u16list, u16, ptr exec_ctx) - u8list GenEqualBitmap(u32list, u32, ptr exec_ctx) - u8list GenEqualBitmap(u64list, u64, ptr exec_ctx) - u8list GenEqualBitmap(i8list, i8, ptr exec_ctx) - u8list GenEqualBitmap(i16list, i16, ptr exec_ctx) - u8list GenEqualBitmap(i32list, i32, ptr exec_ctx) - u8list GenEqualBitmap(i64list, i64, ptr exec_ctx) - u8list GenEqualBitmap(f32list, f32, ptr exec_ctx) - u8list GenEqualBitmap(f64list, f64, ptr exec_ctx) + u8list GenEqualBitmap(u8list, u8) + u8list GenEqualBitmap(u16list, u16) + u8list GenEqualBitmap(u32list, u32) + u8list GenEqualBitmap(u64list, u64) + u8list GenEqualBitmap(i8list, i8) + u8list GenEqualBitmap(i16list, i16) + u8list GenEqualBitmap(i32list, i32) + u8list GenEqualBitmap(i64list, i64) + u8list GenEqualBitmap(f32list, f32) + u8list GenEqualBitmap(f64list, f64) Return a bitmap representing the results of equal comparisons for each element in the two lists. Both lists must have equal length. - u8list GenEqualBitmap(u8list, u8list, ptr exec_ctx) - u8list GenEqualBitmap(u16list, u16list, ptr exec_ctx) - u8list GenEqualBitmap(u32list, u32list, ptr exec_ctx) - u8list GenEqualBitmap(u64list, u64list, ptr exec_ctx) - u8list GenEqualBitmap(i8list, i8list, ptr exec_ctx) - u8list GenEqualBitmap(i16list, i16list, ptr exec_ctx) - u8list GenEqualBitmap(i32list, i32list, ptr exec_ctx) - u8list GenEqualBitmap(i64list, i64list, ptr exec_ctx) - u8list GenEqualBitmap(f32list, f32list, ptr exec_ctx) - u8list GenEqualBitmap(f64list, f64list, ptr exec_ctx) + u8list GenEqualBitmap(u8list, u8list) + u8list GenEqualBitmap(u16list, u16list) + u8list GenEqualBitmap(u32list, u32list) + u8list GenEqualBitmap(u64list, u64list) + u8list GenEqualBitmap(i8list, i8list) + u8list GenEqualBitmap(i16list, i16list) + u8list GenEqualBitmap(i32list, i32list) + u8list GenEqualBitmap(i64list, i64list) + u8list GenEqualBitmap(f32list, f32list) + u8list GenEqualBitmap(f64list, f64list) ## GenLessBitmap Return a bitmap representation after performing a less-than comparison on all elements in the list. - u8list GenLessBitmap(u8list, u8, ptr exec_ctx) - u8list GenLessBitmap(u16list, u16, ptr exec_ctx) - u8list GenLessBitmap(u32list, u32, ptr exec_ctx) - u8list GenLessBitmap(u64list, u64, ptr exec_ctx) - u8list GenLessBitmap(i8list, i8, ptr exec_ctx) - u8list GenLessBitmap(i16list, i16, ptr exec_ctx) - u8list GenLessBitmap(i32list, i32, ptr exec_ctx) - u8list GenLessBitmap(i64list, i64, ptr exec_ctx) - u8list GenLessBitmap(f32list, f32, ptr exec_ctx) - u8list GenLessBitmap(f64list, f64, ptr exec_ctx) + u8list GenLessBitmap(u8list, u8) + u8list GenLessBitmap(u16list, u16) + u8list GenLessBitmap(u32list, u32) + u8list GenLessBitmap(u64list, u64) + u8list GenLessBitmap(i8list, i8) + u8list GenLessBitmap(i16list, i16) + u8list GenLessBitmap(i32list, i32) + u8list GenLessBitmap(i64list, i64) + u8list GenLessBitmap(f32list, f32) + u8list GenLessBitmap(f64list, f64) Return a bitmap representing the results of less-than comparisons for each element in the two lists. Both lists must have equal length. - u8list GenLessBitmap(u8list, u8list, ptr exec_ctx) - u8list GenLessBitmap(u16list, u16list, ptr exec_ctx) - u8list GenLessBitmap(u32list, u32list, ptr exec_ctx) - u8list GenLessBitmap(u64list, u64list, ptr exec_ctx) - u8list GenLessBitmap(i8list, i8list, ptr exec_ctx) - u8list GenLessBitmap(i16list, i16list, ptr exec_ctx) - u8list GenLessBitmap(i32list, i32list, ptr exec_ctx) - u8list GenLessBitmap(i64list, i64list, ptr exec_ctx) - u8list GenLessBitmap(f32list, f32list, ptr exec_ctx) - u8list GenLessBitmap(f64list, f64list, ptr exec_ctx) + u8list GenLessBitmap(u8list, u8list) + u8list GenLessBitmap(u16list, u16list) + u8list GenLessBitmap(u32list, u32list) + u8list GenLessBitmap(u64list, u64list) + u8list GenLessBitmap(i8list, i8list) + u8list GenLessBitmap(i16list, i16list) + u8list GenLessBitmap(i32list, i32list) + u8list GenLessBitmap(i64list, i64list) + u8list GenLessBitmap(f32list, f32list) + u8list GenLessBitmap(f64list, f64list) ## GenLessEqualBitmap Return a bitmap representation after performing a less-than or equal comparison on all elements in the list. - u8list GenLessEqualBitmap(u8list, u8, ptr exec_ctx) - u8list GenLessEqualBitmap(u16list, u16, ptr exec_ctx) - u8list GenLessEqualBitmap(u32list, u32, ptr exec_ctx) - u8list GenLessEqualBitmap(u64list, u64, ptr exec_ctx) - u8list GenLessEqualBitmap(i8list, i8, ptr exec_ctx) - u8list GenLessEqualBitmap(i16list, i16, ptr exec_ctx) - u8list GenLessEqualBitmap(i32list, i32, ptr exec_ctx) - u8list GenLessEqualBitmap(i64list, i64, ptr exec_ctx) - u8list GenLessEqualBitmap(f32list, f32, ptr exec_ctx) - u8list GenLessEqualBitmap(f64list, f64, ptr exec_ctx) + u8list GenLessEqualBitmap(u8list, u8) + u8list GenLessEqualBitmap(u16list, u16) + u8list GenLessEqualBitmap(u32list, u32) + u8list GenLessEqualBitmap(u64list, u64) + u8list GenLessEqualBitmap(i8list, i8) + u8list GenLessEqualBitmap(i16list, i16) + u8list GenLessEqualBitmap(i32list, i32) + u8list GenLessEqualBitmap(i64list, i64) + u8list GenLessEqualBitmap(f32list, f32) + u8list GenLessEqualBitmap(f64list, f64) Return a bitmap representing the results of less-than or equal comparisons for each element in the two lists. Both lists must have equal length. - u8list GenLessEqualBitmap(u8list, u8list, ptr exec_ctx) - u8list GenLessEqualBitmap(u16list, u16list, ptr exec_ctx) - u8list GenLessEqualBitmap(u32list, u32list, ptr exec_ctx) - u8list GenLessEqualBitmap(u64list, u64list, ptr exec_ctx) - u8list GenLessEqualBitmap(i8list, i8list, ptr exec_ctx) - u8list GenLessEqualBitmap(i16list, i16list, ptr exec_ctx) - u8list GenLessEqualBitmap(i32list, i32list, ptr exec_ctx) - u8list GenLessEqualBitmap(i64list, i64list, ptr exec_ctx) - u8list GenLessEqualBitmap(f32list, f32list, ptr exec_ctx) - u8list GenLessEqualBitmap(f64list, f64list, ptr exec_ctx) + u8list GenLessEqualBitmap(u8list, u8list) + u8list GenLessEqualBitmap(u16list, u16list) + u8list GenLessEqualBitmap(u32list, u32list) + u8list GenLessEqualBitmap(u64list, u64list) + u8list GenLessEqualBitmap(i8list, i8list) + u8list GenLessEqualBitmap(i16list, i16list) + u8list GenLessEqualBitmap(i32list, i32list) + u8list GenLessEqualBitmap(i64list, i64list) + u8list GenLessEqualBitmap(f32list, f32list) + u8list GenLessEqualBitmap(f64list, f64list) ## GenNotEqualBitmap Return a bitmap representation after performing a not equal comparison on all elements in the list. - u8list GenNotEqualBitmap(u8list, u8, ptr exec_ctx) - u8list GenNotEqualBitmap(u16list, u16, ptr exec_ctx) - u8list GenNotEqualBitmap(u32list, u32, ptr exec_ctx) - u8list GenNotEqualBitmap(u64list, u64, ptr exec_ctx) - u8list GenNotEqualBitmap(i8list, i8, ptr exec_ctx) - u8list GenNotEqualBitmap(i16list, i16, ptr exec_ctx) - u8list GenNotEqualBitmap(i32list, i32, ptr exec_ctx) - u8list GenNotEqualBitmap(i64list, i64, ptr exec_ctx) - u8list GenNotEqualBitmap(f32list, f32, ptr exec_ctx) - u8list GenNotEqualBitmap(f64list, f64, ptr exec_ctx) + u8list GenNotEqualBitmap(u8list, u8) + u8list GenNotEqualBitmap(u16list, u16) + u8list GenNotEqualBitmap(u32list, u32) + u8list GenNotEqualBitmap(u64list, u64) + u8list GenNotEqualBitmap(i8list, i8) + u8list GenNotEqualBitmap(i16list, i16) + u8list GenNotEqualBitmap(i32list, i32) + u8list GenNotEqualBitmap(i64list, i64) + u8list GenNotEqualBitmap(f32list, f32) + u8list GenNotEqualBitmap(f64list, f64) Return a bitmap representing the results of not equal comparisons for each element in the two lists. Both lists must have equal length. - u8list GenNotEqualBitmap(u8list, u8list, ptr exec_ctx) - u8list GenNotEqualBitmap(u16list, u16list, ptr exec_ctx) - u8list GenNotEqualBitmap(u32list, u32list, ptr exec_ctx) - u8list GenNotEqualBitmap(u64list, u64list, ptr exec_ctx) - u8list GenNotEqualBitmap(i8list, i8list, ptr exec_ctx) - u8list GenNotEqualBitmap(i16list, i16list, ptr exec_ctx) - u8list GenNotEqualBitmap(i32list, i32list, ptr exec_ctx) - u8list GenNotEqualBitmap(i64list, i64list, ptr exec_ctx) - u8list GenNotEqualBitmap(f32list, f32list, ptr exec_ctx) - u8list GenNotEqualBitmap(f64list, f64list, ptr exec_ctx) + u8list GenNotEqualBitmap(u8list, u8list) + u8list GenNotEqualBitmap(u16list, u16list) + u8list GenNotEqualBitmap(u32list, u32list) + u8list GenNotEqualBitmap(u64list, u64list) + u8list GenNotEqualBitmap(i8list, i8list) + u8list GenNotEqualBitmap(i16list, i16list) + u8list GenNotEqualBitmap(i32list, i32list) + u8list GenNotEqualBitmap(i64list, i64list) + u8list GenNotEqualBitmap(f32list, f32list) + u8list GenNotEqualBitmap(f64list, f64list) ## FilterByBitmap Return a new list by filtering out the corresponding elements based on the bitmap. - u8list FilterByBitmap(u8list src, u8list bitmap, ptr exec_ctx) - u16list FilterByBitmap(u16list src, u8list bitmap, ptr exec_ctx) - u32list FilterByBitmap(u32list src, u8list bitmap, ptr exec_ctx) - u64list FilterByBitmap(u64list src, u8list bitmap, ptr exec_ctx) - i8list FilterByBitmap(i8list src, u8list bitmap, ptr exec_ctx) - i16list FilterByBitmap(i16list src, u8list bitmap, ptr exec_ctx) - i32list FilterByBitmap(i32list src, u8list bitmap, ptr exec_ctx) - i64list FilterByBitmap(i64list src, u8list bitmap, ptr exec_ctx) - f32list FilterByBitmap(f32list src, u8list bitmap, ptr exec_ctx) - f64list FilterByBitmap(f64list src, u8list bitmap, ptr exec_ctx) + u8list FilterByBitmap(u8list src, u8list bitmap) + u16list FilterByBitmap(u16list src, u8list bitmap) + u32list FilterByBitmap(u32list src, u8list bitmap) + u64list FilterByBitmap(u64list src, u8list bitmap) + i8list FilterByBitmap(i8list src, u8list bitmap) + i16list FilterByBitmap(i16list src, u8list bitmap) + i32list FilterByBitmap(i32list src, u8list bitmap) + i64list FilterByBitmap(i64list src, u8list bitmap) + f32list FilterByBitmap(f32list src, u8list bitmap) + f64list FilterByBitmap(f64list src, u8list bitmap) ## CountBits Count the number of 1s in the bitmap. @@ -1123,122 +1123,122 @@ Count the number of 1s in the bitmap. ## IfLarge Traverse the list to find all values that meet the condition of being greater than the specified value, modify them to the target value, and return a new list. - u8list IfLarge(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfLarge(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfLarge(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfLarge(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfLarge(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfLarge(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfLarge(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfLarge(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfLarge(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfLarge(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfLarge(u8list src, u8 cmp_value, u8 target_value) + u16list IfLarge(u16list src, u16 cmp_value, u16 target_value) + u32list IfLarge(u32list src, u32 cmp_value, u32 target_value) + u64list IfLarge(u64list src, u64 cmp_value, u64 target_value) + i8list IfLarge(i8list src, i8 cmp_value, i8 target_value) + i16list IfLarge(i16list src, i16 cmp_value, i16 target_value) + i32list IfLarge(i32list src, i32 cmp_value, i32 target_value) + i64list IfLarge(i64list src, i64 cmp_value, i64 target_value) + f32list IfLarge(f32list src, f32 cmp_value, f32 target_value) + f64list IfLarge(f64list src, f64 cmp_value, f64 target_value) ## IfLargeEqual Traverse the list to find all values that meet the condition of being greater than or equal to the specified value, modify them to the target value, and return a new list. - u8list IfLargeEqual(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfLargeEqual(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfLargeEqual(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfLargeEqual(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfLargeEqual(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfLargeEqual(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfLargeEqual(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfLargeEqual(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfLargeEqual(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfLargeEqual(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfLargeEqual(u8list src, u8 cmp_value, u8 target_value) + u16list IfLargeEqual(u16list src, u16 cmp_value, u16 target_value) + u32list IfLargeEqual(u32list src, u32 cmp_value, u32 target_value) + u64list IfLargeEqual(u64list src, u64 cmp_value, u64 target_value) + i8list IfLargeEqual(i8list src, i8 cmp_value, i8 target_value) + i16list IfLargeEqual(i16list src, i16 cmp_value, i16 target_value) + i32list IfLargeEqual(i32list src, i32 cmp_value, i32 target_value) + i64list IfLargeEqual(i64list src, i64 cmp_value, i64 target_value) + f32list IfLargeEqual(f32list src, f32 cmp_value, f32 target_value) + f64list IfLargeEqual(f64list src, f64 cmp_value, f64 target_value) ## IfEqual Traverse the list to find all values that meet the condition of being equal to the specified value, modify them to the target value, and return a new list. - u8list IfEqual(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfEqual(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfEqual(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfEqual(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfEqual(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfEqual(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfEqual(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfEqual(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfEqual(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfEqual(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfEqual(u8list src, u8 cmp_value, u8 target_value) + u16list IfEqual(u16list src, u16 cmp_value, u16 target_value) + u32list IfEqual(u32list src, u32 cmp_value, u32 target_value) + u64list IfEqual(u64list src, u64 cmp_value, u64 target_value) + i8list IfEqual(i8list src, i8 cmp_value, i8 target_value) + i16list IfEqual(i16list src, i16 cmp_value, i16 target_value) + i32list IfEqual(i32list src, i32 cmp_value, i32 target_value) + i64list IfEqual(i64list src, i64 cmp_value, i64 target_value) + f32list IfEqual(f32list src, f32 cmp_value, f32 target_value) + f64list IfEqual(f64list src, f64 cmp_value, f64 target_value) ## IfLess Traverse the list to find all values that meet the condition of being less than the specified value, modify them to the target value, and return a new list. - u8list IfLess(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfLess(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfLess(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfLess(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfLess(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfLess(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfLess(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfLess(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfLess(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfLess(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfLess(u8list src, u8 cmp_value, u8 target_value) + u16list IfLess(u16list src, u16 cmp_value, u16 target_value) + u32list IfLess(u32list src, u32 cmp_value, u32 target_value) + u64list IfLess(u64list src, u64 cmp_value, u64 target_value) + i8list IfLess(i8list src, i8 cmp_value, i8 target_value) + i16list IfLess(i16list src, i16 cmp_value, i16 target_value) + i32list IfLess(i32list src, i32 cmp_value, i32 target_value) + i64list IfLess(i64list src, i64 cmp_value, i64 target_value) + f32list IfLess(f32list src, f32 cmp_value, f32 target_value) + f64list IfLess(f64list src, f64 cmp_value, f64 target_value) ## IfLessEqual Traverse the list to find all values that meet the condition of being less than or equal to the specified value, modify them to the target value, and return a new list. - u8list IfLessEqual(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfLessEqual(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfLessEqual(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfLessEqual(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfLessEqual(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfLessEqual(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfLessEqual(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfLessEqual(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfLessEqual(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfLessEqual(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfLessEqual(u8list src, u8 cmp_value, u8 target_value) + u16list IfLessEqual(u16list src, u16 cmp_value, u16 target_value) + u32list IfLessEqual(u32list src, u32 cmp_value, u32 target_value) + u64list IfLessEqual(u64list src, u64 cmp_value, u64 target_value) + i8list IfLessEqual(i8list src, i8 cmp_value, i8 target_value) + i16list IfLessEqual(i16list src, i16 cmp_value, i16 target_value) + i32list IfLessEqual(i32list src, i32 cmp_value, i32 target_value) + i64list IfLessEqual(i64list src, i64 cmp_value, i64 target_value) + f32list IfLessEqual(f32list src, f32 cmp_value, f32 target_value) + f64list IfLessEqual(f64list src, f64 cmp_value, f64 target_value) ## IfNotEqual Traverse the list to find all values that meet the condition of being not equal to the specified value, modify them to the target value, and return a new list. - u8list IfNotEqual(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfNotEqual(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfNotEqual(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfNotEqual(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfNotEqual(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfNotEqual(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfNotEqual(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfNotEqual(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfNotEqual(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfNotEqual(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfNotEqual(u8list src, u8 cmp_value, u8 target_value) + u16list IfNotEqual(u16list src, u16 cmp_value, u16 target_value) + u32list IfNotEqual(u32list src, u32 cmp_value, u32 target_value) + u64list IfNotEqual(u64list src, u64 cmp_value, u64 target_value) + i8list IfNotEqual(i8list src, i8 cmp_value, i8 target_value) + i16list IfNotEqual(i16list src, i16 cmp_value, i16 target_value) + i32list IfNotEqual(i32list src, i32 cmp_value, i32 target_value) + i64list IfNotEqual(i64list src, i64 cmp_value, i64 target_value) + f32list IfNotEqual(f32list src, f32 cmp_value, f32 target_value) + f64list IfNotEqual(f64list src, f64 cmp_value, f64 target_value) ## IfByBitmap Return a new list based on the values from the bitmap. - u8list IfByBitmap(u8list bitmap, u8list lhs, u8 rhs, ptr exec_ctx) - u16list IfByBitmap(u8list bitmap, u16list lhs, u16 rhs, ptr exec_ctx) - u32list IfByBitmap(u8list bitmap, u32list lhs, u32 rhs, ptr exec_ctx) - u64list IfByBitmap(u8list bitmap, u64list lhs, u64 rhs, ptr exec_ctx) - i8list IfByBitmap(u8list bitmap, i8list lhs, i8 rhs, ptr exec_ctx) - i16list IfByBitmap(u8list bitmap, i16list lhs, i16 rhs, ptr exec_ctx) - i32list IfByBitmap(u8list bitmap, i32list lhs, i32 rhs, ptr exec_ctx) - i64list IfByBitmap(u8list bitmap, i64list lhs, i64 rhs, ptr exec_ctx) - f32list IfByBitmap(u8list bitmap, f32list lhs, f32 rhs, ptr exec_ctx) - f64list IfByBitmap(u8list bitmap, f64list lhs, f64 rhs, ptr exec_ctx) - - u8list IfByBitmap(u8list bitmap, u8 lhs, u8list rhs, ptr exec_ctx) - u16list IfByBitmap(u8list bitmap, u16 lhs, u16list rhs, ptr exec_ctx) - u32list IfByBitmap(u8list bitmap, u32 lhs, u32list rhs, ptr exec_ctx) - u64list IfByBitmap(u8list bitmap, u64 lhs, u64list rhs, ptr exec_ctx) - i8list IfByBitmap(u8list bitmap, i8 lhs, i8list rhs, ptr exec_ctx) - i16list IfByBitmap(u8list bitmap, i16 lhs, i16list rhs, ptr exec_ctx) - i32list IfByBitmap(u8list bitmap, i32 lhs, i32list rhs, ptr exec_ctx) - i64list IfByBitmap(u8list bitmap, i64 lhs, i64list rhs, ptr exec_ctx) - f32list IfByBitmap(u8list bitmap, f32 lhs, f32list rhs, ptr exec_ctx) - f64list IfByBitmap(u8list bitmap, f64 lhs, f64list rhs, ptr exec_ctx) - - u8list IfByBitmap(u8list bitmap, u8list lhs, u8list rhs, ptr exec_ctx) - u16list IfByBitmap(u8list bitmap, u16list lhs, u16list rhs, ptr exec_ctx) - u32list IfByBitmap(u8list bitmap, u32list lhs, u32list rhs, ptr exec_ctx) - u64list IfByBitmap(u8list bitmap, u64list lhs, u64list rhs, ptr exec_ctx) - i8list IfByBitmap(u8list bitmap, i8list lhs, i8list rhs, ptr exec_ctx) - i16list IfByBitmap(u8list bitmap, i16list lhs, i16list rhs, ptr exec_ctx) - i32list IfByBitmap(u8list bitmap, i32list lhs, i32list rhs, ptr exec_ctx) - i64list IfByBitmap(u8list bitmap, i64list lhs, i64list rhs, ptr exec_ctx) - f32list IfByBitmap(u8list bitmap, f32list lhs, f32list rhs, ptr exec_ctx) - f64list IfByBitmap(u8list bitmap, f64list lhs, f64list rhs, ptr exec_ctx) + u8list IfByBitmap(u8list bitmap, u8list lhs, u8 rhs) + u16list IfByBitmap(u8list bitmap, u16list lhs, u16 rhs) + u32list IfByBitmap(u8list bitmap, u32list lhs, u32 rhs) + u64list IfByBitmap(u8list bitmap, u64list lhs, u64 rhs) + i8list IfByBitmap(u8list bitmap, i8list lhs, i8 rhs) + i16list IfByBitmap(u8list bitmap, i16list lhs, i16 rhs) + i32list IfByBitmap(u8list bitmap, i32list lhs, i32 rhs) + i64list IfByBitmap(u8list bitmap, i64list lhs, i64 rhs) + f32list IfByBitmap(u8list bitmap, f32list lhs, f32 rhs) + f64list IfByBitmap(u8list bitmap, f64list lhs, f64 rhs) + + u8list IfByBitmap(u8list bitmap, u8 lhs, u8list rhs) + u16list IfByBitmap(u8list bitmap, u16 lhs, u16list rhs) + u32list IfByBitmap(u8list bitmap, u32 lhs, u32list rhs) + u64list IfByBitmap(u8list bitmap, u64 lhs, u64list rhs) + i8list IfByBitmap(u8list bitmap, i8 lhs, i8list rhs) + i16list IfByBitmap(u8list bitmap, i16 lhs, i16list rhs) + i32list IfByBitmap(u8list bitmap, i32 lhs, i32list rhs) + i64list IfByBitmap(u8list bitmap, i64 lhs, i64list rhs) + f32list IfByBitmap(u8list bitmap, f32 lhs, f32list rhs) + f64list IfByBitmap(u8list bitmap, f64 lhs, f64list rhs) + + u8list IfByBitmap(u8list bitmap, u8list lhs, u8list rhs) + u16list IfByBitmap(u8list bitmap, u16list lhs, u16list rhs) + u32list IfByBitmap(u8list bitmap, u32list lhs, u32list rhs) + u64list IfByBitmap(u8list bitmap, u64list lhs, u64list rhs) + i8list IfByBitmap(u8list bitmap, i8list lhs, i8list rhs) + i16list IfByBitmap(u8list bitmap, i16list lhs, i16list rhs) + i32list IfByBitmap(u8list bitmap, i32list lhs, i32list rhs) + i64list IfByBitmap(u8list bitmap, i64list lhs, i64list rhs) + f32list IfByBitmap(u8list bitmap, f32list lhs, f32list rhs) + f64list IfByBitmap(u8list bitmap, f64list lhs, f64list rhs) ## MurmurHash3X8632 MurmurHash3_x86_32 algorithm @@ -1259,145 +1259,145 @@ List Type Conversion Functions. Cast a list from one element type to another. Numeric/String list to numeric list conversion: - u8list CastU8List(i8list src, ptr exec_ctx) - u8list CastU8List(u16list src, ptr exec_ctx) - u8list CastU8List(i16list src, ptr exec_ctx) - u8list CastU8List(u32list src, ptr exec_ctx) - u8list CastU8List(i32list src, ptr exec_ctx) - u8list CastU8List(u64list src, ptr exec_ctx) - u8list CastU8List(i64list src, ptr exec_ctx) - u8list CastU8List(f32list src, ptr exec_ctx) - u8list CastU8List(f64list src, ptr exec_ctx) - u8list CastU8List(stringlist src, ptr exec_ctx) - - i8list CastI8List(u8list src, ptr exec_ctx) - i8list CastI8List(u16list src, ptr exec_ctx) - i8list CastI8List(i16list src, ptr exec_ctx) - i8list CastI8List(u32list src, ptr exec_ctx) - i8list CastI8List(i32list src, ptr exec_ctx) - i8list CastI8List(u64list src, ptr exec_ctx) - i8list CastI8List(i64list src, ptr exec_ctx) - i8list CastI8List(f32list src, ptr exec_ctx) - i8list CastI8List(f64list src, ptr exec_ctx) - i8list CastI8List(stringlist src, ptr exec_ctx) - - u16list CastU16List(u8list src, ptr exec_ctx) - u16list CastU16List(i8list src, ptr exec_ctx) - u16list CastU16List(i16list src, ptr exec_ctx) - u16list CastU16List(u32list src, ptr exec_ctx) - u16list CastU16List(i32list src, ptr exec_ctx) - u16list CastU16List(u64list src, ptr exec_ctx) - u16list CastU16List(i64list src, ptr exec_ctx) - u16list CastU16List(f32list src, ptr exec_ctx) - u16list CastU16List(f64list src, ptr exec_ctx) - u16list CastU16List(stringlist src, ptr exec_ctx) - - i16list CastI16List(u8list src, ptr exec_ctx) - i16list CastI16List(i8list src, ptr exec_ctx) - i16list CastI16List(u16list src, ptr exec_ctx) - i16list CastI16List(u32list src, ptr exec_ctx) - i16list CastI16List(i32list src, ptr exec_ctx) - i16list CastI16List(u64list src, ptr exec_ctx) - i16list CastI16List(i64list src, ptr exec_ctx) - i16list CastI16List(f32list src, ptr exec_ctx) - i16list CastI16List(f64list src, ptr exec_ctx) - i16list CastI16List(stringlist src, ptr exec_ctx) - - u32list CastU32List(u8list src, ptr exec_ctx) - u32list CastU32List(i8list src, ptr exec_ctx) - u32list CastU32List(u16list src, ptr exec_ctx) - u32list CastU32List(i16list src, ptr exec_ctx) - u32list CastU32List(i32list src, ptr exec_ctx) - u32list CastU32List(u64list src, ptr exec_ctx) - u32list CastU32List(i64list src, ptr exec_ctx) - u32list CastU32List(f32list src, ptr exec_ctx) - u32list CastU32List(f64list src, ptr exec_ctx) - u32list CastU32List(stringlist src, ptr exec_ctx) - - i32list CastI32List(u8list src, ptr exec_ctx) - i32list CastI32List(i8list src, ptr exec_ctx) - i32list CastI32List(u16list src, ptr exec_ctx) - i32list CastI32List(i16list src, ptr exec_ctx) - i32list CastI32List(u32list src, ptr exec_ctx) - i32list CastI32List(u64list src, ptr exec_ctx) - i32list CastI32List(i64list src, ptr exec_ctx) - i32list CastI32List(f32list src, ptr exec_ctx) - i32list CastI32List(f64list src, ptr exec_ctx) - i32list CastI32List(stringlist src, ptr exec_ctx) - - u64list CastU64List(u8list src, ptr exec_ctx) - u64list CastU64List(i8list src, ptr exec_ctx) - u64list CastU64List(u16list src, ptr exec_ctx) - u64list CastU64List(i16list src, ptr exec_ctx) - u64list CastU64List(u32list src, ptr exec_ctx) - u64list CastU64List(i32list src, ptr exec_ctx) - u64list CastU64List(i64list src, ptr exec_ctx) - u64list CastU64List(f32list src, ptr exec_ctx) - u64list CastU64List(f64list src, ptr exec_ctx) - u64list CastU64List(stringlist src, ptr exec_ctx) - - i64list CastI64List(u8list src, ptr exec_ctx) - i64list CastI64List(i8list src, ptr exec_ctx) - i64list CastI64List(u16list src, ptr exec_ctx) - i64list CastI64List(i16list src, ptr exec_ctx) - i64list CastI64List(u32list src, ptr exec_ctx) - i64list CastI64List(i32list src, ptr exec_ctx) - i64list CastI64List(u64list src, ptr exec_ctx) - i64list CastI64List(f32list src, ptr exec_ctx) - i64list CastI64List(f64list src, ptr exec_ctx) - i64list CastI64List(stringlist src, ptr exec_ctx) - - f32list CastF32List(u8list src, ptr exec_ctx) - f32list CastF32List(i8list src, ptr exec_ctx) - f32list CastF32List(u16list src, ptr exec_ctx) - f32list CastF32List(i16list src, ptr exec_ctx) - f32list CastF32List(u32list src, ptr exec_ctx) - f32list CastF32List(i32list src, ptr exec_ctx) - f32list CastF32List(u64list src, ptr exec_ctx) - f32list CastF32List(i64list src, ptr exec_ctx) - f32list CastF32List(f64list src, ptr exec_ctx) - - f64list CastF64List(u8list src, ptr exec_ctx) - f64list CastF64List(i8list src, ptr exec_ctx) - f64list CastF64List(u16list src, ptr exec_ctx) - f64list CastF64List(i16list src, ptr exec_ctx) - f64list CastF64List(u32list src, ptr exec_ctx) - f64list CastF64List(i32list src, ptr exec_ctx) - f64list CastF64List(u64list src, ptr exec_ctx) - f64list CastF64List(i64list src, ptr exec_ctx) - f64list CastF64List(f32list src, ptr exec_ctx) + u8list CastU8List(i8list src) + u8list CastU8List(u16list src) + u8list CastU8List(i16list src) + u8list CastU8List(u32list src) + u8list CastU8List(i32list src) + u8list CastU8List(u64list src) + u8list CastU8List(i64list src) + u8list CastU8List(f32list src) + u8list CastU8List(f64list src) + u8list CastU8List(stringlist src) + + i8list CastI8List(u8list src) + i8list CastI8List(u16list src) + i8list CastI8List(i16list src) + i8list CastI8List(u32list src) + i8list CastI8List(i32list src) + i8list CastI8List(u64list src) + i8list CastI8List(i64list src) + i8list CastI8List(f32list src) + i8list CastI8List(f64list src) + i8list CastI8List(stringlist src) + + u16list CastU16List(u8list src) + u16list CastU16List(i8list src) + u16list CastU16List(i16list src) + u16list CastU16List(u32list src) + u16list CastU16List(i32list src) + u16list CastU16List(u64list src) + u16list CastU16List(i64list src) + u16list CastU16List(f32list src) + u16list CastU16List(f64list src) + u16list CastU16List(stringlist src) + + i16list CastI16List(u8list src) + i16list CastI16List(i8list src) + i16list CastI16List(u16list src) + i16list CastI16List(u32list src) + i16list CastI16List(i32list src) + i16list CastI16List(u64list src) + i16list CastI16List(i64list src) + i16list CastI16List(f32list src) + i16list CastI16List(f64list src) + i16list CastI16List(stringlist src) + + u32list CastU32List(u8list src) + u32list CastU32List(i8list src) + u32list CastU32List(u16list src) + u32list CastU32List(i16list src) + u32list CastU32List(i32list src) + u32list CastU32List(u64list src) + u32list CastU32List(i64list src) + u32list CastU32List(f32list src) + u32list CastU32List(f64list src) + u32list CastU32List(stringlist src) + + i32list CastI32List(u8list src) + i32list CastI32List(i8list src) + i32list CastI32List(u16list src) + i32list CastI32List(i16list src) + i32list CastI32List(u32list src) + i32list CastI32List(u64list src) + i32list CastI32List(i64list src) + i32list CastI32List(f32list src) + i32list CastI32List(f64list src) + i32list CastI32List(stringlist src) + + u64list CastU64List(u8list src) + u64list CastU64List(i8list src) + u64list CastU64List(u16list src) + u64list CastU64List(i16list src) + u64list CastU64List(u32list src) + u64list CastU64List(i32list src) + u64list CastU64List(i64list src) + u64list CastU64List(f32list src) + u64list CastU64List(f64list src) + u64list CastU64List(stringlist src) + + i64list CastI64List(u8list src) + i64list CastI64List(i8list src) + i64list CastI64List(u16list src) + i64list CastI64List(i16list src) + i64list CastI64List(u32list src) + i64list CastI64List(i32list src) + i64list CastI64List(u64list src) + i64list CastI64List(f32list src) + i64list CastI64List(f64list src) + i64list CastI64List(stringlist src) + + f32list CastF32List(u8list src) + f32list CastF32List(i8list src) + f32list CastF32List(u16list src) + f32list CastF32List(i16list src) + f32list CastF32List(u32list src) + f32list CastF32List(i32list src) + f32list CastF32List(u64list src) + f32list CastF32List(i64list src) + f32list CastF32List(f64list src) + + f64list CastF64List(u8list src) + f64list CastF64List(i8list src) + f64list CastF64List(u16list src) + f64list CastF64List(i16list src) + f64list CastF64List(u32list src) + f64list CastF64List(i32list src) + f64list CastF64List(u64list src) + f64list CastF64List(i64list src) + f64list CastF64List(f32list src) Note: CastF32List and CastF64List do not support stringlist input. String to integer list conversion uses std::from_chars internally. String to floating-point list conversion is not supported in C++17. Numeric list to string list conversion: - stringlist CastStringList(u8list src, ptr exec_ctx) - stringlist CastStringList(i8list src, ptr exec_ctx) - stringlist CastStringList(u16list src, ptr exec_ctx) - stringlist CastStringList(i16list src, ptr exec_ctx) - stringlist CastStringList(u32list src, ptr exec_ctx) - stringlist CastStringList(i32list src, ptr exec_ctx) - stringlist CastStringList(u64list src, ptr exec_ctx) - stringlist CastStringList(i64list src, ptr exec_ctx) - stringlist CastStringList(f32list src, ptr exec_ctx) - stringlist CastStringList(f64list src, ptr exec_ctx) + stringlist CastStringList(u8list src) + stringlist CastStringList(i8list src) + stringlist CastStringList(u16list src) + stringlist CastStringList(i16list src) + stringlist CastStringList(u32list src) + stringlist CastStringList(i32list src) + stringlist CastStringList(u64list src) + stringlist CastStringList(i64list src) + stringlist CastStringList(f32list src) + stringlist CastStringList(f64list src) ## ListLookupIndex Given two lists `a` and `b` of the same element type, for each element in `a` return the position of its first occurrence in `b`. When an element of `a` is not found in `b`, the result entry is set to `u32max` (`std::numeric_limits::max()`) as a miss sentinel. Internally a hash table over `b` is built, so the per-element lookup is amortised O(1). The output length always equals `a.len`. - u32list ListLookupIndex(u8list a, u8list b, ptr exec_ctx) - u32list ListLookupIndex(i8list a, i8list b, ptr exec_ctx) - u32list ListLookupIndex(u16list a, u16list b, ptr exec_ctx) - u32list ListLookupIndex(i16list a, i16list b, ptr exec_ctx) - u32list ListLookupIndex(u32list a, u32list b, ptr exec_ctx) - u32list ListLookupIndex(i32list a, i32list b, ptr exec_ctx) - u32list ListLookupIndex(u64list a, u64list b, ptr exec_ctx) - u32list ListLookupIndex(i64list a, i64list b, ptr exec_ctx) - u32list ListLookupIndex(f32list a, f32list b, ptr exec_ctx) - u32list ListLookupIndex(f64list a, f64list b, ptr exec_ctx) - u32list ListLookupIndex(stringlist a, stringlist b, ptr exec_ctx) + u32list ListLookupIndex(u8list a, u8list b) + u32list ListLookupIndex(i8list a, i8list b) + u32list ListLookupIndex(u16list a, u16list b) + u32list ListLookupIndex(i16list a, i16list b) + u32list ListLookupIndex(u32list a, u32list b) + u32list ListLookupIndex(i32list a, i32list b) + u32list ListLookupIndex(u64list a, u64list b) + u32list ListLookupIndex(i64list a, i64list b) + u32list ListLookupIndex(f32list a, f32list b) + u32list ListLookupIndex(f64list a, f64list b) + u32list ListLookupIndex(stringlist a, stringlist b) ## Find Return the index of the first occurrence of `value` in the list. Returns `u32max` (`std::numeric_limits::max()`) when the value is not found. This is the scalar counterpart of `ListLookupIndex` and composes naturally with `GetAt`: `GetAt(values, Find(keys, k))` performs a scalar join (miss falls through to `GetAt`'s out-of-bounds default of zero/empty). @@ -1442,31 +1442,31 @@ Takes a `u32list` produced by `ListLookupIndex` and returns the positions in `a` Output length equals the number of hits; preserves the original order. - u32list ListCompactPositions(u32list raw, ptr exec_ctx) + u32list ListCompactPositions(u32list raw) ## ListCompactIndex Takes a `u32list` produced by `ListLookupIndex` and returns the looked-up b-side indices themselves, skipping miss entries. Useful for directly gathering a b-side column aligned to the hit subset of a. Output length equals the number of hits; preserves the original order. - u32list ListCompactIndex(u32list raw, ptr exec_ctx) + u32list ListCompactIndex(u32list raw) ## ListGather Element-wise gather from a `values` list using a `u32list` of positions. For each `k`, if `idx[k] < values.len` the output is `values[idx[k]]`, otherwise it is the supplied `default_value`. This is the typical "realign a b-side column to the a-side shape" kernel of a join. The output length always equals `idx.len`. - u8list ListGather(u8list values, u32list idx, u8 default_value, ptr exec_ctx) - i8list ListGather(i8list values, u32list idx, i8 default_value, ptr exec_ctx) - u16list ListGather(u16list values, u32list idx, u16 default_value, ptr exec_ctx) - i16list ListGather(i16list values, u32list idx, i16 default_value, ptr exec_ctx) - u32list ListGather(u32list values, u32list idx, u32 default_value, ptr exec_ctx) - i32list ListGather(i32list values, u32list idx, i32 default_value, ptr exec_ctx) - u64list ListGather(u64list values, u32list idx, u64 default_value, ptr exec_ctx) - i64list ListGather(i64list values, u32list idx, i64 default_value, ptr exec_ctx) - f32list ListGather(f32list values, u32list idx, f32 default_value, ptr exec_ctx) - f64list ListGather(f64list values, u32list idx, f64 default_value, ptr exec_ctx) - stringlist ListGather(stringlist values, u32list idx, string default_value, ptr exec_ctx) + u8list ListGather(u8list values, u32list idx, u8 default_value) + i8list ListGather(i8list values, u32list idx, i8 default_value) + u16list ListGather(u16list values, u32list idx, u16 default_value) + i16list ListGather(i16list values, u32list idx, i16 default_value) + u32list ListGather(u32list values, u32list idx, u32 default_value) + i32list ListGather(i32list values, u32list idx, i32 default_value) + u64list ListGather(u64list values, u32list idx, u64 default_value) + i64list ListGather(i64list values, u32list idx, i64 default_value) + f32list ListGather(f32list values, u32list idx, f32 default_value) + f64list ListGather(f64list values, u32list idx, f64 default_value) + stringlist ListGather(stringlist values, u32list idx, string default_value) ## Bucketize Classify each element of `values` into a half-open bin defined by an @@ -1492,13 +1492,13 @@ i.e. left-closed / right-open. Result has the same length as `values`. Implementation is `std::lower_bound`, O(log n) per value. - u32list Bucketize(u8list values, u8list boundaries, ptr exec_ctx) - u32list Bucketize(i8list values, i8list boundaries, ptr exec_ctx) - u32list Bucketize(u16list values, u16list boundaries, ptr exec_ctx) - u32list Bucketize(i16list values, i16list boundaries, ptr exec_ctx) - u32list Bucketize(u32list values, u32list boundaries, ptr exec_ctx) - u32list Bucketize(i32list values, i32list boundaries, ptr exec_ctx) - u32list Bucketize(u64list values, u64list boundaries, ptr exec_ctx) - u32list Bucketize(i64list values, i64list boundaries, ptr exec_ctx) - u32list Bucketize(f32list values, f32list boundaries, ptr exec_ctx) - u32list Bucketize(f64list values, f64list boundaries, ptr exec_ctx) + u32list Bucketize(u8list values, u8list boundaries) + u32list Bucketize(i8list values, i8list boundaries) + u32list Bucketize(u16list values, u16list boundaries) + u32list Bucketize(i16list values, i16list boundaries) + u32list Bucketize(u32list values, u32list boundaries) + u32list Bucketize(i32list values, i32list boundaries) + u32list Bucketize(u64list values, u64list boundaries) + u32list Bucketize(i64list values, i64list boundaries) + u32list Bucketize(f32list values, f32list boundaries) + u32list Bucketize(f64list values, f64list boundaries) diff --git a/include/function_registry.h b/include/function_registry.h index 2ba36d4..d6b8b4c 100644 --- a/include/function_registry.h +++ b/include/function_registry.h @@ -81,6 +81,13 @@ struct FunctionStructure { void *c_func_ptr; CodeGenFunc codegen_func; std::function func_attr_setter{nullptr}; + // True for kCFunc registrations whose user-visible signature does NOT + // include the trailing `void* exec_ctx` argument: the C implementation + // still expects exec_ctx as its last parameter, but FunctionNode codegen + // injects it automatically (pulled from the entry function's arg(1)). + // Lets callers and AST authors write the natural N-arg signature while + // keeping the C side ABI (N+1 args, last one is the context) unchanged. + bool needs_exec_ctx{false}; }; class FunctionSignature { @@ -123,6 +130,16 @@ class FunctionRegistry { // Register ReadOnlyCFunc Status RegisterReadOnlyCFunc(const FunctionSignature &func_sign, void *c_func_ptr, bool allow_override = false); + // Register a ReadOnlyCFunc whose C implementation takes a trailing + // `void* exec_ctx` argument that the user-visible signature should NOT + // expose. The user-supplied `func_sign` describes the natural N-arg + // shape (no trailing kPtr); FunctionNode codegen automatically appends + // the entry function's exec_ctx as the final actual argument when + // emitting the call site. The C function itself must still accept the + // trailing void* in its physical signature. + Status RegisterReadOnlyCFuncWithExecCtx(const FunctionSignature &func_sign, void *c_func_ptr, + bool allow_override = false); + // Register StoreCFunc // store_args_index is the index of the args in the function signature that is OuputNode Status RegisterStoreCFunc(const FunctionSignature &func_sign, void *c_func_ptr, uint32_t store_args_index, @@ -131,6 +148,13 @@ class FunctionRegistry { // Register a function that satisfies the commutative property. Status RegisterCommutativeCFunc(const FunctionSignature &func_sign, void *c_func_ptr, bool allow_override = false); + // Register a commutative C function whose user-visible signature does + // NOT include the trailing exec_ctx; mirror semantics of + // RegisterReadOnlyCFuncWithExecCtx (FunctionNode codegen will inject + // the exec_ctx automatically at call sites). + Status RegisterCommutativeCFuncWithExecCtx(const FunctionSignature &func_sign, void *c_func_ptr, + bool allow_override = false); + Status GetFuncBySign(FunctionSignature &func_sign, FunctionStructure *func_struct) const; Status SetCFuncAttr(llvm::Module *m); diff --git a/src/codegen/function_codegen.cc b/src/codegen/function_codegen.cc index b43a7f5..42d39a0 100644 --- a/src/codegen/function_codegen.cc +++ b/src/codegen/function_codegen.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-22 14:25:33 * @Last Modified by: victorika - * @Last Modified time: 2025-01-22 16:50:36 + * @Last Modified time: 2026-05-11 16:17:09 */ #include #include "codegen.h" @@ -32,17 +32,31 @@ Status CodeGen::Visit(FunctionNode& function_node) { FunctionSignature sign(function_node.GetFuncName(), args_type_list, ValueType::kUnknown); FunctionStructure func_struct; JF_RETURN_NOT_OK(ctx_.function_registry->GetFuncBySign(sign, &func_struct)); + switch (func_struct.func_type) { case FunctionType::kLLVMIntrinicFunc: { value_ = func_struct.codegen_func(sign, args_llvm_type_list, args_llvm_value_list, ctx_); } break; case FunctionType::kCFunc: { + std::string call_symbol_name; + if (func_struct.needs_exec_ctx) { + llvm::Type* ptr_ty = llvm::PointerType::getUnqual(ctx_.context); + args_llvm_type_list.emplace_back(ptr_ty); + args_llvm_value_list.emplace_back(ctx_.entry_function->getArg(1)); + std::vector ctx_param_types = sign.GetParamTypes(); + ctx_param_types.emplace_back(ValueType::kPtr); + FunctionSignature ctx_sign(sign.GetName(), std::move(ctx_param_types), sign.GetRetType()); + call_symbol_name = ctx_sign.ToString(); + } else { + call_symbol_name = sign.ToString(); + } + llvm::Type* llvm_ret_type; JF_RETURN_NOT_OK(ValueTypeToLLVMType(ctx_, function_node.GetReturnType(), &llvm_ret_type)); llvm::FunctionType* func_type = llvm::FunctionType::get(llvm_ret_type, llvm::ArrayRef(args_llvm_type_list), false); - llvm::FunctionCallee call_func_callee = ctx_.module.getOrInsertFunction(sign.ToString(), func_type); + llvm::FunctionCallee call_func_callee = ctx_.module.getOrInsertFunction(call_symbol_name, func_type); if (function_node.GetReturnType() == ValueType::kVoid) { ctx_.builder.CreateCall(call_func_callee, args_llvm_value_list); diff --git a/src/exec_engine.cc b/src/exec_engine.cc index 0a918b9..b15c9eb 100644 --- a/src/exec_engine.cc +++ b/src/exec_engine.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-15 10:59:33 * @Last Modified by: victorika - * @Last Modified time: 2026-05-09 14:42:00 + * @Last Modified time: 2026-05-11 17:07:36 */ #include "exec_engine.h" diff --git a/src/function/list_arithmetic.cc b/src/function/list_arithmetic.cc index bedecb6..33a5df9 100644 --- a/src/function/list_arithmetic.cc +++ b/src/function/list_arithmetic.cc @@ -635,729 +635,707 @@ ListType ListMax(ListType a, typename ListType::CElementType b, void *exec_conte } Status InitListAddFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListAddList))); return Status::OK(); } Status InitListSubFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListSubList))); return Status::OK(); } Status InitListMulFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListMulList))); return Status::OK(); } Status InitListDivFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListDivList))); return Status::OK(); } Status InitListModFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListModList))); return Status::OK(); } Status InitListBitwiseAndFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListBitwiseAndList))); return Status::OK(); } Status InitListBitwiseOrFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListBitwiseOrList))); return Status::OK(); } Status InitListBitwiseXorFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListBitwiseXorList))); return Status::OK(); } Status InitListExpFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kU8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kU16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kU64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kI8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kI16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kI32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kI64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kU8List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kU16List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kU32List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kU64List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kI8List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kI16List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kI32List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kI64List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListExp))); return Status::OK(); } Status InitListLogFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kU8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kU16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kU64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kI8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kI16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kI32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kI64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kU8List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kU16List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kU32List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kU64List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kI8List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kI16List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kI32List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kI64List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListLog))); return Status::OK(); } Status InitListLog2Func(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kU8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kU16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kU64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kI8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kI16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kI32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kI64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kU8List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kU16List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kU32List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kU64List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kI8List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kI16List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kI32List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kI64List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); return Status::OK(); } Status InitListLog10Func(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kU8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kU16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kU64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kI8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kI16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kI32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kI64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kU8List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kU16List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kU32List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kU64List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kI8List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kI16List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kI32List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kI64List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); return Status::OK(); } Status InitListCeilFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListCeil", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListCeil))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListCeil", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListCeil))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListCeil", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListCeil))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListCeil", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListCeil))); return Status::OK(); } Status InitListFloorFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListFloor", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListFloor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListFloor", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListFloor))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListFloor", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListFloor))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListFloor", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListFloor))); return Status::OK(); } Status InitListRoundFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListRound", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListRound))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListRound", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListRound))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListRound", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListRound))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListRound", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListRound))); return Status::OK(); } Status InitListMinFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListMin))); return Status::OK(); } Status InitListMaxFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListMax))); return Status::OK(); } diff --git a/src/function/list_basic.cc b/src/function/list_basic.cc index 6560267..3f67f49 100644 --- a/src/function/list_basic.cc +++ b/src/function/list_basic.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-02-09 15:09:08 * @Last Modified by: victorika - * @Last Modified time: 2026-04-03 15:37:01 + * @Last Modified time: 2026-05-11 16:38:55 */ #include #include @@ -251,9 +251,8 @@ inline StringListStruct UniqueString(StringListStruct a, void *exec_context) { } Status InitCrossJoinFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CrossJoin", - {ValueType::kStringList, ValueType::kStringList, ValueType::kString, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CrossJoin", {ValueType::kStringList, ValueType::kStringList, ValueType::kString}, ValueType::kStringList), reinterpret_cast(CrossJoinString))); return Status::OK(); @@ -310,9 +309,8 @@ inline StringListStruct ZipConcatString(StringListStruct a, StringListStruct b, } Status InitZipConcatFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ZipConcat", - {ValueType::kStringList, ValueType::kStringList, ValueType::kString, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ZipConcat", {ValueType::kStringList, ValueType::kStringList, ValueType::kString}, ValueType::kStringList), reinterpret_cast(ZipConcatString))); return Status::OK(); @@ -320,75 +318,74 @@ Status InitZipConcatFunc(FunctionRegistry *reg) { Status InitUniqueFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK( - reg->RegisterReadOnlyCFunc(FunctionSignature("Unique", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK( - reg->RegisterReadOnlyCFunc(FunctionSignature("Unique", {ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kStringList, ValueType::kPtr}, ValueType::kStringList), + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kU8List}, ValueType::kU8List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kU16List}, ValueType::kU16List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kU32List}, ValueType::kU32List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kU64List}, ValueType::kU64List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kI8List}, ValueType::kI8List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kI16List}, ValueType::kI16List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kI32List}, ValueType::kI32List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kI64List}, ValueType::kI64List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Unique", {ValueType::kStringList}, ValueType::kStringList), reinterpret_cast(UniqueString))); return Status::OK(); } Status InitListConcatFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kStringList, ValueType::kStringList, ValueType::kPtr}, - ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kStringList, ValueType::kStringList}, ValueType::kStringList), reinterpret_cast(ListConcat))); return Status::OK(); } @@ -457,67 +454,67 @@ Status InitLenFunc(FunctionRegistry *reg) { } Status InitSortFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(SortAsc))); - - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kU8List}, ValueType::kU8List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kU16List}, ValueType::kU16List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kU32List}, ValueType::kU32List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kU64List}, ValueType::kU64List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kI8List}, ValueType::kI8List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kI16List}, ValueType::kI16List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kI32List}, ValueType::kI32List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kI64List}, ValueType::kI64List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(SortAsc))); + + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kU8List}, ValueType::kU8List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kU16List}, ValueType::kU16List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kU32List}, ValueType::kU32List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kU64List}, ValueType::kU64List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kI8List}, ValueType::kI8List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kI16List}, ValueType::kI16List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kI32List}, ValueType::kI32List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kI64List}, ValueType::kI64List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(SortDesc))); return Status::OK(); } @@ -598,8 +595,9 @@ Status RegisterNumericListCast(FunctionRegistry *reg, const std::string &func_na if (input_list_vt == output_list_vt) { return Status::OK(); } - return reg->RegisterReadOnlyCFunc(FunctionSignature(func_name, {input_list_vt, ValueType::kPtr}, output_list_vt), - reinterpret_cast(ListCastNumericToNumeric)); + return reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(func_name, {input_list_vt}, output_list_vt), + reinterpret_cast(ListCastNumericToNumeric)); } template @@ -626,9 +624,9 @@ Status RegisterAllInputsForNumericListCast(FunctionRegistry *reg, const std::str JF_RETURN_NOT_OK( (RegisterNumericListCast(reg, func_name, ValueType::kF64List, output_list_vt))); if constexpr (!std::is_floating_point_v) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(func_name, {ValueType::kStringList, ValueType::kPtr}, output_list_vt), - reinterpret_cast(ListCastStringToNumeric))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(func_name, {ValueType::kStringList}, output_list_vt), + reinterpret_cast(ListCastStringToNumeric))); } return Status::OK(); } @@ -645,35 +643,35 @@ Status InitListCastFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(RegisterAllInputsForNumericListCast(reg, "CastF32List", ValueType::kF32List)); JF_RETURN_NOT_OK(RegisterAllInputsForNumericListCast(reg, "CastF64List", ValueType::kF64List)); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kU8List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kU8List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kI8List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kI8List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kU16List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kU16List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kI16List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kI16List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kU32List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kU32List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kI32List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kI32List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kU64List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kU64List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kI64List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kI64List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kF32List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kF32List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kF64List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kF64List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); return Status::OK(); diff --git a/src/function/list_comparison.cc b/src/function/list_comparison.cc index 4fc9d28..e7b2912 100644 --- a/src/function/list_comparison.cc +++ b/src/function/list_comparison.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-02-09 14:48:23 * @Last Modified by: victorika - * @Last Modified time: 2026-04-03 14:31:05 + * @Last Modified time: 2026-05-11 16:35:09 */ #include #include "codegen/codegen.h" @@ -426,934 +426,766 @@ ListType FilterByBitmap(ListType a, U8ListStruct bitmap, uint32_t bits_cnt, void } Status InitIfLargeFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfLarge))); return Status::OK(); } Status InitIfLargeEqualFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfLargeEqual))); return Status::OK(); } Status InitIfEqualFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfEqual))); return Status::OK(); } Status InitIfLessFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfLess))); return Status::OK(); } Status InitIfLessEqualFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfLessEqual))); return Status::OK(); } Status InitIfNotEqualFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfNotEqual))); return Status::OK(); } Status InitIfByBitmapLLRB(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfByBitmapLLRB))); return Status::OK(); } Status InitIfByBitmapLBRL(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8, ValueType::kI8List, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16, ValueType::kI16List, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32, ValueType::kI32List, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64, ValueType::kI64List, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32, ValueType::kF32List, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64, ValueType::kF64List, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(IfByBitmapLBRL))); return Status::OK(); } Status InitIfByBitmapLLRL(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(IfByBitmapLLRL))); return Status::OK(); } Status InitGenLargeBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenLargeBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenLargeEqualBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenLargeEqualBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenEqualBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenEqualBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenLessBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenLessBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenLessEqualBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenLessEqualBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenNotEqualBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenNotEqualBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitFilterByBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU16List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kU16List, ValueType::kU8List, ValueType::kU32}, ValueType::kU16List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU32List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kU32List, ValueType::kU8List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU64List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kU64List, ValueType::kU8List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI8List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kI8List, ValueType::kU8List, ValueType::kU32}, ValueType::kI8List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI16List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kI16List, ValueType::kU8List, ValueType::kU32}, ValueType::kI16List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI32List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kI32List, ValueType::kU8List, ValueType::kU32}, ValueType::kI32List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI64List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kI64List, ValueType::kU8List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kF32List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kF32List, ValueType::kU8List, ValueType::kU32}, ValueType::kF32List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kF64List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kF64List, ValueType::kU8List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(FilterByBitmap))); return Status::OK(); @@ -1363,7 +1195,7 @@ llvm::Value *EmitFilterByBitmapSugar(const FunctionSignature &sign, const std::v const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { auto *list_value = arg_llvm_value_list.at(0); auto *bitmap_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *list_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -1377,7 +1209,13 @@ llvm::Value *EmitFilterByBitmapSugar(const FunctionSignature &sign, const std::v ctx.module.getOrInsertFunction(count_bits_sign.ToString(), count_bits_func_type); llvm::Value *bits_cnt_value = ctx.builder.CreateCall(count_bits_callee, {bitmap_value}, "bits_cnt"); - // FilterByBitmap(list, bitmap, bits_cnt, ctx) -> + // FilterByBitmap is registered via RegisterReadOnlyCFuncWithExecCtx, which + // exposes two signatures: the modern (no-ctx) one for resolution and a + // legacy ctx-bearing one whose ToString() is what MappingToJIT actually + // publishes as a JIT symbol. Use the *legacy* name here so the IR-level + // declaration we emit matches MappingToJIT's symbol exactly, mirroring + // the FunctionNode codegen path that auto-injects exec_ctx and emits + // calls under the ctx-bearing name. FunctionSignature filter_sign("FilterByBitmap", {sign.GetParamTypes().at(0), ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -1390,44 +1228,34 @@ llvm::Value *EmitFilterByBitmapSugar(const FunctionSignature &sign, const std::v Status InitFilterByBitmapSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + FunctionSignature("FilterByBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU16List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU16List), + FunctionSignature("FilterByBitmap", {ValueType::kU16List, ValueType::kU8List}, ValueType::kU16List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU32List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU32List), + FunctionSignature("FilterByBitmap", {ValueType::kU32List, ValueType::kU8List}, ValueType::kU32List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU64List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU64List), + FunctionSignature("FilterByBitmap", {ValueType::kU64List, ValueType::kU8List}, ValueType::kU64List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kI8List), + FunctionSignature("FilterByBitmap", {ValueType::kI8List, ValueType::kU8List}, ValueType::kI8List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI16List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kI16List), + FunctionSignature("FilterByBitmap", {ValueType::kI16List, ValueType::kU8List}, ValueType::kI16List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI32List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kI32List), + FunctionSignature("FilterByBitmap", {ValueType::kI32List, ValueType::kU8List}, ValueType::kI32List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI64List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kI64List), + FunctionSignature("FilterByBitmap", {ValueType::kI64List, ValueType::kU8List}, ValueType::kI64List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kF32List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kF32List), + FunctionSignature("FilterByBitmap", {ValueType::kF32List, ValueType::kU8List}, ValueType::kF32List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kF64List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kF64List), + FunctionSignature("FilterByBitmap", {ValueType::kF64List, ValueType::kU8List}, ValueType::kF64List), EmitFilterByBitmapSugar)); return Status::OK(); } diff --git a/src/function/list_group.cc b/src/function/list_group.cc index 9294137..70f9460 100644 --- a/src/function/list_group.cc +++ b/src/function/list_group.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-30 11:35:00 * @Last Modified by: victorika - * @Last Modified time: 2026-04-30 11:35:00 + * @Last Modified time: 2026-05-11 16:32:30 */ #include #include @@ -182,38 +182,38 @@ F64ListStruct GroupAvg(VList values, U32ListStruct group_index, uint32_t distinc } Status InitGroupIndexFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kI8List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kU16List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kI16List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kI32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kU64List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kI64List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kF32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kF64List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kStringList, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kU8List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kI8List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kU16List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kI16List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kU32List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kI32List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kU64List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kI64List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kF32List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kF64List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupIndex", {ValueType::kStringList}, ValueType::kU32List), reinterpret_cast(GroupIndexString))); return Status::OK(); } @@ -225,48 +225,38 @@ Status InitGroupCountFunc(FunctionRegistry *reg) { } Status InitGroupKeysFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kI8List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kU16List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kI16List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kI32List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF32List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List, ValueType::kU32}, ValueType::kStringList), reinterpret_cast(GroupKeys))); return Status::OK(); @@ -276,7 +266,7 @@ llvm::Value *EmitGroupKeysSugar(const FunctionSignature &sign, const std::vector const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { auto *keys_value = arg_llvm_value_list.at(0); auto *group_index_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *keys_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -289,6 +279,10 @@ llvm::Value *EmitGroupKeysSugar(const FunctionSignature &sign, const std::vector ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + // Mirror the *legacy* ctx-bearing signature of GroupKeys so the IR-level + // symbol we emit matches what MappingToJIT publishes (and what FunctionNode + // codegen would emit for a direct call): the ctx-bearing name lets GVN/CSE + // share a single declaration with all other GroupKeys call sites. FunctionSignature group_keys_sign("GroupKeys", {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -302,84 +296,73 @@ llvm::Value *EmitGroupKeysSugar(const FunctionSignature &sign, const std::vector Status InitGroupKeysSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU8List), + FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List}, ValueType::kU8List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI8List), + FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List}, ValueType::kI8List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU16List), + FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List}, ValueType::kU16List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI16List), + FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List}, ValueType::kI16List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI32List), + FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List}, ValueType::kI32List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List}, ValueType::kU64List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List}, ValueType::kI64List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF32List), + FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF32List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List, ValueType::kPtr}, - ValueType::kStringList), + FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List}, ValueType::kStringList), EmitGroupKeysSugar)); return Status::OK(); } Status InitGroupSumFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupSum))); // Unsigned integers promote to u64. - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupSum))); // Floating-point promotes to f64. - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupSum))); return Status::OK(); } @@ -388,7 +371,7 @@ llvm::Value *EmitGroupSumSugar(const FunctionSignature &sign, const std::vector< const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { auto *values_value = arg_llvm_value_list.at(0); auto *group_index_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *values_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -404,6 +387,10 @@ llvm::Value *EmitGroupSumSugar(const FunctionSignature &sign, const std::vector< ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + // Mirror the *legacy* ctx-bearing signature of GroupSum so getOrInsertFunction + // lands on the same declaration that MappingToJIT publishes (and the same + // one FunctionNode codegen emits for direct user calls). That keeps GVN/CSE + // happy across sugar / direct call shapes. FunctionSignature group_sum_sign("GroupSum", {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -417,122 +404,102 @@ llvm::Value *EmitGroupSumSugar(const FunctionSignature &sign, const std::vector< Status InitGroupSumSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List}, ValueType::kI64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List}, ValueType::kI64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List}, ValueType::kI64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List}, ValueType::kI64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List}, ValueType::kU64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List}, ValueType::kU64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List}, ValueType::kU64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupSumSugar)); return Status::OK(); } Status InitGroupMaxFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kI8List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kU16List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kI16List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kI32List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF32List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupMax))); return Status::OK(); } Status InitGroupMinFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kI8List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kU16List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kI16List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kI32List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF32List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupMin))); return Status::OK(); } @@ -543,7 +510,7 @@ llvm::Value *EmitGroupExtremaSugar(const std::string &kernel_name, const Functio const char *call_name) { auto *values_value = arg_llvm_value_list.at(0); auto *group_index_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *values_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -556,6 +523,9 @@ llvm::Value *EmitGroupExtremaSugar(const std::string &kernel_name, const Functio ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + // Mirror the *legacy* ctx-bearing signature of the GroupMin/GroupMax kernel + // so the IR-level declaration matches MappingToJIT's published symbol and + // FunctionNode codegen's direct-call name. FunctionSignature kernel_sign(kernel_name, {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -578,112 +548,98 @@ llvm::Value *EmitGroupMinSugar(const FunctionSignature &sign, const std::vector< Status InitGroupMaxSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU8List), - EmitGroupMaxSugar)); + FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List}, ValueType::kU8List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI8List), - EmitGroupMaxSugar)); + FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List}, ValueType::kI8List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU16List), + FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List}, ValueType::kU16List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI16List), + FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List}, ValueType::kI16List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI32List), + FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List}, ValueType::kI32List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List}, ValueType::kU64List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List}, ValueType::kI64List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF32List), + FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF32List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupMaxSugar)); return Status::OK(); } Status InitGroupMinSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU8List), - EmitGroupMinSugar)); + FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List}, ValueType::kU8List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI8List), - EmitGroupMinSugar)); + FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List}, ValueType::kI8List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU16List), + FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List}, ValueType::kU16List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI16List), + FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List}, ValueType::kI16List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI32List), + FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List}, ValueType::kI32List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List}, ValueType::kU64List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List}, ValueType::kI64List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF32List), + FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF32List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupMinSugar)); return Status::OK(); } Status InitGroupAvgFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); return Status::OK(); } @@ -692,7 +648,7 @@ llvm::Value *EmitGroupAvgSugar(const FunctionSignature &sign, const std::vector< const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { auto *values_value = arg_llvm_value_list.at(0); auto *group_index_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *values_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -708,6 +664,10 @@ llvm::Value *EmitGroupAvgSugar(const FunctionSignature &sign, const std::vector< ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + // Mirror the registry view of GroupAvg (no trailing exec_ctx in its + // Mirror the *legacy* ctx-bearing signature of GroupAvg so getOrInsertFunction + // lands on the same Function* MappingToJIT publishes and FunctionNode codegen + // emits for direct user calls. FunctionSignature group_avg_sign("GroupAvg", {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -721,34 +681,34 @@ llvm::Value *EmitGroupAvgSugar(const FunctionSignature &sign, const std::vector< Status InitGroupAvgSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); return Status::OK(); } diff --git a/src/function/list_indexing.cc b/src/function/list_indexing.cc index 8c7fbd5..39318a6 100644 --- a/src/function/list_indexing.cc +++ b/src/function/list_indexing.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-05-06 11:15:00 * @Last Modified by: victorika - * @Last Modified time: 2026-05-11 14:55:04 + * @Last Modified time: 2026-05-11 16:30:32 */ #include #include @@ -91,22 +91,32 @@ constexpr const char *kLookupStringName = "__LookupTableString"; bool IsStringListType(ValueType v) { return v == ValueType::kStringList; } -// Lowering for the user-facing ListLookupIndex(a, b, ctx). Emits two -// readonly C calls - one to build the hash table over `b`, one to probe -// the table with `a`. LLVM CSE merges the BuildLookupTable_* call across -// multiple ListLookupIndex sites that share the same `b`. +// Lowering for the user-facing ListLookupIndex(a, b). The user-visible +// signature does NOT include exec_ctx — the helper functions it lowers to +// are registered via RegisterReadOnlyCFuncWithExecCtx, meaning their C +// implementations consume a trailing void* ctx but the registry view of +// the signature does not advertise it. We pull ctx from entry_function's +// arg(1) ourselves and append it to each call site, so the emitted LLVM +// `Function` types still match the C ABI (N+1 args, last one ptr). +// +// Two readonly C calls are emitted: one to build the hash table over `b`, +// one to probe the table with `a`. LLVM CSE merges the BuildLookupTable_* +// call across multiple ListLookupIndex sites that share the same `b`. llvm::Value *CodegenListLookupIndex(const FunctionSignature &sign, const std::vector &arg_types, const std::vector &args, IRCodeGenContext &ctx) { - // sign.GetParamTypes() = {KList, KList, kPtr}; args[0]=a, args[1]=b, args[2]=exec_ctx + // sign.GetParamTypes() = {KList, KList}; args[0]=a, args[1]=b. const auto ¶m_types = sign.GetParamTypes(); const ValueType list_vt = param_types[0]; const bool is_string = IsStringListType(list_vt); const char *build_name = is_string ? kBuildStringName : kBuildIntName; const char *lookup_name = is_string ? kLookupStringName : kLookupIntName; - // Each helper has its own *registered* signature (so MappingToJIT and - // SetCFuncAttr can find them). Mirror those signatures here when - // asking the module for the function declaration. + // Mirror the *legacy* ctx-bearing signatures of the helpers (the names + // MappingToJIT actually publishes for the underlying C symbols, and the + // ones FunctionNode codegen would emit for direct user calls). Using the + // ctx-bearing form here means a single LLVM Function declaration is + // shared between this sugar's emit and any future direct calls of + // BuildLookupTable/LookupTable, letting GVN/CSE merge across both. FunctionSignature build_sign(build_name, {list_vt, ValueType::kPtr}, ValueType::kPtr); FunctionSignature lookup_sign(lookup_name, {list_vt, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List); @@ -114,15 +124,20 @@ llvm::Value *CodegenListLookupIndex(const FunctionSignature &sign, const std::ve llvm::Type *list_ty = arg_types[0]; // matches args[0] / args[1] (KList struct value) llvm::Type *u32list_ty = ctx.complex_type.u32list_type; - // Build call: ptr (KList, ptr) + llvm::Value *exec_ctx = ctx.entry_function->getArg(1); + + // Build call: ptr (KList, ptr) — the ptr at the end is the auto-injected + // exec_ctx; the helper's user-visible signature is just (KList). auto *build_fty = llvm::FunctionType::get(ptr_ty, {list_ty, ptr_ty}, false); llvm::FunctionCallee build_callee = ctx.module.getOrInsertFunction(build_sign.ToString(), build_fty); - llvm::Value *table_ptr = ctx.builder.CreateCall(build_callee, {args[1], args[2]}, "call_BuildLookupTable"); + llvm::Value *table_ptr = ctx.builder.CreateCall(build_callee, {args[1], exec_ctx}, "call_BuildLookupTable"); - // Lookup call: U32List (KList, ptr, ptr) + // Lookup call: U32List (KList, ptr, ptr) — same trick: trailing ptr is + // exec_ctx, the user-visible signature is just (KList, ptr) where the + // first ptr is the table handle returned above. auto *lookup_fty = llvm::FunctionType::get(u32list_ty, {list_ty, ptr_ty, ptr_ty}, false); llvm::FunctionCallee lookup_callee = ctx.module.getOrInsertFunction(lookup_sign.ToString(), lookup_fty); - llvm::Value *result = ctx.builder.CreateCall(lookup_callee, {args[0], table_ptr, args[2]}, "call_LookupTable"); + llvm::Value *result = ctx.builder.CreateCall(lookup_callee, {args[0], table_ptr, exec_ctx}, "call_LookupTable"); return result; } @@ -269,89 +284,88 @@ U32ListStruct Bucketize(ListType values, ListType boundaries, void *exec_context } Status InitListLookupIndexFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kU8List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kU8List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kU8List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kU8List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kI8List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kI8List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kI8List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kI8List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kU16List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kU16List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kU16List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kU16List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kI16List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kI16List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kI16List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kI16List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kU32List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kU32List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kU32List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kI32List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kI32List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kI32List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kI32List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kU64List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kU64List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kU64List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kU64List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kI64List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kI64List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kI64List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kI64List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kF32List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kF32List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kF32List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kF32List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kF64List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kF64List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kF64List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kF64List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildStringName, {ValueType::kStringList, ValueType::kPtr}, ValueType::kPtr), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kBuildStringName, {ValueType::kStringList}, ValueType::kPtr), reinterpret_cast(BuildLookupTableString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupStringName, {ValueType::kStringList, ValueType::kPtr, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupStringName, {ValueType::kStringList, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableString))); for (ValueType vt : {ValueType::kU8List, ValueType::kI8List, ValueType::kU16List, ValueType::kI16List, ValueType::kU32List, ValueType::kI32List, ValueType::kU64List, ValueType::kI64List, ValueType::kF32List, ValueType::kF64List, ValueType::kStringList}) { - JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("ListLookupIndex", {vt, vt, ValueType::kPtr}, ValueType::kU32List), CodegenListLookupIndex)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc(FunctionSignature("ListLookupIndex", {vt, vt}, ValueType::kU32List), + CodegenListLookupIndex)); } return Status::OK(); } @@ -436,95 +450,84 @@ Status InitFindMissFunc(FunctionRegistry *reg) { } Status InitListCompactFuncs(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListCompactPositions", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListCompactPositions", {ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListCompactPositions))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListCompactIndex", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListCompactIndex", {ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListCompactIndex))); return Status::OK(); } Status InitListGatherFunc(FunctionRegistry *reg) { // Signature: ListGather(values, idx, default, ctx) - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kU8List, ValueType::kU32List, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kU8List, ValueType::kU32List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kI8List, ValueType::kU32List, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kI8List, ValueType::kU32List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kU16List, ValueType::kU32List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kU16List, ValueType::kU32List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kI16List, ValueType::kU32List, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kI16List, ValueType::kU32List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kI32List, ValueType::kU32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kI32List, ValueType::kU32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kU64List, ValueType::kU32List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kU64List, ValueType::kU32List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kI64List, ValueType::kU32List, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kI64List, ValueType::kU32List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kF32List, ValueType::kU32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kF32List, ValueType::kU32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kF64List, ValueType::kU32List, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kF64List, ValueType::kU32List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", - {ValueType::kStringList, ValueType::kU32List, ValueType::kString, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kStringList, ValueType::kU32List, ValueType::kString}, ValueType::kStringList), reinterpret_cast(ListGather))); return Status::OK(); } Status InitBucketizeFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU32List), reinterpret_cast(Bucketize))); return Status::OK(); } diff --git a/src/function/string_function_init.cc b/src/function/string_function_init.cc index c6a83ad..86b0be7 100644 --- a/src/function/string_function_init.cc +++ b/src/function/string_function_init.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-23 12:36:51 * @Last Modified by: victorika - * @Last Modified time: 2026-04-03 16:36:37 + * @Last Modified time: 2026-05-11 16:38:52 */ #include #include @@ -74,8 +74,8 @@ llvm::Value *CallBuiltinStringLenFunction(const FunctionSignature & /*sign*/, } // namespace Status InitStringInternalFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("StringConcat", {ValueType::kString, ValueType::kString, ValueType::kPtr}, ValueType::kString), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("StringConcat", {ValueType::kString, ValueType::kString}, ValueType::kString), reinterpret_cast(StringConcat))); JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( FunctionSignature("StringCmp", {ValueType::kString, ValueType::kString}, ValueType::kI32), @@ -86,61 +86,53 @@ Status InitStringInternalFunc(FunctionRegistry *reg) { FunctionSignature("StringContains", {ValueType::kString, ValueType::kString}, ValueType::kU8), reinterpret_cast(StringContains))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kU8, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kI8, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kU16, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kI16, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kU32, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kI32, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kU64, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kI64, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kF32, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kF64, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kU8}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kI8}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kU16}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kI16}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kU32}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kI32}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kU64}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kI64}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kF32}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kF64}, ValueType::kString), + reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastU8", {ValueType::kString}, ValueType::kU8), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastI8", {ValueType::kString}, ValueType::kI8), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastU16", {ValueType::kString}, ValueType::kU16), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastI16", {ValueType::kString}, ValueType::kI16), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastU32", {ValueType::kString}, ValueType::kU32), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastI32", {ValueType::kString}, ValueType::kI32), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastU64", {ValueType::kString}, ValueType::kU64), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastI64", {ValueType::kString}, ValueType::kI64), - reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastU8", {ValueType::kString}, ValueType::kU8), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastI8", {ValueType::kString}, ValueType::kI8), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastU16", {ValueType::kString}, ValueType::kU16), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastI16", {ValueType::kString}, ValueType::kI16), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastU32", {ValueType::kString}, ValueType::kU32), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastI32", {ValueType::kString}, ValueType::kI32), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastU64", {ValueType::kString}, ValueType::kU64), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastI64", {ValueType::kString}, ValueType::kI64), + reinterpret_cast(CastStringToNumeric))); return Status::OK(); } diff --git a/src/function_registry.cc b/src/function_registry.cc index 2f28f0a..d706377 100644 --- a/src/function_registry.cc +++ b/src/function_registry.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-15 14:26:36 * @Last Modified by: victorika - * @Last Modified time: 2025-03-04 19:03:28 + * @Last Modified time: 2026-05-11 16:37:39 */ #include "function_registry.h" #include @@ -138,6 +138,36 @@ Status FunctionRegistry::RegisterReadOnlyCFunc(const FunctionSignature& func_sig return RegisterFunc(func_sign, std::move(func_struct), allow_override); } +Status FunctionRegistry::RegisterReadOnlyCFuncWithExecCtx(const FunctionSignature& func_sign, void* c_func_ptr, + bool allow_override) { + if (nullptr == c_func_ptr) { + return Status::InvalidArgument("c_func_ptr is nullptr"); + } + // Modern user-visible signature: no trailing kPtr; codegen auto-injects + // exec_ctx when emitting the call so the C ABI (N+1 args) is preserved. + { + FunctionStructure func_struct; + func_struct.func_type = FunctionType::kCFunc; + func_struct.c_func_ptr = c_func_ptr; + func_struct.func_attr_setter = ReadOnlyFunctionAttributeSetter; + func_struct.needs_exec_ctx = true; + JF_RETURN_NOT_OK(RegisterFunc(func_sign, std::move(func_struct), allow_override)); + } + // Legacy compatibility signature: with trailing kPtr; behaves exactly + // like the old RegisterReadOnlyCFunc registration. Existing callers + // (AST builders that still create an ExecContextNode tail arg, or + // athena DSL code using `EXEC_CTX`) keep working unchanged. + std::vector legacy_params = func_sign.GetParamTypes(); + legacy_params.emplace_back(ValueType::kPtr); + FunctionSignature legacy_sign(func_sign.GetName(), std::move(legacy_params), func_sign.GetRetType()); + FunctionStructure legacy_struct; + legacy_struct.func_type = FunctionType::kCFunc; + legacy_struct.c_func_ptr = c_func_ptr; + legacy_struct.func_attr_setter = ReadOnlyFunctionAttributeSetter; + legacy_struct.needs_exec_ctx = false; + return RegisterFunc(legacy_sign, std::move(legacy_struct), allow_override); +} + Status FunctionRegistry::RegisterStoreCFunc(const FunctionSignature& func_sign, void* c_func_ptr, uint32_t store_args_index, bool allow_override) { if (nullptr == c_func_ptr) { @@ -162,6 +192,34 @@ Status FunctionRegistry::RegisterCommutativeCFunc(const FunctionSignature& func_ return RegisterFunc(func_sign, std::move(func_struct), allow_override); } +Status FunctionRegistry::RegisterCommutativeCFuncWithExecCtx(const FunctionSignature& func_sign, void* c_func_ptr, + bool allow_override) { + if (nullptr == c_func_ptr) { + return Status::InvalidArgument("c_func_ptr is nullptr"); + } + // Modern user-visible signature: no trailing kPtr; codegen auto-injects. + { + FunctionStructure func_struct; + func_struct.func_type = FunctionType::kCFunc; + func_struct.c_func_ptr = c_func_ptr; + func_struct.func_attr_setter = CommutantFunctionAttributeSetter; + func_struct.needs_exec_ctx = true; + JF_RETURN_NOT_OK(RegisterFunc(func_sign, std::move(func_struct), allow_override)); + } + // Legacy compatibility signature: with trailing kPtr; identical to the + // old RegisterCommutativeCFunc registration so existing AST/DSL code + // that still passes ExecContextNode keeps resolving. + std::vector legacy_params = func_sign.GetParamTypes(); + legacy_params.emplace_back(ValueType::kPtr); + FunctionSignature legacy_sign(func_sign.GetName(), std::move(legacy_params), func_sign.GetRetType()); + FunctionStructure legacy_struct; + legacy_struct.func_type = FunctionType::kCFunc; + legacy_struct.c_func_ptr = c_func_ptr; + legacy_struct.func_attr_setter = CommutantFunctionAttributeSetter; + legacy_struct.needs_exec_ctx = false; + return RegisterFunc(legacy_sign, std::move(legacy_struct), allow_override); +} + Status FunctionRegistry::GetFuncBySign(FunctionSignature& func_sign, FunctionStructure* func_struct) const { auto iter = signature2funcstruct_.find(func_sign); if (iter == signature2funcstruct_.end()) { @@ -177,6 +235,9 @@ Status FunctionRegistry::SetCFuncAttr(llvm::Module* m) { if (FunctionType::kLLVMIntrinicFunc == fc.func_type) { continue; } + if (fc.needs_exec_ctx) { + continue; + } auto* func = m->getFunction(sign.ToString()); if (func == nullptr) { continue; @@ -196,6 +257,9 @@ Status FunctionRegistry::MappingToJIT(llvm::orc::LLJIT* jit) { if (FunctionType::kLLVMIntrinicFunc == fc.func_type) { continue; } + if (fc.needs_exec_ctx) { + continue; + } auto function_a_address = llvm::orc::ExecutorAddr::fromPtr(fc.c_func_ptr); symbols.try_emplace(mangle(sign.ToString()), function_a_address, llvm::JITSymbolFlags::Exported); } diff --git a/test/empty_list_test.cc b/test/empty_list_test.cc index a244987..541bec2 100644 --- a/test/empty_list_test.cc +++ b/test/empty_list_test.cc @@ -35,31 +35,28 @@ Status RunExpr(std::unique_ptr expr, RetType* result) { return engine.Execute(nullptr, result); } -// Build: (, exec_ctx) for nullary-over-list ops. +// Build: () for nullary-over-list ops. std::unique_ptr MakeUnaryListCall(const std::string& func_name, std::unique_ptr list_node) { std::vector> args; args.emplace_back(std::move(list_node)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build: (, , exec_ctx) +// Build: (, ) std::unique_ptr MakeListScalarCall(const std::string& func_name, std::unique_ptr list_node, std::unique_ptr scalar_node) { std::vector> args; args.emplace_back(std::move(list_node)); args.emplace_back(std::move(scalar_node)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build: (, , exec_ctx) for list-list ops. +// Build: (, ) for list-list ops. std::unique_ptr MakeListListCall(const std::string& func_name, std::unique_ptr lhs, std::unique_ptr rhs) { std::vector> args; args.emplace_back(std::move(lhs)); args.emplace_back(std::move(rhs)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } @@ -221,7 +218,7 @@ TEST(EmptyListRuntimeTest, GenNotEqualBitmapListEmptyVsEmpty) { // ---- list_comparison.cc: IfXxx on empty list ------------------------------- TEST(EmptyListRuntimeTest, IfLargeOnEmptyList) { - // IfLarge(list, cmp_value, target_value, exec_ctx) + // IfLarge(list, cmp_value, target_value) auto list = std::unique_ptr(new ConstantListValueNode(std::vector{})); auto cmp = std::unique_ptr(new ConstantValueNode(int32_t{5})); auto target = std::unique_ptr(new ConstantValueNode(int32_t{99})); @@ -229,7 +226,6 @@ TEST(EmptyListRuntimeTest, IfLargeOnEmptyList) { args.emplace_back(std::move(list)); args.emplace_back(std::move(cmp)); args.emplace_back(std::move(target)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("IfLarge", std::move(args))); RetType result; ASSERT_TRUE(RunExpr(std::move(expr), &result).ok()); @@ -244,7 +240,6 @@ TEST(EmptyListRuntimeTest, StringConcatTwoEmptyStrings) { std::vector> args; args.emplace_back(std::move(a)); args.emplace_back(std::move(b)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("StringConcat", std::move(args))); RetType result; ASSERT_TRUE(RunExpr(std::move(expr), &result).ok()); @@ -257,7 +252,6 @@ TEST(EmptyListRuntimeTest, StringConcatEmptyWithNonEmpty) { std::vector> args; args.emplace_back(std::move(a)); args.emplace_back(std::move(b)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("StringConcat", std::move(args))); RetType result; ASSERT_TRUE(RunExpr(std::move(expr), &result).ok()); diff --git a/test/exec_error_test.cc b/test/exec_error_test.cc index 2d5c772..4bc2328 100644 --- a/test/exec_error_test.cc +++ b/test/exec_error_test.cc @@ -24,11 +24,9 @@ namespace { std::unique_ptr MakeListAddNode(const std::vector& lhs, const std::vector& rhs) { auto l_node = std::unique_ptr(new ConstantListValueNode(lhs)); auto r_node = std::unique_ptr(new ConstantListValueNode(rhs)); - auto ctx_node = std::unique_ptr(new ExecContextNode); std::vector> args; args.emplace_back(std::move(l_node)); args.emplace_back(std::move(r_node)); - args.emplace_back(std::move(ctx_node)); return std::unique_ptr(new FunctionNode("ListAdd", std::move(args))); } diff --git a/test/function_test.cc b/test/function_test.cc index 6f7b3e3..b36e7d1 100644 --- a/test/function_test.cc +++ b/test/function_test.cc @@ -322,11 +322,10 @@ TEST(FunctionTest, StringConcatTest) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto l_node = std::unique_ptr(new ConstantValueNode(l)); auto r_node = std::unique_ptr(new ConstantValueNode(r)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(l_node)); args_list.emplace_back(std::move(r_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("StringConcat", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -449,10 +448,9 @@ TEST(FunctionTest, CastStringFromI32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantValueNode(arg)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastString", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -467,10 +465,9 @@ TEST(FunctionTest, CastStringFromU64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantValueNode(arg)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastString", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -485,10 +482,9 @@ TEST(FunctionTest, CastStringFromF64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantValueNode(arg)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastString", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -503,10 +499,9 @@ TEST(FunctionTest, CastStringFromU8Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantValueNode(arg)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastString", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_arithmetic_test.cc b/test/list_arithmetic_test.cc index e917b81..f4513ab 100644 --- a/test/list_arithmetic_test.cc +++ b/test/list_arithmetic_test.cc @@ -25,11 +25,10 @@ TEST(FunctionTest, ListAddTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto add_node = std::unique_ptr(new ConstantValueNode(add)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(add_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -47,11 +46,10 @@ TEST(FunctionTest, ListAddTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto add_node = std::unique_ptr(new ConstantValueNode(add)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(add_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -69,11 +67,10 @@ TEST(FunctionTest, ListAddTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto add_node = std::unique_ptr(new ConstantValueNode(add)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(add_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -91,11 +88,10 @@ TEST(FunctionTest, ListAddTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -113,11 +109,10 @@ TEST(FunctionTest, ListAddTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -135,11 +130,10 @@ TEST(FunctionTest, ListAddTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -157,11 +151,10 @@ TEST(FunctionTest, ListSubTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto sub_node = std::unique_ptr(new ConstantValueNode(sub)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(sub_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -179,11 +172,10 @@ TEST(FunctionTest, ListSubTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto sub_node = std::unique_ptr(new ConstantValueNode(sub)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(sub_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -201,11 +193,10 @@ TEST(FunctionTest, ListSubTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto sub_node = std::unique_ptr(new ConstantValueNode(sub)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(sub_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -223,11 +214,10 @@ TEST(FunctionTest, ListSubTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -245,11 +235,10 @@ TEST(FunctionTest, ListSubTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -267,11 +256,10 @@ TEST(FunctionTest, ListSubTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -289,11 +277,10 @@ TEST(FunctionTest, ListMulTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mul_node = std::unique_ptr(new ConstantValueNode(mul)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -311,11 +298,10 @@ TEST(FunctionTest, ListMulTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mul_node = std::unique_ptr(new ConstantValueNode(mul)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -333,11 +319,10 @@ TEST(FunctionTest, ListMulTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mul_node = std::unique_ptr(new ConstantValueNode(mul)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -355,11 +340,10 @@ TEST(FunctionTest, ListMulTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mul_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -377,11 +361,10 @@ TEST(FunctionTest, ListMulTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mul_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -399,11 +382,10 @@ TEST(FunctionTest, ListMulTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mul_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -421,11 +403,10 @@ TEST(FunctionTest, ListDivTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto div_node = std::unique_ptr(new ConstantValueNode(div)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -443,11 +424,10 @@ TEST(FunctionTest, ListDivTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto div_node = std::unique_ptr(new ConstantValueNode(div)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -465,11 +445,10 @@ TEST(FunctionTest, ListDivTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto div_node = std::unique_ptr(new ConstantValueNode(div)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -487,11 +466,10 @@ TEST(FunctionTest, ListDivTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto div_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -509,11 +487,10 @@ TEST(FunctionTest, ListDivTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto div_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -531,11 +508,10 @@ TEST(FunctionTest, ListDivTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto div_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -553,11 +529,10 @@ TEST(FunctionTest, ListModTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mod_node = std::unique_ptr(new ConstantValueNode(mod)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mod_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMod", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -575,11 +550,10 @@ TEST(FunctionTest, ListModTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mod_node = std::unique_ptr(new ConstantValueNode(mod)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mod_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMod", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -597,11 +571,10 @@ TEST(FunctionTest, ListModTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mod_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mod_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMod", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -619,11 +592,10 @@ TEST(FunctionTest, ListModTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mod_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mod_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMod", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_basic_test.cc b/test/list_basic_test.cc index 483da1f..5745bfa 100644 --- a/test/list_basic_test.cc +++ b/test/list_basic_test.cc @@ -25,11 +25,10 @@ TEST(FunctionTest, ListConcatTest) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto l_node = std::unique_ptr(new ConstantListValueNode(l)); auto r_node = std::unique_ptr(new ConstantListValueNode(r)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(l_node)); args_list.emplace_back(std::move(r_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListConcat", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -80,10 +79,9 @@ TEST(FunctionTest, SortAscTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_ctx_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_ctx_node)); + auto op_node = std::unique_ptr(new FunctionNode("SortAsc", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -100,10 +98,9 @@ TEST(FunctionTest, SortAscTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_ctx_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_ctx_node)); + auto op_node = std::unique_ptr(new FunctionNode("SortAsc", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -120,10 +117,9 @@ TEST(FunctionTest, SortAscTest3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_ctx_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_ctx_node)); + auto op_node = std::unique_ptr(new FunctionNode("SortAsc", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -223,12 +219,11 @@ std::vector RunCrossJoin(const std::vector& a, const s auto a_node = std::unique_ptr(new ConstantListValueNode(a)); auto b_node = std::unique_ptr(new ConstantListValueNode(b)); auto sep_node = std::unique_ptr(new ConstantValueNode(sep)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(a_node)); args_list.emplace_back(std::move(b_node)); args_list.emplace_back(std::move(sep_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CrossJoin", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -287,12 +282,11 @@ std::unique_ptr MakeZipConcatExpr(const std::vector& a, c auto a_node = std::unique_ptr(new ConstantListValueNode(a)); auto b_node = std::unique_ptr(new ConstantListValueNode(b)); auto sep_node = std::unique_ptr(new ConstantValueNode(sep)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(a_node)); args_list.emplace_back(std::move(b_node)); args_list.emplace_back(std::move(sep_node)); - args_list.emplace_back(std::move(exec_node)); + return std::unique_ptr(new FunctionNode("ZipConcat", std::move(args_list))); } diff --git a/test/list_bitwise_test.cc b/test/list_bitwise_test.cc index 4320dd9..50a3c63 100644 --- a/test/list_bitwise_test.cc +++ b/test/list_bitwise_test.cc @@ -25,11 +25,10 @@ TEST(FunctionTest, ListBitwiseAndTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto and_data_node = std::unique_ptr(new ConstantValueNode(and_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(and_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseAnd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -47,11 +46,10 @@ TEST(FunctionTest, ListBitwiseAndTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto and_data_node = std::unique_ptr(new ConstantValueNode(and_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(and_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseAnd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -69,11 +67,10 @@ TEST(FunctionTest, ListBitwiseAndTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseAnd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -91,11 +88,10 @@ TEST(FunctionTest, ListBitwiseAndTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseAnd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -114,11 +110,10 @@ TEST(FunctionTest, ListBitwiseOrTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto or_data_node = std::unique_ptr(new ConstantValueNode(or_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(or_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseOr", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -136,11 +131,10 @@ TEST(FunctionTest, ListBitwiseOrTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto or_data_node = std::unique_ptr(new ConstantValueNode(or_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(or_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseOr", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -158,11 +152,10 @@ TEST(FunctionTest, ListBitwiseOrTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto or_data_node = std::unique_ptr(new ConstantListValueNode(or_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(or_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseOr", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -180,11 +173,10 @@ TEST(FunctionTest, ListBitwiseOrTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto or_data_node = std::unique_ptr(new ConstantListValueNode(or_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(or_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseOr", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -203,11 +195,10 @@ TEST(FunctionTest, ListBitwiseXorTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto xor_data_node = std::unique_ptr(new ConstantValueNode(xor_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(xor_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseXor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -225,11 +216,10 @@ TEST(FunctionTest, ListBitwiseXorTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto xor_data_node = std::unique_ptr(new ConstantValueNode(xor_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(xor_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseXor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -247,11 +237,10 @@ TEST(FunctionTest, ListBitwiseXorTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto xor_data_node = std::unique_ptr(new ConstantListValueNode(xor_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(xor_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseXor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -269,11 +258,10 @@ TEST(FunctionTest, ListBitwiseXorTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto xor_data_node = std::unique_ptr(new ConstantListValueNode(xor_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(xor_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseXor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_cast_test.cc b/test/list_cast_test.cc index 5e0a5e9..fd8c5de 100644 --- a/test/list_cast_test.cc +++ b/test/list_cast_test.cc @@ -23,10 +23,9 @@ TEST(FunctionTest, ListCastI32ToI64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastI64List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -42,10 +41,9 @@ TEST(FunctionTest, ListCastU32ToF64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastF64List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -61,10 +59,9 @@ TEST(FunctionTest, ListCastF32ToI32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastI32List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -80,10 +77,9 @@ TEST(FunctionTest, ListCastStringToI32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastI32List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -99,10 +95,9 @@ TEST(FunctionTest, ListCastStringToI64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastI64List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -118,10 +113,9 @@ TEST(FunctionTest, ListCastStringToU8Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastU8List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -137,10 +131,9 @@ TEST(FunctionTest, ListCastI32ToStringTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastStringList", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -156,10 +149,9 @@ TEST(FunctionTest, ListCastU64ToStringTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastStringList", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_comparison_test.cc b/test/list_comparison_test.cc index cd5d38d..33394cb 100644 --- a/test/list_comparison_test.cc +++ b/test/list_comparison_test.cc @@ -25,11 +25,10 @@ TEST(FunctionTest, GenLargeBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -47,11 +46,10 @@ TEST(FunctionTest, GenLargeBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -69,11 +67,10 @@ TEST(FunctionTest, GenLargeBitmapTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -91,11 +88,10 @@ TEST(FunctionTest, GenLargeBitmapTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -113,11 +109,10 @@ TEST(FunctionTest, GenLargeBitmapTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -135,11 +130,10 @@ TEST(FunctionTest, GenLargeBitmapTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -157,11 +151,10 @@ TEST(FunctionTest, GenLargeEqualBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -179,11 +172,10 @@ TEST(FunctionTest, GenLargeEqualBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -201,11 +193,10 @@ TEST(FunctionTest, GenEqualBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -223,11 +214,10 @@ TEST(FunctionTest, GenEqualBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -245,11 +235,10 @@ TEST(FunctionTest, GenLessBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLessBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -267,11 +256,10 @@ TEST(FunctionTest, GenLessBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLessBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -289,11 +277,10 @@ TEST(FunctionTest, GenLessEqualBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLessEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -311,11 +298,10 @@ TEST(FunctionTest, GenLessEqualBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLessEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -333,11 +319,10 @@ TEST(FunctionTest, GenNotEqualBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenNotEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -355,11 +340,10 @@ TEST(FunctionTest, GenNotEqualBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenNotEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_conditional_test.cc b/test/list_conditional_test.cc index 2372539..8915479 100644 --- a/test/list_conditional_test.cc +++ b/test/list_conditional_test.cc @@ -27,12 +27,11 @@ TEST(FunctionTest, IfLargeTest1) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLarge", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -52,12 +51,11 @@ TEST(FunctionTest, IfLargeTest2) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLarge", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -77,12 +75,11 @@ TEST(FunctionTest, IfLargeTest3) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLarge", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -102,12 +99,11 @@ TEST(FunctionTest, IfLargeEqualTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLargeEqual", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -127,12 +123,11 @@ TEST(FunctionTest, IfEqualTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfEqual", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -152,12 +147,11 @@ TEST(FunctionTest, IfELessTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLess", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -177,12 +171,11 @@ TEST(FunctionTest, IfELessEqualTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLessEqual", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -202,12 +195,11 @@ TEST(FunctionTest, IfNotEqualTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfNotEqual", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -228,12 +220,11 @@ TEST(FunctionTest, IfByBitmapTest1) { auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); auto lhs_node = std::unique_ptr(new ConstantListValueNode(lhs)); auto rhs_node = std::unique_ptr(new ConstantValueNode(rhs)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(bitmap_node)); args_list.emplace_back(std::move(lhs_node)); args_list.emplace_back(std::move(rhs_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -256,12 +247,11 @@ TEST(FunctionTest, IfByBitmapTest2) { auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); auto lhs_node = std::unique_ptr(new ConstantValueNode(lhs)); auto rhs_node = std::unique_ptr(new ConstantListValueNode(rhs)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(bitmap_node)); args_list.emplace_back(std::move(lhs_node)); args_list.emplace_back(std::move(rhs_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -285,12 +275,11 @@ TEST(FunctionTest, IfByBitmapTest3) { auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); auto lhs_node = std::unique_ptr(new ConstantListValueNode(lhs)); auto rhs_node = std::unique_ptr(new ConstantListValueNode(rhs)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(bitmap_node)); args_list.emplace_back(std::move(lhs_node)); args_list.emplace_back(std::move(rhs_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_group_test.cc b/test/list_group_test.cc index e6915fe..53ba6e3 100644 --- a/test/list_group_test.cc +++ b/test/list_group_test.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-30 11:35:00 * @Last Modified by: victorika - * @Last Modified time: 2026-04-30 11:35:00 + * @Last Modified time: 2026-05-11 16:37:04 */ #include #include @@ -23,7 +23,6 @@ namespace { std::unique_ptr MakeGroupIndexCall(std::unique_ptr list_node) { std::vector> args; args.emplace_back(std::move(list_node)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupIndex", std::move(args))); } @@ -123,8 +122,8 @@ TEST(ListGroupTest, GroupIndexU32) { } TEST(ListGroupTest, GroupIndexU64Large) { - auto list = std::unique_ptr(new ConstantListValueNode( - std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); RetType result; ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); std::vector expected = {0, 1, 0, 1, 2}; @@ -173,8 +172,7 @@ TEST(ListGroupTest, GroupIndexStringEmpty) { } TEST(ListGroupTest, GroupIndexStringWithEmptyStrings) { - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); RetType result; ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); std::vector expected = {0, 1, 0, 2, 1, 0}; @@ -182,8 +180,8 @@ TEST(ListGroupTest, GroupIndexStringWithEmptyStrings) { } TEST(ListGroupTest, GroupIndexStringDifferentLengths) { - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); + auto list = + std::unique_ptr(new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); RetType result; ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); std::vector expected = {0, 1, 0, 2, 1}; @@ -268,7 +266,7 @@ TEST(ListGroupTest, GroupCountString) { namespace { -// Builds: GroupKeys(keys, GroupIndex(keys), GroupCount(GroupIndex(keys)), exec_ctx). +// Builds: GroupKeys(keys, GroupIndex(keys), GroupCount(GroupIndex(keys))). // The keys node is cloned so the same logical list feeds every argument, // mirroring how CSE would share the GroupIndex / GroupCount sub-expressions // with other aggregates in a real pipeline. @@ -279,7 +277,6 @@ std::unique_ptr MakeGroupKeysCall(std::unique_ptr keys_node) args.emplace_back(std::move(keys_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_for_index))); args.emplace_back(MakeGroupCountCall(std::move(keys_for_count))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); } @@ -379,8 +376,8 @@ TEST(ListGroupTest, GroupKeysU32) { } TEST(ListGroupTest, GroupKeysU64Large) { - auto list = std::unique_ptr(new ConstantListValueNode( - std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); std::vector expected = {0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL}; @@ -429,8 +426,7 @@ TEST(ListGroupTest, GroupKeysStringEmpty) { } TEST(ListGroupTest, GroupKeysStringWithEmptyStrings) { - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); std::vector expected = {"", "a", "b"}; @@ -438,8 +434,8 @@ TEST(ListGroupTest, GroupKeysStringWithEmptyStrings) { } TEST(ListGroupTest, GroupKeysStringDifferentLengths) { - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); + auto list = + std::unique_ptr(new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); std::vector expected = {"ab", "abc", "abcd"}; @@ -449,8 +445,8 @@ TEST(ListGroupTest, GroupKeysStringDifferentLengths) { TEST(ListGroupTest, GroupKeysPreservesFirstAppearanceOrder) { // Distinct keys must come out in the order of their first occurrence, not // sorted and not in hash-table order. - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{100, 50, 100, 75, 50, 25, 75, 100})); + auto list = + std::unique_ptr(new ConstantListValueNode(std::vector{100, 50, 100, 75, 50, 25, 75, 100})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); std::vector expected = {100, 50, 75, 25}; @@ -461,13 +457,11 @@ TEST(ListGroupTest, GroupKeysLenMismatchReturnsError) { // keys has 4 elements, group_index has 3 -> must surface a runtime error // instead of silently truncating. auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); std::vector> args; args.emplace_back(std::move(keys)); args.emplace_back(std::move(bad_group_index)); args.emplace_back(std::unique_ptr(new ConstantValueNode(static_cast(2U)))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); RetType result; @@ -479,18 +473,15 @@ TEST(ListGroupTest, GroupKeysLenMismatchReturnsError) { namespace { -// Builds the 3-arg sugar form: GroupKeys(keys, GroupIndex(keys), exec_ctx). +// Builds the 2-arg sugar form: GroupKeys(keys, GroupIndex(keys)). // This is the user-facing call registered as an LLVM intrinsic that expands -// at IR time into GroupCount + the canonical 4-arg GroupKeys kernel, letting -// GVN share the distinct-count computation with other aggregates. The -// trailing exec_context keeps the call shape consistent with other DSL -// functions (GroupIndex, etc.). +// at IR time into GroupCount + the canonical GroupKeys kernel, letting +// GVN share the distinct-count computation with other aggregates. std::unique_ptr MakeGroupKeysSugarCall(std::unique_ptr keys_node) { auto keys_for_index = keys_node->Clone(); std::vector> args; args.emplace_back(std::move(keys_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_for_index))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); } @@ -576,8 +567,8 @@ TEST(ListGroupTest, GroupKeysSugarU32) { } TEST(ListGroupTest, GroupKeysSugarU64Large) { - auto list = std::unique_ptr(new ConstantListValueNode( - std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); std::vector expected = {0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL}; @@ -629,12 +620,10 @@ TEST(ListGroupTest, GroupKeysSugarLenMismatchReturnsError) { // The sugar form forwards exec_context to the 4-arg kernel, which must still // surface the same "len mismatch" runtime error path. auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); std::vector> args; args.emplace_back(std::move(keys)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); RetType result; @@ -646,21 +635,20 @@ TEST(ListGroupTest, GroupKeysSugarLenMismatchReturnsError) { namespace { -// Builds: GroupSum(values, GroupIndex(keys), exec_ctx). Sugar form, same call -// shape as the user-facing DSL -- the IR-level expansion adds GroupCount and -// routes to the 4-arg kernel. Keys and values are separate nodes because they -// may be of different element types. +// Builds: GroupSum(values, GroupIndex(keys)). Sugar form, same call shape +// as the user-facing DSL -- the IR-level expansion adds GroupCount and +// routes to the 4-arg kernel. Keys and values are separate nodes because +// they may be of different element types. std::unique_ptr MakeGroupSumSugarCall(std::unique_ptr values_node, std::unique_ptr keys_node) { std::vector> args; args.emplace_back(std::move(values_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); } -// Builds: GroupSum(values, GroupIndex(keys), GroupCount(GroupIndex(keys)), exec_ctx). -// Exercises the raw 4-arg kernel directly so its contract is covered +// Builds: GroupSum(values, GroupIndex(keys), GroupCount(GroupIndex(keys))). +// Exercises the raw 3-arg kernel directly so its contract is covered // independently of the sugar-layer expansion. std::unique_ptr MakeGroupSumKernelCall(std::unique_ptr values_node, std::unique_ptr keys_node) { @@ -669,7 +657,6 @@ std::unique_ptr MakeGroupSumKernelCall(std::unique_ptr value args.emplace_back(std::move(values_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); args.emplace_back(MakeGroupCountCall(std::move(keys_for_count))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); } @@ -705,8 +692,7 @@ TEST(ListGroupTest, GroupSumSugarI32) { TEST(ListGroupTest, GroupSumSugarI8NegativeValues) { // Exercise i8 -> i64 promotion with negative values. auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 1, 2, 1, 2})); - auto values = - std::unique_ptr(new ConstantListValueNode(std::vector{-10, 20, -30, -40, 50})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{-10, 20, -30, -40, 50})); RetType result; ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); // group 0: -10 + 20 + (-40) = -30; group 1: -30 + 50 = 20 @@ -725,8 +711,8 @@ TEST(ListGroupTest, GroupSumSugarI16) { TEST(ListGroupTest, GroupSumSugarI64) { auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1})); - auto values = std::unique_ptr( - new ConstantListValueNode(std::vector{1LL << 40, 1LL << 41, -(1LL << 40)})); + auto values = + std::unique_ptr(new ConstantListValueNode(std::vector{1LL << 40, 1LL << 41, -(1LL << 40)})); RetType result; ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); std::vector expected = {0, 1LL << 41}; @@ -745,8 +731,8 @@ TEST(ListGroupTest, GroupSumSugarU8) { TEST(ListGroupTest, GroupSumSugarU64Large) { auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1})); - auto values = std::unique_ptr(new ConstantListValueNode( - std::vector{0xFFFFFFFFFFFFFFFEULL, 1ULL, 42ULL})); + auto values = + std::unique_ptr(new ConstantListValueNode(std::vector{0xFFFFFFFFFFFFFFFEULL, 1ULL, 42ULL})); RetType result; ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); // Group 0 sums exactly to UINT64_MAX. @@ -810,8 +796,8 @@ TEST(ListGroupTest, GroupSumSugarStringKeys) { // keys are strings, values are numeric. GroupIndex handles the string keys; // GroupSum just operates on the resulting u32 group_index, so this exercises // the full "keys can be anything, values can be anything" combination. - auto keys = std::unique_ptr( - new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto keys = + std::unique_ptr(new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); RetType result; ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); @@ -845,10 +831,10 @@ TEST(ListGroupTest, GroupSumKernelSugarAgreeF64) { // inputs -- protects against future divergence (e.g. if sugar starts // passing a different `distinct`). auto keys_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); - auto values_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); + auto values_sugar = + std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); RetType sugar_result; - ASSERT_TRUE( - RunGroupSum(MakeGroupSumSugarCall(std::move(values_sugar), std::move(keys_sugar)), &sugar_result).ok()); + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values_sugar), std::move(keys_sugar)), &sugar_result).ok()); auto keys_kernel = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); auto values_kernel = @@ -871,13 +857,11 @@ TEST(ListGroupTest, GroupSumLenMismatchReturnsError) { // values has 3 elements, group_index has 4 -> kernel must surface a runtime // error, same shape as GroupKeys len-mismatch handling. auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); args.emplace_back(std::unique_ptr(new ConstantValueNode(static_cast(2U)))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); RetType result; @@ -891,12 +875,10 @@ TEST(ListGroupTest, GroupSumSugarLenMismatchReturnsError) { // Same kind of mismatch reached through the sugar form, to prove the error // propagates across the IR-level expansion. auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); RetType result; @@ -909,19 +891,18 @@ TEST(ListGroupTest, GroupSumSugarLenMismatchReturnsError) { namespace { // Generic builder for a per-group aggregate sugar call of shape -// `(values, GroupIndex(keys), exec_ctx)`. Used by GroupMax / GroupMin -// tests and ready to be reused by later aggregates (Avg, ...). +// `(values, GroupIndex(keys))`. Used by GroupMax / GroupMin / +// GroupAvg sugars. std::unique_ptr MakeGroupAggSugarCall(const std::string &func_name, std::unique_ptr values_node, std::unique_ptr keys_node) { std::vector> args; args.emplace_back(std::move(values_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Same as above but for the raw 4-arg kernel: -// `(values, GroupIndex(keys), GroupCount(GroupIndex(keys)), exec_ctx)` +// Same as above but for the raw 3-arg kernel: +// `(values, GroupIndex(keys), GroupCount(GroupIndex(keys)))` std::unique_ptr MakeGroupAggKernelCall(const std::string &func_name, std::unique_ptr values_node, std::unique_ptr keys_node) { auto keys_for_count = keys_node->Clone(); @@ -929,7 +910,6 @@ std::unique_ptr MakeGroupAggKernelCall(const std::string &func_name, s args.emplace_back(std::move(values_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); args.emplace_back(MakeGroupCountCall(std::move(keys_for_count))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } @@ -1012,8 +992,8 @@ TEST(ListGroupTest, GroupMaxSugarEmpty) { } TEST(ListGroupTest, GroupMaxSugarStringKeys) { - auto keys = std::unique_ptr( - new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto keys = + std::unique_ptr(new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 7, 5, 4, 2, 3})); RetType result; ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); @@ -1087,8 +1067,8 @@ TEST(ListGroupTest, GroupMinSugarEmpty) { } TEST(ListGroupTest, GroupMinSugarStringKeys) { - auto keys = std::unique_ptr( - new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto keys = + std::unique_ptr(new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 7, 5, 4, 2, 3})); RetType result; ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMin", std::move(values), std::move(keys)), &result).ok()); @@ -1137,12 +1117,10 @@ TEST(ListGroupTest, GroupMaxMinConsistency) { TEST(ListGroupTest, GroupMaxSugarLenMismatchReturnsError) { auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupMax", std::move(args))); RetType result; @@ -1154,12 +1132,10 @@ TEST(ListGroupTest, GroupMaxSugarLenMismatchReturnsError) { TEST(ListGroupTest, GroupMinSugarLenMismatchReturnsError) { auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupMin", std::move(args))); RetType result; @@ -1197,8 +1173,8 @@ TEST(ListGroupTest, GroupAvgSugarI8NegativeValues) { ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); auto &actual = std::get>(result); ASSERT_EQ(actual.size(), 2U); - EXPECT_DOUBLE_EQ(actual[0], 5.0); // (-10 + 20) / 2 - EXPECT_DOUBLE_EQ(actual[1], -2.5); // (-3 + -2) / 2 <-- int would round to -2 + EXPECT_DOUBLE_EQ(actual[0], 5.0); // (-10 + 20) / 2 + EXPECT_DOUBLE_EQ(actual[1], -2.5); // (-3 + -2) / 2 <-- int would round to -2 } TEST(ListGroupTest, GroupAvgSugarU64) { @@ -1233,8 +1209,8 @@ TEST(ListGroupTest, GroupAvgSugarF64) { ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); auto &actual = std::get>(result); ASSERT_EQ(actual.size(), 3U); - EXPECT_DOUBLE_EQ(actual[0], 0.2); // (0.1 + 0.3) / 2 - EXPECT_DOUBLE_EQ(actual[1], 0.3); // (0.2 + 0.4) / 2 + EXPECT_DOUBLE_EQ(actual[0], 0.2); // (0.1 + 0.3) / 2 + EXPECT_DOUBLE_EQ(actual[1], 0.3); // (0.2 + 0.4) / 2 EXPECT_DOUBLE_EQ(actual[2], 0.5); } @@ -1263,7 +1239,7 @@ TEST(ListGroupTest, GroupAvgSugarAllSameGroup) { ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); auto &actual = std::get>(result); ASSERT_EQ(actual.size(), 1U); - EXPECT_DOUBLE_EQ(actual[0], 2.5); // (1+2+3+4)/4 + EXPECT_DOUBLE_EQ(actual[0], 2.5); // (1+2+3+4)/4 } TEST(ListGroupTest, GroupAvgSugarAllDistinctGroups) { @@ -1280,8 +1256,8 @@ TEST(ListGroupTest, GroupAvgSugarAllDistinctGroups) { } TEST(ListGroupTest, GroupAvgSugarStringKeys) { - auto keys = std::unique_ptr( - new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto keys = + std::unique_ptr(new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); RetType result; ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); @@ -1311,7 +1287,8 @@ TEST(ListGroupTest, GroupAvgKernelSugarAgreeF64) { // results given identical inputs. Guards against future divergence (e.g. // sugar starting to pass a different `distinct` than GroupCount). auto keys_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); - auto values_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); + auto values_sugar = + std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); RetType sugar_result; ASSERT_TRUE( RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values_sugar), std::move(keys_sugar)), &sugar_result) @@ -1359,13 +1336,11 @@ TEST(ListGroupTest, GroupAvgMatchesSumOverCount) { TEST(ListGroupTest, GroupAvgKernelLenMismatchReturnsError) { auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); args.emplace_back(std::unique_ptr(new ConstantValueNode(static_cast(2U)))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupAvg", std::move(args))); RetType result; @@ -1377,12 +1352,10 @@ TEST(ListGroupTest, GroupAvgKernelLenMismatchReturnsError) { TEST(ListGroupTest, GroupAvgSugarLenMismatchReturnsError) { auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupAvg", std::move(args))); RetType result; diff --git a/test/list_indexing_test.cc b/test/list_indexing_test.cc index 4620f85..f56945e 100644 --- a/test/list_indexing_test.cc +++ b/test/list_indexing_test.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-05-06 11:20:00 * @Last Modified by: victorika - * @Last Modified time: 2026-05-06 11:20:00 + * @Last Modified time: 2026-05-11 16:35:40 */ #include #include @@ -23,26 +23,27 @@ namespace { constexpr uint32_t kMiss = std::numeric_limits::max(); -// Build a FunctionNode that takes two lists and an ExecContextNode. +// Build a FunctionNode that takes two lists. ListLookupIndex is registered +// as a sugar lowering and its user-visible signature does NOT include the +// trailing exec_ctx; the codegen pulls ctx from the entry function itself. std::unique_ptr MakeLookup(std::unique_ptr a, std::unique_ptr b) { std::vector> args; args.emplace_back(std::move(a)); args.emplace_back(std::move(b)); - args.emplace_back(std::make_unique()); return std::make_unique("ListLookupIndex", std::move(args)); } std::unique_ptr MakeCompactPositions(std::unique_ptr raw) { std::vector> args; args.emplace_back(std::move(raw)); - args.emplace_back(std::make_unique()); + return std::make_unique("ListCompactPositions", std::move(args)); } std::unique_ptr MakeCompactIndex(std::unique_ptr raw) { std::vector> args; args.emplace_back(std::move(raw)); - args.emplace_back(std::make_unique()); + return std::make_unique("ListCompactIndex", std::move(args)); } @@ -52,7 +53,7 @@ std::unique_ptr MakeGather(std::unique_ptr values, std::uniq args.emplace_back(std::move(values)); args.emplace_back(std::move(idx)); args.emplace_back(std::move(default_value)); - args.emplace_back(std::make_unique()); + return std::make_unique("ListGather", std::move(args)); } @@ -81,7 +82,7 @@ std::unique_ptr MakeGetAt(std::unique_ptr values, std::uniqu return std::make_unique("GetAt", std::move(args)); } -RetType RunExpr(std::unique_ptr root, Status *status_out = nullptr) { +RetType RunExpr(std::unique_ptr root, Status* status_out = nullptr) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ExecEngine engine; @@ -615,13 +616,13 @@ TEST(ListIndexingTest, FindMissMatchesFindSortedMiss) { namespace { -// Build a Bucketize(values, boundaries, exec_ctx) FunctionNode. +// Build a Bucketize(values, boundaries) FunctionNode. template std::unique_ptr MakeBucketize(const std::vector& values, const std::vector& boundaries) { std::vector> args; args.emplace_back(std::make_unique(values)); args.emplace_back(std::make_unique(boundaries)); - args.emplace_back(std::make_unique()); + return std::make_unique("Bucketize", std::move(args)); } diff --git a/test/list_math_test.cc b/test/list_math_test.cc index cbececb..810b7b2 100644 --- a/test/list_math_test.cc +++ b/test/list_math_test.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-16 11:22:31 * @Last Modified by: victorika - * @Last Modified time: 2026-04-16 11:22:31 + * @Last Modified time: 2026-05-11 16:56:43 */ #include #include @@ -23,10 +23,9 @@ TEST(FunctionTest, ListExpTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListExp", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -46,10 +45,9 @@ TEST(FunctionTest, ListExpTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListExp", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -68,10 +66,9 @@ TEST(FunctionTest, ListExpTest3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListExp", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -87,10 +84,9 @@ TEST(FunctionTest, ListLogTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -107,10 +103,9 @@ TEST(FunctionTest, ListLogTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -126,10 +121,9 @@ TEST(FunctionTest, ListLogTest3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -145,10 +139,9 @@ TEST(FunctionTest, ListLog2Test1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog2", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -165,10 +158,9 @@ TEST(FunctionTest, ListLog2Test2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog2", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -184,10 +176,9 @@ TEST(FunctionTest, ListLog2Test3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog2", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -203,10 +194,9 @@ TEST(FunctionTest, ListLog10Test1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog10", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -223,10 +213,9 @@ TEST(FunctionTest, ListLog10Test2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog10", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -242,10 +231,9 @@ TEST(FunctionTest, ListLog10Test3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog10", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -261,10 +249,9 @@ TEST(FunctionTest, ListCeilTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListCeil", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -282,10 +269,9 @@ TEST(FunctionTest, ListCeilTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListCeil", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -301,10 +287,9 @@ TEST(FunctionTest, ListFloorTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListFloor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -322,10 +307,9 @@ TEST(FunctionTest, ListFloorTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListFloor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -341,10 +325,9 @@ TEST(FunctionTest, ListRoundTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListRound", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -362,10 +345,9 @@ TEST(FunctionTest, ListRoundTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListRound", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -383,11 +365,10 @@ TEST(FunctionTest, ListMinTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMin", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -405,11 +386,10 @@ TEST(FunctionTest, ListMinTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMin", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -427,11 +407,10 @@ TEST(FunctionTest, ListMinTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMin", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -449,11 +428,10 @@ TEST(FunctionTest, ListMaxTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMax", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -471,11 +449,10 @@ TEST(FunctionTest, ListMaxTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMax", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -493,11 +470,10 @@ TEST(FunctionTest, ListMaxTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMax", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_misc_test.cc b/test/list_misc_test.cc index a742d9a..c58eb9a 100644 --- a/test/list_misc_test.cc +++ b/test/list_misc_test.cc @@ -26,11 +26,9 @@ TEST(FunctionTest, FilterByBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(bitmap_node)); - args_list.emplace_back(std::move(exec_node)); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -49,11 +47,9 @@ TEST(FunctionTest, FilterByBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(bitmap_node)); - args_list.emplace_back(std::move(exec_node)); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -64,9 +60,9 @@ TEST(FunctionTest, FilterByBitmapTest2) { EXPECT_EQ(std::get>(result), expect); } -// Keep one test exercising the 4-arg explicit-bits_cnt kernel directly, so the +// Keep one test exercising the explicit-bits_cnt kernel directly, so the // underlying kernel (and its validation logic) stays under coverage even after -// the 3-arg sugar became the recommended path. +// the 2-arg sugar became the recommended path. TEST(FunctionTest, FilterByBitmapExplicitBitsCntTest) { std::vector data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}; @@ -76,12 +72,10 @@ TEST(FunctionTest, FilterByBitmapExplicitBitsCntTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); auto bits_cnt_node = std::unique_ptr(new ConstantValueNode(12U)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(bitmap_node)); args_list.emplace_back(std::move(bits_cnt_node)); - args_list.emplace_back(std::move(exec_node)); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -100,18 +94,16 @@ TEST(FunctionTest, FilterByBitmapSugarFromGenBitmapTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); - // bitmap = GenLargeBitmap(data, 3, exec_ctx) -> keep elements > 3 + // bitmap = GenLargeBitmap(data, 3) -> keep elements > 3 std::vector> gen_args; gen_args.emplace_back(new ConstantListValueNode(data)); gen_args.emplace_back(new ConstantValueNode(static_cast(3))); - gen_args.emplace_back(new ExecContextNode()); auto bitmap_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(gen_args))); - // FilterByBitmap(data, bitmap, exec_ctx) -- sugar, no bits_cnt. + // FilterByBitmap(data, bitmap) -- sugar, no bits_cnt. std::vector> filter_args; filter_args.emplace_back(new ConstantListValueNode(data)); filter_args.emplace_back(std::move(bitmap_node)); - filter_args.emplace_back(new ExecContextNode()); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(filter_args))); ExecEngine exec_engine; @@ -234,10 +226,9 @@ TEST(FunctionTest, UniqueU32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -253,10 +244,9 @@ TEST(FunctionTest, UniqueI32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -272,10 +262,9 @@ TEST(FunctionTest, UniqueF64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -291,10 +280,9 @@ TEST(FunctionTest, UniqueAlreadyUniqueTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -310,10 +298,9 @@ TEST(FunctionTest, UniqueAllSameTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -329,10 +316,9 @@ TEST(FunctionTest, UniqueStringTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -348,10 +334,9 @@ TEST(FunctionTest, UniqueStringAllSameTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry);