3 files changed, 365 insertions, 21 deletions

diff --git a/examples/core.zig b/examples/core.zig
index e69de29..f393e0f 100644
--- a/examples/core.zig
+++ b/examples/core.zig
@@ -0,0 +1,340 @@
+const std = @import("std");
+const clap = @import("clap").core;
+
+const debug = std.debug;
+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,
+};
+
+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")),
+};
+
+const usage =
+    \\usage: zig [command] [options]
+    \\
+    \\Commands:
+    \\
+    \\  build                        Build project from build.zig
+    \\  build-exe   [source]         Create executable from source or object files
+    \\  build-lib   [source]         Create library from source or object files
+    \\  build-obj   [source]         Create object from source or assembly
+    \\  fmt         [source]         Parse file and render in canonical zig format
+    \\  run         [source]         Create executable and run immediately
+    \\  targets                      List available compilation targets
+    \\  test        [source]         Create and run a test build
+    \\  translate-c [source]         Convert c code to zig code
+    \\  version                      Print version number and exit
+    \\  zen                          Print zen of zig and exit
+    \\
+    \\
+;
+
+pub fn main() !void {
+    var direct_allocator = std.heap.DirectAllocator.init();
+    defer direct_allocator.deinit();
+    var arena = std.heap.ArenaAllocator.init(&direct_allocator.allocator);
+    defer arena.deinit();
+
+    const allocator = &arena.allocator;
+
+    var args = clap.OsArgIterator.init();
+    var parser = clap.Clap(Command).init(params, &args.iter, allocator);
+    defer parser.deinit();
+
+    const exe = try parser.nextNoParse();
+    const maybe_arg = parser.next() catch |err| b: {
+        debug.warn("{}.\n", @errorName(err));
+        // debug.warn(usage); TODO: error: evaluation exceeded 1000 backwards branches
+        return err;
+    };
+    const arg = maybe_arg ?? {
+        debug.warn("No command found.\n");
+        // debug.warn(usage); TODO: error: evaluation exceeded 1000 backwards branches
+        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,
+    }
+}
+
+// cmd:build ///////////////////////////////////////////////////////////////////////////////////////
+
+const BuildArg = enum {
+    Help,
+    Init,
+    BuildFile,
+    CacheDir,
+    Verbose,
+    Prefix,
+    VerboseTokenize,
+    VerboseAst,
+    VerboseLink,
+    VerboseIr,
+    VerboseLlvmIr,
+    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")),
+
+    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")),
+};
+
+const build_usage =
+    \\usage: zig build <options>
+    \\
+    \\General Options:
+    \\   -h, --help                   Print this help and exit
+    \\       --init                   Generate a build.zig template
+    \\       --build-file [file]      Override path to build.zig
+    \\       --cache-dir [path]       Override path to cache directory
+    \\   -v, --verbose                Print commands before executing them
+    \\       --prefix [path]          Override default install prefix
+    \\
+    \\Project-Specific Options:
+    \\
+    \\   Project-specific options become available when the build file is found.
+    \\
+    \\Advanced Options:
+    \\       --verbose-tokenize       Enable compiler debug output for tokenization
+    \\       --verbose-ast            Enable compiler debug output for parsing into an AST
+    \\       --verbose-link           Enable compiler debug output for linking
+    \\       --verbose-ir             Enable compiler debug output for Zig IR
+    \\       --verbose-llvm-ir        Enable compiler debug output for LLVM IR
+    \\       --verbose-cimport        Enable compiler debug output for C imports
+    \\
+    \\
+;
+
+const missing_build_file =
+    \\No 'build.zig' file found.
+    \\
+    \\Initialize a 'build.zig' template file with `zig build --init`,
+    \\or build an executable directly with `zig build-exe $FILENAME.zig`.
+    \\
+    \\See: `zig build --help` or `zig help` for more options.
+    \\
+;
+
+fn cmdBuild(allocator: &mem.Allocator, args: &clap.ArgIterator) !void {
+    var init = false;
+    var build_file: []const u8 = "build.zig";
+    var cache_dir: []const u8 = "zig-cache";
+    var verbose = false;
+    var prefix: []const u8 = "";
+    var verbose_tokenize = false;
+    var verbose_ast = false;
+    var verbose_link = false;
+    var verbose_ir = false;
+    var verbose_llvm_ir = false;
+    var verbose_cimport = false;
+
+    var parser = clap.Clap(BuildArg).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,
+    };
+
+    debug.warn("command: build\n");
+    debug.warn("init             = {}\n", init);
+    debug.warn("build_file       = {}\n", build_file);
+    debug.warn("cache_dir        = {}\n", cache_dir);
+    debug.warn("verbose          = {}\n", verbose);
+    debug.warn("prefix           = {}\n", prefix);
+    debug.warn("verbose_tokenize = {}\n", verbose_tokenize);
+    debug.warn("verbose_ast      = {}\n", verbose_ast);
+    debug.warn("verbose_link     = {}\n", verbose_link);
+    debug.warn("verbose_ir       = {}\n", verbose_ir);
+    debug.warn("verbose_llvm_ir  = {}\n", verbose_llvm_ir);
+    debug.warn("verbose_cimport  = {}\n", verbose_cimport);
+}
+
+// cmd:build-exe ///////////////////////////////////////////////////////////////////////////////////
+
+const BuildGeneric = enum {
+    File,
+    Help,
+    Color,
+
+    Assembly,
+    CacheDir,
+    Emit,
+    EnableTimingInfo,
+    LibCDir,
+    Name,
+    Output,
+    OutputH,
+    PkgBegin,
+    PkgEnd,
+    ReleaseFast,
+    ReleaseSafe,
+    Static,
+    Strip,
+    TargetArch,
+    TargetEnviron,
+    TargetOs,
+    VerboseTokenize,
+    VerboseAst,
+    VerboseLink,
+    VerboseIr,
+    VerboseLlvmIr,
+    VerboseCImport,
+    DirAfter,
+    ISystem,
+    MLlvm,
+
+    ArPath,
+    DynamicLinker,
+    EachLibRPath,
+    LibcLibDir,
+    LibcStaticLibDir,
+    MsvcLibDir,
+    Kernel32LibDir,
+    Library,
+    ForbidLibrary,
+    LibraryPath,
+    LinkerScript,
+    Object,
+    RDynamic,
+    RPath,
+    MConsole,
+    MWindows,
+    Framework,
+    MiOsVersionMin,
+    MMacOsXVersonMin,
+    VerMajor,
+    VerMinor,
+    VerPatch,
+};
+
+const build_generic_params = []Param(BuildArg){
+    Param(BuildArg).init(BuildArg.Help, false, Names.prefix("help")),
+};
+
+const build_generic_usage =
+    \\usage: zig build-exe <options> [file]
+    \\       zig build-lib <options> [file]
+    \\       zig build-obj <options> [file]
+    \\
+    \\General Options:
+    \\  -h, --help                       Print this help and exit
+    \\  -c, --color [auto|off|on]        Enable or disable colored error messages
+    \\
+    \\Compile Options:
+    \\  --assembly [source]          Add assembly file to build
+    \\  --cache-dir [path]           Override the cache directory
+    \\  --emit [filetype]            Emit a specific file format as compilation output
+    \\  --enable-timing-info         Print timing diagnostics
+    \\  --libc-include-dir [path]    Directory where libc stdlib.h resides
+    \\  --name [name]                Override output name
+    \\  --output [file]              Override destination path
+    \\  --output-h [file]            Override generated header file path
+    \\  --pkg-begin [name] [path]    Make package available to import and push current pkg
+    \\  --pkg-end                    Pop current pkg
+    \\  --release-fast               Build with optimizations on and safety off
+    \\  --release-safe               Build with optimizations on and safety on
+    \\  --static                     Output will be statically linked
+    \\  --strip                      Exclude debug symbols
+    \\  --target-arch [name]         Specify target architecture
+    \\  --target-environ [name]      Specify target environment
+    \\  --target-os [name]           Specify target operating system
+    \\  --verbose-tokenize           Turn on compiler debug output for tokenization
+    \\  --verbose-ast-tree           Turn on compiler debug output for parsing into an AST (tree view)
+    \\  --verbose-ast-fmt            Turn on compiler debug output for parsing into an AST (render source)
+    \\  --verbose-link               Turn on compiler debug output for linking
+    \\  --verbose-ir                 Turn on compiler debug output for Zig IR
+    \\  --verbose-llvm-ir            Turn on compiler debug output for LLVM IR
+    \\  --verbose-cimport            Turn on compiler debug output for C imports
+    \\  --dirafter [dir]             Same as --isystem but do it last
+    \\  --isystem [dir]              Add additional search path for other .h files
+    \\  --mllvm [arg]                Additional arguments to forward to LLVM's option processing
+    \\
+    \\Link Options:
+    \\  --ar-path [path]             Set the path to ar
+    \\  --dynamic-linker [path]      Set the path to ld.so
+    \\  --each-lib-rpath             Add rpath for each used dynamic library
+    \\  --libc-lib-dir [path]        Directory where libc crt1.o resides
+    \\  --libc-static-lib-dir [path] Directory where libc crtbegin.o resides
+    \\  --msvc-lib-dir [path]        (windows) directory where vcruntime.lib resides
+    \\  --kernel32-lib-dir [path]    (windows) directory where kernel32.lib resides
+    \\  --library [lib]              Link against lib
+    \\  --forbid-library [lib]       Make it an error to link against lib
+    \\  --library-path [dir]         Add a directory to the library search path
+    \\  --linker-script [path]       Use a custom linker script
+    \\  --object [obj]               Add object file to build
+    \\  --rdynamic                   Add all symbols to the dynamic symbol table
+    \\  --rpath [path]               Add directory to the runtime library search path
+    \\  --mconsole                   (windows) --subsystem console to the linker
+    \\  --mwindows                   (windows) --subsystem windows to the linker
+    \\  --framework [name]           (darwin) link against framework
+    \\  --mios-version-min [ver]     (darwin) set iOS deployment target
+    \\  --mmacosx-version-min [ver]  (darwin) set Mac OS X deployment target
+    \\  --ver-major [ver]            Dynamic library semver major version
+    \\  --ver-minor [ver]            Dynamic library semver minor version
+    \\  --ver-patch [ver]            Dynamic library semver patch version
+    \\
+    \\
+;
diff --git a/examples/extended.zig b/examples/extended.zig
index e69de29..c21d254 100644
--- a/examples/extended.zig
+++ b/examples/extended.zig
@@ -0,0 +1,2 @@
+
+pub fn main() void {}
diff --git a/src/core.zig b/src/core.zig
index a3fb44c..22b5df2 100644
--- a/src/core.zig
+++ b/src/core.zig
@@ -217,26 +217,26 @@ pub fn Clap(comptime Id: type) type {
 
         arena: heap.ArenaAllocator,
         params: []const Param(Id),
-        inner: &ArgIterator,
+        iter: &ArgIterator,
         state: State,
 
-        pub fn init(params: []const Param(Id), inner: &ArgIterator, allocator: &mem.Allocator) Self {
+        pub fn init(params: []const Param(Id), iter: &ArgIterator, allocator: &mem.Allocator) Self {
             var res = Self {
                 .arena = heap.ArenaAllocator.init(allocator),
                 .params = params,
-                .inner = inner,
+                .iter = iter,
                 .state = State.Normal,
             };
 
             return res;
         }
 
-        pub fn deinit(iter: &Self) void {
-            iter.arena.deinit();
+        pub fn deinit(clap: &Self) void {
+            clap.arena.deinit();
         }
 
         /// Get the next ::Arg that matches a ::Param.
-        pub fn next(iter: &Self) !?Arg(Id) {
+        pub fn next(clap: &Self) !?Arg(Id) {
             const ArgInfo = struct {
                 const Kind = enum { Long, Short, Bare };
 
@@ -244,9 +244,9 @@ pub fn Clap(comptime Id: type) type {
                 kind: Kind,
             };
 
-            switch (iter.state) {
+            switch (clap.state) {
                 State.Normal => {
-                    const full_arg = (try iter.innerNext()) ?? return null;
+                    const full_arg = (try clap.nextNoParse()) ?? return null;
                     const arg_info = blk: {
                         var arg = full_arg;
                         var kind = ArgInfo.Kind.Bare;
@@ -272,7 +272,7 @@ pub fn Clap(comptime Id: type) type {
                     switch (kind) {
                         ArgInfo.Kind.Bare,
                         ArgInfo.Kind.Long => {
-                            for (iter.params) |*param| {
+                            for (clap.params) |*param| {
                                 const match = switch (kind) {
                                     ArgInfo.Kind.Bare => param.names.bare ?? continue,
                                     ArgInfo.Kind.Long => param.names.long ?? continue,
@@ -294,14 +294,14 @@ pub fn Clap(comptime Id: type) type {
                                     if (maybe_value) |v|
                                         break :blk v;
 
-                                    break :blk (try iter.innerNext()) ?? return error.MissingValue;
+                                    break :blk (try clap.nextNoParse()) ?? return error.MissingValue;
                                 };
 
                                 return Arg(Id).init(param.id, value);
                             }
                         },
                         ArgInfo.Kind.Short => {
-                            return try iter.chainging(State.Chaining {
+                            return try clap.chainging(State.Chaining {
                                 .arg = full_arg,
                                 .index = (full_arg.len - arg.len),
                             });
@@ -310,7 +310,7 @@ pub fn Clap(comptime Id: type) type {
 
                     // We do a final pass to look for value parameters matches
                     if (kind == ArgInfo.Kind.Bare) {
-                        for (iter.params) |*param| {
+                        for (clap.params) |*param| {
                             if (param.names.bare) |_| continue;
                             if (param.names.short) |_| continue;
                             if (param.names.long) |_| continue;
@@ -321,26 +321,26 @@ pub fn Clap(comptime Id: type) type {
 
                     return error.InvalidArgument;
                 },
-                @TagType(State).Chaining => |state| return try iter.chainging(state),
+                @TagType(State).Chaining => |state| return try clap.chainging(state),
             }
         }
 
-        fn chainging(iter: &Self, state: &const State.Chaining) !?Arg(Id) {
+        fn chainging(clap: &Self, state: &const State.Chaining) !?Arg(Id) {
             const arg = state.arg;
             const index = state.index;
             const next_index = index + 1;
 
-            for (iter.params) |param| {
+            for (clap.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
+                // Before we return, we have to set the new state of the clap
                 defer {
                     if (arg.len <= next_index or param.takes_value) {
-                        iter.state = State.Normal;
+                        clap.state = State.Normal;
                     } else {
-                        iter.state = State { .Chaining = State.Chaining {
+                        clap.state = State { .Chaining = State.Chaining {
                             .arg = arg,
                             .index = next_index,
                         }};
@@ -351,7 +351,7 @@ pub fn Clap(comptime Id: type) type {
                     return Arg(Id).init(param.id, null);
 
                 if (arg.len <= next_index) {
-                    const value = (try iter.innerNext()) ?? return error.MissingValue;
+                    const value = (try clap.nextNoParse()) ?? return error.MissingValue;
                     return Arg(Id).init(param.id, value);
                 }
 
@@ -365,8 +365,10 @@ pub fn Clap(comptime Id: type) type {
             return error.InvalidArgument;
         }
 
-        fn innerNext(iter: &Self) !?[]const u8 {
-            return try iter.inner.next(&iter.arena.allocator);
+        // Returns the next arg in the underlying arg iterator
+        pub fn nextNoParse(clap: &Self) !?[]const u8 {
+            clap.state = State.Normal;
+            return try clap.iter.next(&clap.arena.allocator);
         }
     };
 }