factotum/NOCLIP
1
Fork 0
Code Issues 10 Projects Releases Activity
NOCLIP/source/command.zig

531 lines
20 KiB
Zig
Raw Normal View History

restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
const std = @import("std");
const StructField = std.builtin.Type.StructField;
help: start grinding away at help text generation I am resisting the urge to try to codegolf this into fewer lines. It's going to end up being a sprawl, but it is what it is. The main part of this that will actually require intelligent thought is the column wrapping and alignment. I think I will probably be implementing a custom writer style thing to handle that. There are a lot of annoying loose odds and ends here. Choice types should list all the choices. But we can't necessarily assume that an enum-typed parameter is a choice type (only if it uses the default converter). Perhaps the conversion stuff should be turned into an interface that can also be responsible for converting the default value and providing additional information. For now I will probably just hack it so that I can move on to other things.
2023-04-02 15:11:50 -07:00
const help = @import("./help.zig");
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
const ncmeta = @import("./meta.zig");
const parameters = @import("./parameters.zig");
const parser = @import("./parser.zig");
const ValueCount = parameters.ValueCount;
const ParameterGenerics = parameters.ParameterGenerics;
const OptionConfig = parameters.OptionConfig;
const FlagConfig = parameters.FlagConfig;
command/parser: sketch out help flag integration This is a special case flag that cannot be replicated with the normal machinery. It's much easier to special case it. So here we go.
2023-04-01 13:04:02 -07:00
const ShortLongPair = parameters.ShortLongPair;
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
const FlagBias = parameters.FlagBias;
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
const makeOption = parameters.makeOption;
const makeArgument = parameters.makeArgument;
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
const Parser = parser.Parser;
const ParserInterface = parser.ParserInterface;
fn BuilderGenerics(comptime UserContext: type) type {
return struct {
OutputType: type = void,
value_count: ValueCount = .{ .fixed = 1 },
multi: bool = false,
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn argGen(comptime self: @This()) ParameterGenerics {
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
if (self.value_count == .flag) @compileError("argument may not be a flag");
if (self.value_count == .count) @compileError("argument may not be a count");
return ParameterGenerics{
.UserContext = UserContext,
.OutputType = self.OutputType,
.param_type = .Ordinal,
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
.value_count = ParameterGenerics.fixedValueCount(self.OutputType, self.value_count),
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
.multi = self.multi,
};
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn optGen(comptime self: @This()) ParameterGenerics {
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
if (self.value_count == .flag) @compileError("option may not be a flag");
parser: support unexposed values Having thought about this more, it seems likely that complex converters could benefit from being able to parse their arguments on the fly without having to structure them into a rigid type. This is sort of a get out of jail free card for custom converters as they can dump into the user context type or whatever they want directly.
2023-04-03 01:36:45 -07:00
if (self.value_count == .count) @compileError("option may not be a count");
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
return ParameterGenerics{
.UserContext = UserContext,
.OutputType = self.OutputType,
.param_type = .Nominal,
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
.value_count = ParameterGenerics.fixedValueCount(self.OutputType, self.value_count),
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
.multi = self.multi,
};
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn countGen(comptime _: @This()) ParameterGenerics {
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
return ParameterGenerics{
.UserContext = UserContext,
.OutputType = usize,
.param_type = .Nominal,
.value_count = .count,
.multi = true,
};
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn flagGen(comptime self: @This()) ParameterGenerics {
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
return ParameterGenerics{
.UserContext = UserContext,
.OutputType = bool,
.param_type = .Nominal,
.value_count = .flag,
.multi = self.multi,
};
}
};
}
command: add `commandGroup` function This just creates an empty command with an auto-assigned noop callback. This is useful sugar for creating a group of commands under a common name because previously the user would have to define their own noop callback and bind it. This just takes a description string (and, optionally, a help flag override).
2023-09-10 14:52:49 -07:00
pub const GroupOptions = struct {
help_flag: ShortLongPair = .{ .short_tag = "-h", .long_tag = "--help" },
description: []const u8,
};
pub fn commandGroup(allocator: std.mem.Allocator, comptime options: GroupOptions) !ParserInterface {
const cmd = comptime CommandBuilder(void){
.help_flag = options.help_flag,
.description = options.description,
.subcommand_required = true,
};
return try cmd.createInterface(allocator, cmd.noopCallback());
}
command, parser: try to clean up UserContext type handling This is a feeble attempt to unify some logic, as I realized that Command.createInterface had different logic for handling the user context than Parser did, which broke certain use cases (using a slice as the context for example). I'm not convinced this really unifies the logic as much as wraps it in another layer of indirection, but at least the core problem is solved.
2023-09-10 14:50:44 -07:00
fn InterfaceCreator(comptime Command: type) type {
return if (Command.ICC.InputType()) |Type|
struct {
pub fn createInterface(
comptime self: Command,
allocator: std.mem.Allocator,
comptime callback: self.CallbackSignature(),
context: Type,
) !ParserInterface {
return try self._createInterfaceImpl(allocator, callback, context);
}
}
else
struct {
pub fn createInterface(
comptime self: Command,
allocator: std.mem.Allocator,
comptime callback: self.CallbackSignature(),
) !ParserInterface {
return try self._createInterfaceImpl(allocator, callback, void{});
}
};
}
pub const InterfaceContextCategory = union(enum) {
empty,
pointer: type,
value: type,
pub fn fromType(comptime ContextType: type) InterfaceContextCategory {
return switch (@typeInfo(ContextType)) {
.Void => .empty,
.Pointer => |info| if (info.size == .Slice) .{ .value = ContextType } else .{ .pointer = ContextType },
// technically, i0, u0, and struct{} should be treated as empty, probably
else => .{ .value = ContextType },
};
}
pub fn InputType(comptime self: InterfaceContextCategory) ?type {
return switch (self) {
.empty => null,
.pointer => |Type| Type,
.value => |Type| *const Type,
};
}
pub fn OutputType(comptime self: InterfaceContextCategory) type {
return switch (self) {
.empty => void,
.pointer => |Type| Type,
.value => |Type| Type,
};
}
};
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
pub fn CommandBuilder(comptime UserContext: type) type {
return struct {
command/parser: sketch out help flag integration This is a special case flag that cannot be replicated with the normal machinery. It's much easier to special case it. So here we go.
2023-04-01 13:04:02 -07:00
param_spec: ncmeta.TupleBuilder = .{},
// this is a strange hack, but it's easily the path of least resistance
help_flag: ShortLongPair = .{ .short_tag = "-h", .long_tag = "--help" },
/// if any subcommands are provided, one of them must be specified, or the command has failed.
subcommand_required: bool = true,
command: remove init function Maybe this is short-sighted, but it wasn't really doing anything. Chuck it.
2023-04-04 23:22:12 -07:00
description: []const u8,
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
pub const UserContextType = UserContext;
command, parser: try to clean up UserContext type handling This is a feeble attempt to unify some logic, as I realized that Command.createInterface had different logic for handling the user context than Parser did, which broke certain use cases (using a slice as the context for example). I'm not convinced this really unifies the logic as much as wraps it in another layer of indirection, but at least the core problem is solved.
2023-09-10 14:50:44 -07:00
pub const ICC: InterfaceContextCategory = InterfaceContextCategory.fromType(UserContextType);
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn createParser(
command/parser: sketch out help flag integration This is a special case flag that cannot be replicated with the normal machinery. It's much easier to special case it. So here we go.
2023-04-01 13:04:02 -07:00
comptime self: @This(),
comptime callback: self.CallbackSignature(),
allocator: std.mem.Allocator,
parser: shove an arena allocator in there Stay a while and listen to my story. Due to the design of the parser execution flow, the only reasonable way to avoid leaking memory in the parser is to use an arena allocator because the parser itself doesn't have direct access to everything it allocates, and everything it allocates needs to live for the duration of whatever callbacks are called. Now, you might say, if the items it allocates are stored for the lifetime of whatever callbacks, then that means that the items it allocates stay allocated for effectively the entire life of the program. In which case there's really not much point in freeing them at all, as it's just extra work on exit that the OS should normally clean up. And you'd be right, except for two details: if the user uses the current GeneralPurposeAllocator, it will complain about leaks when deinitialized, which simply isn't groovy. The other detail is that technically the user can run any code they want after the parser execution finishes, so forcing the user to leak memory by having an incomplete API is rude. The other option would be, as before, forcing the user to supply their own arena allocator if they don't want to leak, but that's kind of a rude thing to do and goes against the "all allocators look the same" design of the standard library, which is what makes it so easy to use and create allocators with advanced functionality. That seems like an ugly thing to do, so, instead, each parser gets to eat the memory cost of storing a pointer to its arena allocator (and the heap cost of the arena allocator itself). In theory, subcommands could borrow the arena allocator of their parent command to save a bit of heap space, but that would make a variety of creation and cleanup-related tasks less isomorphic between the parents and the subcommands. I like the current design where commands and subcommands are the same thing, and I'm not in a rush to disturb that. I don't think the overhead cost of the arena allocator itself, which can be measured in double digit bytes, is a particularly steep price to pay.
2023-07-20 23:15:37 -07:00
) !Parser(self, callback) {
// note: this is freed in Parser.deinit
var arena = try allocator.create(std.heap.ArenaAllocator);
arena.* = std.heap.ArenaAllocator.init(allocator);
const arena_alloc = arena.allocator();
command/parser: sketch out help flag integration This is a special case flag that cannot be replicated with the normal machinery. It's much easier to special case it. So here we go.
2023-04-01 13:04:02 -07:00
return Parser(self, callback){
parser: shove an arena allocator in there Stay a while and listen to my story. Due to the design of the parser execution flow, the only reasonable way to avoid leaking memory in the parser is to use an arena allocator because the parser itself doesn't have direct access to everything it allocates, and everything it allocates needs to live for the duration of whatever callbacks are called. Now, you might say, if the items it allocates are stored for the lifetime of whatever callbacks, then that means that the items it allocates stay allocated for effectively the entire life of the program. In which case there's really not much point in freeing them at all, as it's just extra work on exit that the OS should normally clean up. And you'd be right, except for two details: if the user uses the current GeneralPurposeAllocator, it will complain about leaks when deinitialized, which simply isn't groovy. The other detail is that technically the user can run any code they want after the parser execution finishes, so forcing the user to leak memory by having an incomplete API is rude. The other option would be, as before, forcing the user to supply their own arena allocator if they don't want to leak, but that's kind of a rude thing to do and goes against the "all allocators look the same" design of the standard library, which is what makes it so easy to use and create allocators with advanced functionality. That seems like an ugly thing to do, so, instead, each parser gets to eat the memory cost of storing a pointer to its arena allocator (and the heap cost of the arena allocator itself). In theory, subcommands could borrow the arena allocator of their parent command to save a bit of heap space, but that would make a variety of creation and cleanup-related tasks less isomorphic between the parents and the subcommands. I like the current design where commands and subcommands are the same thing, and I'm not in a rush to disturb that. I don't think the overhead cost of the arena allocator itself, which can be measured in double digit bytes, is a particularly steep price to pay.
2023-07-20 23:15:37 -07:00
.arena = arena,
.allocator = arena_alloc,
command: preserve subcommand definition order This was as simple as switching to an order preserving hashmap. This lets the user decide which order their subcommands should be presented in.
2023-11-08 22:56:11 -08:00
.subcommands = parser.CommandMap.init(arena_alloc),
parser: shove an arena allocator in there Stay a while and listen to my story. Due to the design of the parser execution flow, the only reasonable way to avoid leaking memory in the parser is to use an arena allocator because the parser itself doesn't have direct access to everything it allocates, and everything it allocates needs to live for the duration of whatever callbacks are called. Now, you might say, if the items it allocates are stored for the lifetime of whatever callbacks, then that means that the items it allocates stay allocated for effectively the entire life of the program. In which case there's really not much point in freeing them at all, as it's just extra work on exit that the OS should normally clean up. And you'd be right, except for two details: if the user uses the current GeneralPurposeAllocator, it will complain about leaks when deinitialized, which simply isn't groovy. The other detail is that technically the user can run any code they want after the parser execution finishes, so forcing the user to leak memory by having an incomplete API is rude. The other option would be, as before, forcing the user to supply their own arena allocator if they don't want to leak, but that's kind of a rude thing to do and goes against the "all allocators look the same" design of the standard library, which is what makes it so easy to use and create allocators with advanced functionality. That seems like an ugly thing to do, so, instead, each parser gets to eat the memory cost of storing a pointer to its arena allocator (and the heap cost of the arena allocator itself). In theory, subcommands could borrow the arena allocator of their parent command to save a bit of heap space, but that would make a variety of creation and cleanup-related tasks less isomorphic between the parents and the subcommands. I like the current design where commands and subcommands are the same thing, and I'm not in a rush to disturb that. I don't think the overhead cost of the arena allocator itself, which can be measured in double digit bytes, is a particularly steep price to pay.
2023-07-20 23:15:37 -07:00
.help_builder = help.HelpBuilder(self).init(arena_alloc),
command/parser: sketch out help flag integration This is a special case flag that cannot be replicated with the normal machinery. It's much easier to special case it. So here we go.
2023-04-01 13:04:02 -07:00
};
}
command, parser: try to clean up UserContext type handling This is a feeble attempt to unify some logic, as I realized that Command.createInterface had different logic for handling the user context than Parser did, which broke certain use cases (using a slice as the context for example). I'm not convinced this really unifies the logic as much as wraps it in another layer of indirection, but at least the core problem is solved.
2023-09-10 14:50:44 -07:00
pub usingnamespace InterfaceCreator(@This());
fn _createInterfaceImpl(
command: add a method for creating owned interfaces This allocates the interface with its own arena allocator, allowing it to live beyond its stack lifetime. This enables some useful patterns for composing a CLI from multiple functions or files. This is actually probably the preferred method over `create_parser` in most circumstances.
2023-08-04 00:14:40 -07:00
comptime self: @This(),
allocator: std.mem.Allocator,
command, parser: try to clean up UserContext type handling This is a feeble attempt to unify some logic, as I realized that Command.createInterface had different logic for handling the user context than Parser did, which broke certain use cases (using a slice as the context for example). I'm not convinced this really unifies the logic as much as wraps it in another layer of indirection, but at least the core problem is solved.
2023-09-10 14:50:44 -07:00
comptime callback: self.CallbackSignature(),
context: (ICC.InputType() orelse void),
command: add a method for creating owned interfaces This allocates the interface with its own arena allocator, allowing it to live beyond its stack lifetime. This enables some useful patterns for composing a CLI from multiple functions or files. This is actually probably the preferred method over `create_parser` in most circumstances.
2023-08-04 00:14:40 -07:00
) !ParserInterface {
var arena = try allocator.create(std.heap.ArenaAllocator);
arena.* = std.heap.ArenaAllocator.init(allocator);
const arena_alloc = arena.allocator();
var this_parser = try arena_alloc.create(Parser(self, callback));
this_parser.* = .{
.arena = arena,
.allocator = arena_alloc,
command: preserve subcommand definition order This was as simple as switching to an order preserving hashmap. This lets the user decide which order their subcommands should be presented in.
2023-11-08 22:56:11 -08:00
.subcommands = parser.CommandMap.init(arena_alloc),
command: add a method for creating owned interfaces This allocates the interface with its own arena allocator, allowing it to live beyond its stack lifetime. This enables some useful patterns for composing a CLI from multiple functions or files. This is actually probably the preferred method over `create_parser` in most circumstances.
2023-08-04 00:14:40 -07:00
.help_builder = help.HelpBuilder(self).init(arena_alloc),
};
command, parser: try to clean up UserContext type handling This is a feeble attempt to unify some logic, as I realized that Command.createInterface had different logic for handling the user context than Parser did, which broke certain use cases (using a slice as the context for example). I'm not convinced this really unifies the logic as much as wraps it in another layer of indirection, but at least the core problem is solved.
2023-09-10 14:50:44 -07:00
if (comptime ICC == .empty) {
command: add a method for creating owned interfaces This allocates the interface with its own arena allocator, allowing it to live beyond its stack lifetime. This enables some useful patterns for composing a CLI from multiple functions or files. This is actually probably the preferred method over `create_parser` in most circumstances.
2023-08-04 00:14:40 -07:00
return this_parser.interface();
} else {
return this_parser.interface(context);
}
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn setHelpFlag(
command/parser: sketch out help flag integration This is a special case flag that cannot be replicated with the normal machinery. It's much easier to special case it. So here we go.
2023-04-01 13:04:02 -07:00
comptime self: *@This(),
comptime tags: ShortLongPair,
) void {
self.help_flag = tags;
}
parser: parse into 0-terminated strings This was kind of an annoying change to make since 0.11.0 has issues where it will point to the wrong srcloc on compile errors in generic code (which this 100% is) fortunately fixed in master. The motivation for this change is that the arg vector already contains 0-terminated strings, so we can avoid a lot of copies. This makes forwarding command-line arguments to C-functions that expect zero-terminated strings much more straightforward, and they also automatically decay to normal slices. Unfortunately, environment variable values are NOT zero-terminated, so they are currently copied with zero-termination. This seems to be the fault of Windows/WASI, both of which already are performing allocations (Windows to convert from UTF-16 to UTF-8, and WASI to get a copy of the environment). By duplicating the std EnvMap implementation, we could make a version that generates 0-terminated env vars without extra copies, but I'll skip on doing that for now.
2023-08-27 13:53:14 -07:00
const string_generics = BuilderGenerics(UserContext){ .OutputType = [:0]const u8 };
command/parser: sketch out help flag integration This is a special case flag that cannot be replicated with the normal machinery. It's much easier to special case it. So here we go.
2023-04-01 13:04:02 -07:00
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn stringOption(
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
comptime self: *@This(),
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
comptime cfg: OptionConfig(string_generics.optGen()),
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
) void {
const config = if (cfg.nice_type_name == null)
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
ncmeta.copyStruct(@TypeOf(cfg), cfg, .{ .nice_type_name = "string" })
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
else
cfg;
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
self.addOption(string_generics, config);
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn stringArgument(
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
comptime self: *@This(),
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
comptime cfg: OptionConfig(string_generics.argGen()),
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
) void {
const config = if (cfg.nice_type_name == null)
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
ncmeta.copyStruct(@TypeOf(cfg), cfg, .{ .nice_type_name = "string" })
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
else
cfg;
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
self.addArgument(string_generics, config);
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn simpleFlag(
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
comptime self: *@This(),
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
comptime cfg: FlagConfig(string_generics.flagGen()),
command: add a few helper functions There's going to be more where this came from. Since this is our main API, directly exposing all of the built-in functionality at this layer is desirable.
2023-04-03 01:38:00 -07:00
) void {
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
self.addFlag(string_generics, cfg);
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn addArgument(
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
comptime self: *@This(),
comptime bgen: BuilderGenerics(UserContext),
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
comptime config: OptionConfig(bgen.argGen()),
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
) void {
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
self.param_spec.add(makeArgument(bgen.argGen(), config));
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn addOption(
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
comptime self: *@This(),
comptime bgen: BuilderGenerics(UserContext),
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
comptime config: OptionConfig(bgen.optGen()),
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
) void {
if (comptime bgen.value_count == .fixed and bgen.value_count.fixed == 0) {
@compileError(
"please use add_flag rather than add_option to " ++
"create a 0-argument option",
);
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
self.param_spec.add(makeOption(bgen.optGen(), config));
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
pub fn addFlag(
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
comptime self: *@This(),
comptime bgen: BuilderGenerics(UserContext),
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
comptime config: FlagConfig(bgen.flagGen()),
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
) void {
comptime {
if (config.truthy == null and config.falsy == null and config.env_var == null) {
@compileError(
"flag " ++
config.name ++
" must have at least one of truthy flags, falsy flags, or env_var flags",
);
}
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
const generics = bgen.flagGen();
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
var args = OptionConfig(generics){
.name = config.name,
//
.short_tag = null,
.long_tag = null,
.env_var = null,
//
.description = config.description,
.default = config.default,
.converter = config.converter,
//
.eager = config.eager,
.required = config.required,
.global = config.global,
//
.secret = config.secret,
.nice_type_name = "flag",
};
if (config.truthy) |truthy_pair| {
if (truthy_pair.short_tag == null and truthy_pair.long_tag == null) {
@compileError(
"flag " ++
config.name ++
" truthy pair must have at least short or long tags set",
);
}
args.short_tag = truthy_pair.short_tag;
args.long_tag = truthy_pair.long_tag;
args.flag_bias = .truthy;
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
self.param_spec.add(makeOption(generics, args));
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
}
if (config.falsy) |falsy_pair| {
if (falsy_pair.short_tag == null and falsy_pair.long_tag == null) {
@compileError(
"flag " ++
config.name ++
" falsy pair must have at least short or long tags set",
);
}
args.short_tag = falsy_pair.short_tag;
args.long_tag = falsy_pair.long_tag;
args.flag_bias = .falsy;
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
self.param_spec.add(makeOption(generics, args));
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
}
if (config.env_var) |env_var| {
// @compileLog(env_var);
args.short_tag = null;
args.long_tag = null;
args.env_var = env_var;
args.flag_bias = .unbiased;
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
self.param_spec.add(makeOption(generics, args));
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
}
}
}
pub fn generate(comptime self: @This()) self.param_spec.TupleType() {
return self.param_spec.realTuple();
}
command: add `commandGroup` function This just creates an empty command with an auto-assigned noop callback. This is useful sugar for creating a group of commands under a common name because previously the user would have to define their own noop callback and bind it. This just takes a description string (and, optionally, a help flag override).
2023-09-10 14:52:49 -07:00
pub fn noopCallback(comptime self: @This()) self.CallbackSignature() {
return struct {
fn callback(_: UserContextType, _: self.Output()) !void {}
}.callback;
}
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
pub fn CallbackSignature(comptime self: @This()) type {
command, parser: try to clean up UserContext type handling This is a feeble attempt to unify some logic, as I realized that Command.createInterface had different logic for handling the user context than Parser did, which broke certain use cases (using a slice as the context for example). I'm not convinced this really unifies the logic as much as wraps it in another layer of indirection, but at least the core problem is solved.
2023-09-10 14:50:44 -07:00
return *const fn (UserContextType, self.Output()) anyerror!void;
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
}
pub fn Output(comptime self: @This()) type {
comptime {
const spec = self.generate();
var fields: []const StructField = &[_]StructField{};
var flag_skip = 0;
var tag_fields: []const StructField = &[_]StructField{};
var env_var_fields: []const StructField = &[_]StructField{};
paramloop: for (spec, 0..) |param, idx| {
parser: support unexposed values Having thought about this more, it seems likely that complex converters could benefit from being able to parse their arguments on the fly without having to structure them into a rigid type. This is sort of a get out of jail free card for custom converters as they can dump into the user context type or whatever they want directly.
2023-04-03 01:36:45 -07:00
const PType = @TypeOf(param);
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
// these three blocks are to check for redundantly defined tags and
// environment variables. This only works within a command. It
// doesn't support compile time checks for conflict into
// subcommands because those are attached at runtime. also, only
// global tags and env_vars would conflict, which is less common.
if (param.short_tag) |short|
tag_fields = tag_fields ++ &[_]StructField{.{
command: coerce field names to null-terminated strings ziglang/zig@a02bd81760166d679ccee0e190bf62115272ffbe changed builtin.StructField to necessitate this, but this should also be backwards compatible since these should decay to plain slices just fine.
2024-01-15 22:42:26 -08:00
// this goofy construct coerces the comptime []const u8 to
// [:0]const u8.
.name = short ++ "",
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
.type = void,
.default_value = null,
.is_comptime = false,
.alignment = 0,
}};
if (param.long_tag) |long|
tag_fields = tag_fields ++ &[_]StructField{.{
command: coerce field names to null-terminated strings ziglang/zig@a02bd81760166d679ccee0e190bf62115272ffbe changed builtin.StructField to necessitate this, but this should also be backwards compatible since these should decay to plain slices just fine.
2024-01-15 22:42:26 -08:00
.name = long ++ "",
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
.type = void,
.default_value = null,
.is_comptime = false,
.alignment = 0,
}};
if (param.env_var) |env_var|
env_var_fields = env_var_fields ++ &[_]StructField{.{
command: coerce field names to null-terminated strings ziglang/zig@a02bd81760166d679ccee0e190bf62115272ffbe changed builtin.StructField to necessitate this, but this should also be backwards compatible since these should decay to plain slices just fine.
2024-01-15 22:42:26 -08:00
.name = env_var ++ "",
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
.type = void,
.default_value = null,
.is_comptime = false,
.alignment = 0,
}};
parser: support unexposed values Having thought about this more, it seems likely that complex converters could benefit from being able to parse their arguments on the fly without having to structure them into a rigid type. This is sort of a get out of jail free card for custom converters as they can dump into the user context type or whatever they want directly.
2023-04-03 01:36:45 -07:00
if (!PType.has_output) continue :paramloop;
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
while (flag_skip > 0) {
flag_skip -= 1;
continue :paramloop;
}
if (PType.is_flag) {
var peek = idx + 1;
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
var bias_seen: [ncmeta.enumLength(FlagBias)]bool = [_]bool{false} ** ncmeta.enumLength(FlagBias);
all: update for changed zig builtins enumToInt changed to intFromEnum, and the casting builtins figured out how to automagically infer the cast type. This results in some minor simplification, which is nice.
2023-07-19 00:31:19 -07:00
bias_seen[@intFromEnum(param.flag_bias)] = true;
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
while (peek < spec.len) : (peek += 1) {
const peek_param = spec[peek];
if (@TypeOf(peek_param).is_flag and std.mem.eql(u8, param.name, peek_param.name)) {
all: update for changed zig builtins enumToInt changed to intFromEnum, and the casting builtins figured out how to automagically infer the cast type. This results in some minor simplification, which is nice.
2023-07-19 00:31:19 -07:00
if (bias_seen[@intFromEnum(peek_param.flag_bias)] == true) {
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
@compileError("redundant flag!!!! " ++ param.name);
} else {
all: update for changed zig builtins enumToInt changed to intFromEnum, and the casting builtins figured out how to automagically infer the cast type. This results in some minor simplification, which is nice.
2023-07-19 00:31:19 -07:00
bias_seen[@intFromEnum(peek_param.flag_bias)] = true;
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
}
flag_skip += 1;
} else {
break;
}
}
}
// the default field is already the optional type. Stripping
// the optional wrapper is an interesting idea for required
// fields. I do not foresee this greatly increasing complexity here.
const FieldType = if (param.required or param.default != null)
PType.G.ConvertedType()
else
?PType.G.ConvertedType();
const default = if (param.default) |def| &@as(FieldType, def) else @as(?*const anyopaque, null);
fields = fields ++ &[_]StructField{.{
command: coerce field names to null-terminated strings ziglang/zig@a02bd81760166d679ccee0e190bf62115272ffbe changed builtin.StructField to necessitate this, but this should also be backwards compatible since these should decay to plain slices just fine.
2024-01-15 22:42:26 -08:00
.name = param.name ++ "",
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
.type = FieldType,
command: add missing ptrCast While a lot of values will implicitly coerce to this field value, slices annoyingly do not and thus the explicit cast is required.
2023-08-04 00:15:29 -07:00
.default_value = @ptrCast(default),
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
.is_comptime = false,
.alignment = @alignOf(FieldType),
}};
}
_ = @Type(.{ .Struct = .{
.layout = .Auto,
.fields = tag_fields,
.decls = &.{},
.is_tuple = false,
} });
_ = @Type(.{ .Struct = .{
.layout = .Auto,
.fields = env_var_fields,
.decls = &.{},
.is_tuple = false,
} });
return @Type(.{ .Struct = .{
.layout = .Auto,
.fields = fields,
.decls = &.{},
.is_tuple = false,
} });
}
}
pub fn Intermediate(comptime self: @This()) type {
comptime {
const spec = self.generate();
var fields: []const StructField = &[0]StructField{};
var flag_skip = 0;
paramloop: for (spec, 0..) |param, idx| {
while (flag_skip > 0) {
flag_skip -= 1;
continue :paramloop;
}
const PType = @TypeOf(param);
if (PType.is_flag) {
var peek = idx + 1;
style: use conventional camelCase naming for functions I think I still prefer snake_case stylistically, but this style fits in a lot better with other zig code and is the officially endorsed style, so it makes sense to use it. Since I don't have good test coverage, some conversions may have been missed, but the demo still builds, which is a decent amount of coverage. This was pretty easy to do with a find and replace, so it should be reasonably thorough.
2023-08-05 13:41:21 -07:00
var bias_seen: [ncmeta.enumLength(FlagBias)]bool = [_]bool{false} ** ncmeta.enumLength(FlagBias);
all: update for changed zig builtins enumToInt changed to intFromEnum, and the casting builtins figured out how to automagically infer the cast type. This results in some minor simplification, which is nice.
2023-07-19 00:31:19 -07:00
bias_seen[@intFromEnum(param.flag_bias)] = true;
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
while (peek < spec.len) : (peek += 1) {
const peek_param = spec[peek];
if (@TypeOf(peek_param).is_flag and std.mem.eql(u8, param.name, peek_param.name)) {
all: update for changed zig builtins enumToInt changed to intFromEnum, and the casting builtins figured out how to automagically infer the cast type. This results in some minor simplification, which is nice.
2023-07-19 00:31:19 -07:00
if (bias_seen[@intFromEnum(peek_param.flag_bias)] == true) {
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
@compileError("redundant flag!!!! " ++ param.name);
} else {
all: update for changed zig builtins enumToInt changed to intFromEnum, and the casting builtins figured out how to automagically infer the cast type. This results in some minor simplification, which is nice.
2023-07-19 00:31:19 -07:00
bias_seen[@intFromEnum(peek_param.flag_bias)] = true;
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
}
flag_skip += 1;
} else {
break;
}
}
}
const FieldType = if (PType.value_count == .count)
PType.G.IntermediateType()
else
?PType.G.IntermediateType();
fields = &(@as([fields.len]StructField, fields[0..fields.len].*) ++ [1]StructField{.{
command: coerce field names to null-terminated strings ziglang/zig@a02bd81760166d679ccee0e190bf62115272ffbe changed builtin.StructField to necessitate this, but this should also be backwards compatible since these should decay to plain slices just fine.
2024-01-15 22:42:26 -08:00
.name = param.name ++ "",
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
.type = FieldType,
all: update for changed zig builtins enumToInt changed to intFromEnum, and the casting builtins figured out how to automagically infer the cast type. This results in some minor simplification, which is nice.
2023-07-19 00:31:19 -07:00
.default_value = @ptrCast(&@as(
FieldType,
if (PType.value_count == .count) 0 else null,
)),
restructure the checklist of things to do is continuing to dwindle. hooray. last big feature push is help text generation. Then improving error reporting. Then writing some tests. Then writing documentation. Ay carumba.
2023-03-30 17:00:49 -07:00
.is_comptime = false,
.alignment = @alignOf(?[]const u8),
}});
}
return @Type(.{ .Struct = .{
.layout = .Auto,
.fields = fields,
.decls = &.{},
.is_tuple = false,
} });
}
}
};
}
Reference in New Issue Copy Permalink