From 61f141ca6a5b6f3d7ab0eade8d6f8fbe0ac6a28e Mon Sep 17 00:00:00 2001 From: Jimmi HC Date: Fri, 1 Jun 2018 08:37:21 +0200 Subject: [PATCH] Core args now have a pointer to the param that the arg belongs to --- examples/core.zig | 238 +++++++++++++++++++++++++++++++++------------- src/core.zig | 22 ++--- 2 files changed, 182 insertions(+), 78 deletions(-) diff --git a/examples/core.zig b/examples/core.zig index f393e0f..8bcc928 100644 --- a/examples/core.zig +++ b/examples/core.zig @@ -7,32 +7,21 @@ const mem = std.mem; const Names = clap.Names; const Param = clap.Param; -const Command = enum { - Help, - Build, - BuildExe, - BuildLib, - BuildObj, - Fmt, - Run, - Targets, - Test, - Version, - Zen, -}; +// TODO: More specific error in this func type. +const Command = fn(&mem.Allocator, &clap.ArgIterator) error!void; const params = []Param(Command){ - Param(Command).init(Command.Help, false, Names.prefix("help")), - Param(Command).init(Command.Build, false, Names.bare("build")), - Param(Command).init(Command.BuildExe, false, Names.bare("build-exe")), - Param(Command).init(Command.BuildLib, false, Names.bare("build-lib")), - Param(Command).init(Command.BuildObj, false, Names.bare("build-obj")), - Param(Command).init(Command.Fmt, false, Names.bare("fmt")), - Param(Command).init(Command.Run, false, Names.bare("run")), - Param(Command).init(Command.Targets, false, Names.bare("targets")), - Param(Command).init(Command.Test, false, Names.bare("test")), - Param(Command).init(Command.Version, false, Names.bare("version")), - Param(Command).init(Command.Zen, false, Names.bare("zen")), + Param(Command).init(help, false, Names.prefix("help")), + Param(Command).init(cmdBuild, false, Names.bare("build")), + Param(Command).init(cmdBuildExe, false, Names.bare("build-exe")), + Param(Command).init(cmdBuildLib, false, Names.bare("build-lib")), + Param(Command).init(cmdBuildObj, false, Names.bare("build-obj")), + Param(Command).init(cmdFmt, false, Names.bare("fmt")), + Param(Command).init(cmdRun, false, Names.bare("run")), + Param(Command).init(cmdTargets, false, Names.bare("targets")), + Param(Command).init(cmdTest, false, Names.bare("test")), + Param(Command).init(cmdVersion, false, Names.bare("version")), + Param(Command).init(cmdZen, false, Names.bare("zen")), }; const usage = @@ -79,24 +68,16 @@ pub fn main() !void { return error.NoCommandFound; }; - switch (arg.id) { - Command.Help => return, // debug.warn(usage), TODO: error: evaluation exceeded 1000 backwards branches - Command.Build => try cmdBuild(allocator, parser.iter), - Command.BuildExe, - Command.BuildLib, - Command.BuildObj, - Command.Fmt, - Command.Run, - Command.Targets, - Command.Test, - Command.Version, - Command.Zen => unreachable, - } + try arg.param.id(allocator, parser.iter); +} + +pub fn help(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { + // debug.warn(usage); TODO: error: evaluation exceeded 1000 backwards branches } // cmd:build /////////////////////////////////////////////////////////////////////////////////////// -const BuildArg = enum { +const Build = enum { Help, Init, BuildFile, @@ -111,20 +92,20 @@ const BuildArg = enum { VerboseCImport, }; -const build_params = []Param(BuildArg){ - Param(BuildArg).init(BuildArg.Help, false, Names.prefix("help")), - Param(BuildArg).init(BuildArg.Init, false, Names.long("init")), - Param(BuildArg).init(BuildArg.BuildFile, true, Names.long("build-file")), - Param(BuildArg).init(BuildArg.CacheDir, true, Names.long("cache-dir")), - Param(BuildArg).init(BuildArg.Verbose, false, Names.prefix("verbose")), - Param(BuildArg).init(BuildArg.Prefix, true, Names.long("prefix")), +const build_params = []Param(Build){ + Param(Build).init(Build.Help, false, Names.prefix("help")), + Param(Build).init(Build.Init, false, Names.long("init")), + Param(Build).init(Build.BuildFile, true, Names.long("build-file")), + Param(Build).init(Build.CacheDir, true, Names.long("cache-dir")), + Param(Build).init(Build.Verbose, false, Names.prefix("verbose")), + Param(Build).init(Build.Prefix, true, Names.long("prefix")), - Param(BuildArg).init(BuildArg.VerboseTokenize, false, Names.prefix("verbose-tokenize")), - Param(BuildArg).init(BuildArg.VerboseAst, false, Names.prefix("verbose-ast")), - Param(BuildArg).init(BuildArg.VerboseLink, false, Names.prefix("verbose-link")), - Param(BuildArg).init(BuildArg.VerboseIr, false, Names.prefix("verbose-ir")), - Param(BuildArg).init(BuildArg.VerboseLlvmIr, false, Names.prefix("verbose-llvm-ir")), - Param(BuildArg).init(BuildArg.VerboseCImport, false, Names.prefix("verbose-cimport")), + Param(Build).init(Build.VerboseTokenize, false, Names.prefix("verbose-tokenize")), + Param(Build).init(Build.VerboseAst, false, Names.prefix("verbose-ast")), + Param(Build).init(Build.VerboseLink, false, Names.prefix("verbose-link")), + Param(Build).init(Build.VerboseIr, false, Names.prefix("verbose-ir")), + Param(Build).init(Build.VerboseLlvmIr, false, Names.prefix("verbose-llvm-ir")), + Param(Build).init(Build.VerboseCImport, false, Names.prefix("verbose-cimport")), }; const build_usage = @@ -176,26 +157,26 @@ fn cmdBuild(allocator: &mem.Allocator, args: &clap.ArgIterator) !void { var verbose_llvm_ir = false; var verbose_cimport = false; - var parser = clap.Clap(BuildArg).init(build_params, args, allocator); + var parser = clap.Clap(Build).init(build_params, args, allocator); defer parser.deinit(); while (parser.next() catch |err| { debug.warn("{}.\n", @errorName(err)); // debug.warn(build_usage); TODO: error: evaluation exceeded 1000 backwards branches return err; - }) |arg| switch (arg.id) { - BuildArg.Help => return, // debug.warn(build_usage) TODO: error: evaluation exceeded 1000 backwards branches, - BuildArg.Init => init = true, - BuildArg.BuildFile => build_file = ??arg.value, - BuildArg.CacheDir => cache_dir = ??arg.value, - BuildArg.Verbose => verbose = true, - BuildArg.Prefix => prefix = ??arg.value, - BuildArg.VerboseTokenize => verbose_tokenize = true, - BuildArg.VerboseAst => verbose_ast = true, - BuildArg.VerboseLink => verbose_link = true, - BuildArg.VerboseIr => verbose_ir = true, - BuildArg.VerboseLlvmIr => verbose_llvm_ir = true, - BuildArg.VerboseCImport => verbose_cimport = true, + }) |arg| switch (arg.param.id) { + Build.Help => return, // debug.warn(build_usage) TODO: error: evaluation exceeded 1000 backwards branches, + Build.Init => init = true, + Build.BuildFile => build_file = ??arg.value, + Build.CacheDir => cache_dir = ??arg.value, + Build.Verbose => verbose = true, + Build.Prefix => prefix = ??arg.value, + Build.VerboseTokenize => verbose_tokenize = true, + Build.VerboseAst => verbose_ast = true, + Build.VerboseLink => verbose_link = true, + Build.VerboseIr => verbose_ir = true, + Build.VerboseLlvmIr => verbose_llvm_ir = true, + Build.VerboseCImport => verbose_cimport = true, }; debug.warn("command: build\n"); @@ -270,8 +251,8 @@ const BuildGeneric = enum { VerPatch, }; -const build_generic_params = []Param(BuildArg){ - Param(BuildArg).init(BuildArg.Help, false, Names.prefix("help")), +const build_generic_params = []Param(BuildGeneric){ + Param(BuildGeneric).init(BuildGeneric.Help, false, Names.prefix("help")), }; const build_generic_usage = @@ -338,3 +319,126 @@ const build_generic_usage = \\ \\ ; + + +fn cmdBuildExe(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:build-lib /////////////////////////////////////////////////////////////////////////////////// + +fn cmdBuildLib(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:build-obj /////////////////////////////////////////////////////////////////////////////////// + +fn cmdBuildObj(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:fmt ///////////////////////////////////////////////////////////////////////////////////////// + +const usage_fmt = + \\usage: zig fmt [file]... + \\ + \\ Formats the input files and modifies them in-place. + \\ + \\Options: + \\ --help Print this help and exit + \\ --color [auto|off|on] Enable or disable colored error messages + \\ + \\ +; + +fn cmdFmt(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:targets ///////////////////////////////////////////////////////////////////////////////////// + +fn cmdTargets(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:version ///////////////////////////////////////////////////////////////////////////////////// + +fn cmdVersion(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:test //////////////////////////////////////////////////////////////////////////////////////// + +const usage_test = + \\usage: zig test [file]... + \\ + \\Options: + \\ --help Print this help and exit + \\ + \\ +; + +fn cmdTest(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:run ///////////////////////////////////////////////////////////////////////////////////////// + +// Run should be simple and not expose the full set of arguments provided by build-exe. If specific +// build requirements are need, the user should `build-exe` then `run` manually. +const usage_run = + \\usage: zig run [file] -- + \\ + \\Options: + \\ --help Print this help and exit + \\ + \\ +; + +fn cmdRun(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:translate-c ///////////////////////////////////////////////////////////////////////////////// + +const usage_translate_c = + \\usage: zig translate-c [file] + \\ + \\Options: + \\ --help Print this help and exit + \\ --enable-timing-info Print timing diagnostics + \\ --output [path] Output file to write generated zig file (default: stdout) + \\ + \\ +; + +fn cmdTranslateC(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:zen ///////////////////////////////////////////////////////////////////////////////////////// + +const info_zen = + \\ + \\ * Communicate intent precisely. + \\ * Edge cases matter. + \\ * Favor reading code over writing code. + \\ * Only one obvious way to do things. + \\ * Runtime crashes are better than bugs. + \\ * Compile errors are better than runtime crashes. + \\ * Incremental improvements. + \\ * Avoid local maximums. + \\ * Reduce the amount one must remember. + \\ * Minimize energy spent on coding style. + \\ * Together we serve end users. + \\ + \\ +; + +fn cmdZen(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} + +// cmd:internal //////////////////////////////////////////////////////////////////////////////////// + +const usage_internal = + \\usage: zig internal [subcommand] + \\ + \\Sub-Commands: + \\ build-info Print static compiler build-info + \\ + \\ +; + +fn cmdInternal(allocator: &mem.Allocator, args: &clap.ArgIterator) (error{}!void) { +} diff --git a/src/core.zig b/src/core.zig index 22b5df2..8570220 100644 --- a/src/core.zig +++ b/src/core.zig @@ -123,12 +123,12 @@ pub fn Arg(comptime Id: type) type { return struct { const Self = this; - id: Id, + param: &const Param(Id), value: ?[]const u8, - pub fn init(id: Id, value: ?[]const u8) Self { + pub fn init(param: &const Param(Id), value: ?[]const u8) Self { return Self { - .id = id, + .param = param, .value = value, }; } @@ -287,7 +287,7 @@ pub fn Clap(comptime Id: type) type { if (maybe_value != null) return error.DoesntTakeValue; - return Arg(Id).init(param.id, null); + return Arg(Id).init(param, null); } const value = blk: { @@ -297,7 +297,7 @@ pub fn Clap(comptime Id: type) type { break :blk (try clap.nextNoParse()) ?? return error.MissingValue; }; - return Arg(Id).init(param.id, value); + return Arg(Id).init(param, value); } }, ArgInfo.Kind.Short => { @@ -315,7 +315,7 @@ pub fn Clap(comptime Id: type) type { if (param.names.short) |_| continue; if (param.names.long) |_| continue; - return Arg(Id).init(param.id, arg); + return Arg(Id).init(param, arg); } } @@ -330,7 +330,7 @@ pub fn Clap(comptime Id: type) type { const index = state.index; const next_index = index + 1; - for (clap.params) |param| { + for (clap.params) |*param| { const short = param.names.short ?? continue; if (short != arg[index]) continue; @@ -348,18 +348,18 @@ pub fn Clap(comptime Id: type) type { } if (!param.takes_value) - return Arg(Id).init(param.id, null); + return Arg(Id).init(param, null); if (arg.len <= next_index) { const value = (try clap.nextNoParse()) ?? return error.MissingValue; - return Arg(Id).init(param.id, value); + return Arg(Id).init(param, value); } if (arg[next_index] == '=') { - return Arg(Id).init(param.id, arg[next_index + 1..]); + return Arg(Id).init(param, arg[next_index + 1..]); } - return Arg(Id).init(param.id, arg[next_index..]); + return Arg(Id).init(param, arg[next_index..]); } return error.InvalidArgument;