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/core.zig | 372 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/extended.zig | 264 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 636 insertions(+) create mode 100644 src/core.zig create mode 100644 src/extended.zig (limited to 'src') diff --git a/src/core.zig b/src/core.zig new file mode 100644 index 0000000..a3fb44c --- /dev/null +++ b/src/core.zig @@ -0,0 +1,372 @@ +const std = @import("std"); +const builtin = @import("builtin"); + +const os = std.os; +const heap = std.heap; +const mem = std.mem; +const debug = std.debug; + +/// The names a ::Param can have. +pub const Names = struct { + /// No prefix + bare: ?[]const u8, + + /// '-' prefix + short: ?u8, + + /// '--' prefix + long: ?[]const u8, + + /// Initializes no names + pub fn none() Names { + return Names{ + .bare = null, + .short = null, + .long = null, + }; + } + + /// Initializes a bare name + pub fn bare(b: []const u8) Names { + return Names{ + .bare = b, + .short = null, + .long = null, + }; + } + + /// Initializes a short name + pub fn short(s: u8) Names { + return Names{ + .bare = null, + .short = s, + .long = null, + }; + } + + /// Initializes a long name + pub fn long(l: []const u8) Names { + return Names{ + .bare = null, + .short = null, + .long = l, + }; + } + + /// Initializes a name with a prefix. + /// ::short is set to ::name[0], and ::long is set to ::name. + /// This function asserts that ::name.len != 0 + pub fn prefix(name: []const u8) Names { + debug.assert(name.len != 0); + + return Names{ + .bare = null, + .short = name[0], + .long = name, + }; + } +}; + +/// Represents a parameter for the command line. +/// Parameters come in three kinds: +/// * Short ("-a"): Should be used for the most commonly used parameters in your program. +/// * They can take a value three different ways. +/// * "-a value" +/// * "-a=value" +/// * "-avalue" +/// * They chain if they don't take values: "-abc". +/// * The last given parameter can take a value in the same way that a single parameter can: +/// * "-abc value" +/// * "-abc=value" +/// * "-abcvalue" +/// * Long ("--long-param"): Should be used for less common parameters, or when no single character +/// can describe the paramter. +/// * They can take a value two different ways. +/// * "--long-param value" +/// * "--long-param=value" +/// * Bare ("bare"): Should be used as for sub-commands and other keywords. +/// * They can take a value two different ways. +/// * "command value" +/// * "command=value" +/// * Value ("value"): Should be used as the primary parameter of the program, like a filename or +/// an expression to parse. +/// * Value parameters must take a value. +pub fn Param(comptime Id: type) type { + return struct { + const Self = this; + + id: Id, + takes_value: bool, + names: Names, + + pub fn init(id: Id, takes_value: bool, names: &const Names) Self { + // Assert, that if the param have no name, then it has to take + // a value. + debug.assert( + names.bare != null or + names.long != null or + names.short != null or + takes_value + ); + + return Self{ + .id = id, + .takes_value = takes_value, + .names = names.*, + }; + } + }; +} + +/// The result returned from ::Clap.next +pub fn Arg(comptime Id: type) type { + return struct { + const Self = this; + + id: Id, + value: ?[]const u8, + + pub fn init(id: Id, value: ?[]const u8) Self { + return Self { + .id = id, + .value = value, + }; + } + }; +} + +/// A interface for iterating over command line arguments +pub const ArgIterator = struct { + const Error = error{OutOfMemory}; + + nextFn: fn(iter: &ArgIterator, allocator: &mem.Allocator) Error!?[]const u8, + + pub fn next(iter: &ArgIterator, allocator: &mem.Allocator) Error!?[]const u8 { + return iter.nextFn(iter, allocator); + } +}; + +/// An ::ArgIterator, which iterates over a slice of arguments. +/// This implementation does not allocate. +pub const ArgSliceIterator = struct { + args: []const []const u8, + index: usize, + iter: ArgIterator, + + pub fn init(args: []const []const u8) ArgSliceIterator { + return ArgSliceIterator { + .args = args, + .index = 0, + .iter = ArgIterator { + .nextFn = nextFn, + }, + }; + } + + fn nextFn(iter: &ArgIterator, allocator: &mem.Allocator) ArgIterator.Error!?[]const u8 { + const self = @fieldParentPtr(ArgSliceIterator, "iter", iter); + if (self.args.len <= self.index) + return null; + + defer self.index += 1; + return self.args[self.index]; + } +}; + +/// An ::ArgIterator, which wraps the ArgIterator in ::std. +/// On windows, this iterator allocates. +pub const OsArgIterator = struct { + args: os.ArgIterator, + iter: ArgIterator, + + pub fn init() OsArgIterator { + return OsArgIterator { + .args = os.args(), + .iter = ArgIterator { + .nextFn = nextFn, + }, + }; + } + + fn nextFn(iter: &ArgIterator, allocator: &mem.Allocator) ArgIterator.Error!?[]const u8 { + const self = @fieldParentPtr(OsArgIterator, "iter", iter); + if (builtin.os == builtin.Os.windows) { + return try self.args.next(allocator) ?? return null; + } else { + return self.args.nextPosix(); + } + } +}; + +/// A command line argument parser which, given an ::ArgIterator, will parse arguments according +/// to the ::params. ::Clap parses in an iterating manner, so you have to use a loop together with +/// ::Clap.next to parse all the arguments of your program. +pub fn Clap(comptime Id: type) type { + return struct { + const Self = this; + + const State = union(enum) { + Normal, + Chaining: Chaining, + + const Chaining = struct { + arg: []const u8, + index: usize, + }; + }; + + arena: heap.ArenaAllocator, + params: []const Param(Id), + inner: &ArgIterator, + state: State, + + pub fn init(params: []const Param(Id), inner: &ArgIterator, allocator: &mem.Allocator) Self { + var res = Self { + .arena = heap.ArenaAllocator.init(allocator), + .params = params, + .inner = inner, + .state = State.Normal, + }; + + return res; + } + + pub fn deinit(iter: &Self) void { + iter.arena.deinit(); + } + + /// Get the next ::Arg that matches a ::Param. + pub fn next(iter: &Self) !?Arg(Id) { + const ArgInfo = struct { + const Kind = enum { Long, Short, Bare }; + + arg: []const u8, + kind: Kind, + }; + + switch (iter.state) { + State.Normal => { + const full_arg = (try iter.innerNext()) ?? return null; + const arg_info = blk: { + var arg = full_arg; + var kind = ArgInfo.Kind.Bare; + + if (mem.startsWith(u8, arg, "--")) { + arg = arg[2..]; + kind = ArgInfo.Kind.Long; + } else if (mem.startsWith(u8, arg, "-")) { + arg = arg[1..]; + kind = ArgInfo.Kind.Short; + } + + if (arg.len == 0) + return error.ArgWithNoName; + + break :blk ArgInfo { .arg = arg, .kind = kind }; + }; + + const arg = arg_info.arg; + const kind = arg_info.kind; + const eql_index = mem.indexOfScalar(u8, arg, '='); + + switch (kind) { + ArgInfo.Kind.Bare, + ArgInfo.Kind.Long => { + for (iter.params) |*param| { + const match = switch (kind) { + ArgInfo.Kind.Bare => param.names.bare ?? continue, + ArgInfo.Kind.Long => param.names.long ?? continue, + else => unreachable, + }; + const name = if (eql_index) |i| arg[0..i] else arg; + const maybe_value = if (eql_index) |i| arg[i + 1..] else null; + + if (!mem.eql(u8, name, match)) + continue; + if (!param.takes_value) { + if (maybe_value != null) + return error.DoesntTakeValue; + + return Arg(Id).init(param.id, null); + } + + const value = blk: { + if (maybe_value) |v| + break :blk v; + + break :blk (try iter.innerNext()) ?? return error.MissingValue; + }; + + return Arg(Id).init(param.id, value); + } + }, + ArgInfo.Kind.Short => { + return try iter.chainging(State.Chaining { + .arg = full_arg, + .index = (full_arg.len - arg.len), + }); + }, + } + + // We do a final pass to look for value parameters matches + if (kind == ArgInfo.Kind.Bare) { + for (iter.params) |*param| { + if (param.names.bare) |_| continue; + if (param.names.short) |_| continue; + if (param.names.long) |_| continue; + + return Arg(Id).init(param.id, arg); + } + } + + return error.InvalidArgument; + }, + @TagType(State).Chaining => |state| return try iter.chainging(state), + } + } + + fn chainging(iter: &Self, state: &const State.Chaining) !?Arg(Id) { + const arg = state.arg; + const index = state.index; + const next_index = index + 1; + + for (iter.params) |param| { + const short = param.names.short ?? continue; + if (short != arg[index]) + continue; + + // Before we return, we have to set the new state of the iterator + defer { + if (arg.len <= next_index or param.takes_value) { + iter.state = State.Normal; + } else { + iter.state = State { .Chaining = State.Chaining { + .arg = arg, + .index = next_index, + }}; + } + } + + if (!param.takes_value) + return Arg(Id).init(param.id, null); + + if (arg.len <= next_index) { + const value = (try iter.innerNext()) ?? return error.MissingValue; + return Arg(Id).init(param.id, value); + } + + if (arg[next_index] == '=') { + return Arg(Id).init(param.id, arg[next_index + 1..]); + } + + return Arg(Id).init(param.id, arg[next_index..]); + } + + return error.InvalidArgument; + } + + fn innerNext(iter: &Self) !?[]const u8 { + return try iter.inner.next(&iter.arena.allocator); + } + }; +} 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