From f4e53cd6149ed4dcbfd8b81a6427b1b652d0a472 Mon Sep 17 00:00:00 2001 From: Jimmi HC Date: Thu, 31 May 2018 16:00:44 +0200 Subject: Started work on the proper structure for the lib --- src/extended.zig | 264 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) create mode 100644 src/extended.zig (limited to 'src/extended.zig') diff --git a/src/extended.zig b/src/extended.zig new file mode 100644 index 0000000..9427b83 --- /dev/null +++ b/src/extended.zig @@ -0,0 +1,264 @@ +pub const core = @import("core.zig"); + +const builtin = @import("builtin"); +const std = @import("std"); + +const mem = std.mem; +const fmt = std.fmt; +const debug = std.debug; +const io = std.io; + +const assert = debug.assert; + +const Opaque = @OpaqueType(); + +pub const Param = struct { + field: []const u8, + short: ?u8, + long: ?[]const u8, + takes_value: ?Parser, + required: bool, + position: ?usize, + + pub fn short(s: u8) Param { + return Param{ + .field = []u8{s}, + .short = s, + .long = null, + .takes_value = null, + .required = false, + .position = null, + }; + } + + pub fn long(l: []const u8) Param { + return Param{ + .field = l, + .short = null, + .long = l, + .takes_value = null, + .required = false, + .position = null, + }; + } + + pub fn value(f: []const u8) Param { + return Param{ + .field = f, + .short = null, + .long = null, + .takes_value = null, + .required = false, + .position = null, + }; + } + + /// Initialize a ::Param. + /// If ::name.len == 0, then it's a value parameter: "value". + /// If ::name.len == 1, then it's a short parameter: "-s". + /// If ::name.len > 1, then it's a long parameter: "--long". + pub fn smart(name: []const u8) Param { + return Param{ + .field = name, + .short = if (name.len == 1) name[0] else null, + .long = if (name.len > 1) name else null, + .takes_value = null, + .required = false, + .position = null, + }; + } + + pub fn with(param: &const Param, comptime field_name: []const u8, v: var) Param { + var res = param.*; + @field(res, field_name) = v; + return res; + } +}; + +pub const Command = struct { + field: []const u8, + name: []const u8, + params: []const Param, + sub_commands: []const Command, + + Result: type, + defaults: &const Opaque, + parent: ?&const Command, + + pub fn init(name: []const u8, comptime Result: type, defaults: &const Result, params: []const Param, sub_commands: []const Command) Command { + return Command{ + .field = name, + .name = name, + .params = params, + .sub_commands = sub_commands, + .Result = Result, + .defaults = @ptrCast(&const Opaque, defaults), + .parent = null, + }; + } + + pub fn with(command: &const Command, comptime field_name: []const u8, v: var) Param { + var res = command.*; + @field(res, field_name) = v; + return res; + } + + pub fn parse(comptime command: &const Command, allocator: &mem.Allocator, arg_iter: &core.ArgIterator) !command.Result { + const Parent = struct {}; + var parent = Parent{}; + return command.parseHelper(&parent, allocator, arg_iter); + } + + fn parseHelper(comptime command: &const Command, parent: var, allocator: &mem.Allocator, arg_iter: &core.ArgIterator) !command.Result { + const Result = struct { + parent: @typeOf(parent), + result: command.Result, + }; + + var result = Result{ + .parent = parent, + .result = @ptrCast(&const command.Result, command.defaults).*, + }; + + // In order for us to wrap the core api, we have to translate clap.Param into core.Param. + const core_params = comptime blk: { + var res: [command.params.len + command.sub_commands.len]core.Param(usize) = undefined; + + for (command.params) |p, i| { + const id = i; + res[id] = core.Param(usize) { + .id = id, + .takes_value = p.takes_value != null, + .names = core.Names{ + .bare = null, + .short = p.short, + .long = p.long, + }, + }; + } + + for (command.sub_commands) |c, i| { + const id = i + command.params.len; + res[id] = core.Param(usize) { + .id = id, + .takes_value = false, + .names = core.Names.bare(c.name), + }; + } + + break :blk res; + }; + + var handled = comptime blk: { + var res: [command.params.len]bool = undefined; + for (command.params) |p, i| { + res[i] = !p.required; + } + + break :blk res; + }; + + var pos: usize = 0; + var iter = core.Clap(usize).init(core_params, arg_iter, allocator); + defer iter.deinit(); + + arg_loop: + while (try iter.next()) |arg| : (pos += 1) { + inline for(command.params) |param, i| { + comptime const field = "result." ++ param.field; + + if (arg.id == i and (param.position ?? pos) == pos) { + if (param.takes_value) |parser| { + try parser.parse(getFieldPtr(&result, field), ??arg.value); + } else { + getFieldPtr(&result, field).* = true; + } + handled[i] = true; + continue :arg_loop; + } + } + + inline for(command.sub_commands) |c, i| { + comptime const field = "result." ++ c.field; + comptime var sub_command = c; + sub_command.parent = command; + + if (arg.id == i + command.params.len) { + getFieldPtr(&result, field).* = try sub_command.parseHelper(&result, allocator, arg_iter); + continue :arg_loop; + } + } + + return error.InvalidArgument; + } + + return result.result; + } + + fn GetFieldPtrReturn(comptime Struct: type, comptime field: []const u8) type { + var inst: Struct = undefined; + const dot_index = comptime mem.indexOfScalar(u8, field, '.') ?? { + return @typeOf(&@field(inst, field)); + }; + + return GetFieldPtrReturn(@typeOf(@field(inst, field[0..dot_index])), field[dot_index + 1..]); + } + + fn getFieldPtr(curr: var, comptime field: []const u8) GetFieldPtrReturn(@typeOf(curr).Child, field) { + const dot_index = comptime mem.indexOfScalar(u8, field, '.') ?? { + return &@field(curr, field); + }; + + return getFieldPtr(&@field(curr, field[0..dot_index]), field[dot_index + 1..]); + } +}; + +pub const Parser = struct { + const UnsafeFunction = &const void; + + FieldType: type, + Errors: type, + func: UnsafeFunction, + + pub fn init(comptime FieldType: type, comptime Errors: type, func: parseFunc(FieldType, Errors)) Parser { + return Parser { + .FieldType = FieldType, + .Errors = Errors, + .func = @ptrCast(UnsafeFunction, func), + }; + } + + fn parse(comptime parser: Parser, field_ptr: TakePtr(parser.FieldType), arg: []const u8) parser.Errors!void { + return @ptrCast(parseFunc(parser.FieldType, parser.Errors), parser.func)(field_ptr, arg); + } + + // TODO: This is a workaround, since we don't have pointer reform yet. + fn TakePtr(comptime T: type) type { return &T; } + + fn parseFunc(comptime FieldType: type, comptime Errors: type) type { + return fn(&FieldType, []const u8) Errors!void; + } + + pub fn int(comptime Int: type, comptime radix: u8) Parser { + const func = struct { + fn i(field_ptr: &Int, arg: []const u8) !void { + field_ptr.* = try fmt.parseInt(Int, arg, radix); + } + }.i; + return Parser.init( + Int, + @typeOf(func).ReturnType.ErrorSet, + func + ); + } + + const string = Parser.init( + []const u8, + error{}, + struct { + fn s(field_ptr: &[]const u8, arg: []const u8) (error{}!void) { + field_ptr.* = arg; + } + }.s + ); +}; -- cgit v1.2.3