Release v1.23.0

Introduce new API for running commands (by @rexim, @programmerlexi, @0x152a)
  - Add nob_cmd_run()
  - Add nob_cmd_run_opt()
  - Add struct Nob_Cmd_Opt
  - Add nob_procs_flush()
  - Add nob_nprocs()
Deprecate old API for running commands. (by @rexim)
  We do not plan to delete this API any time, but we believe that the new one is more convenient.
  - Deprecate struct Nob_Cmd_Redirect{} (it's not explicitly marked with NOB_DEPRECATED, but functions that use it are)
  - Turn nob_cmd_run_async() into a function (otherwise it's not deprecatable with NOB_DEPRECATED)
  - Deprecate nob_cmd_run_async()
  - Deprecate nob_cmd_run_async_and_reset()
  - Deprecate nob_cmd_run_async_redirect()
  - Deprecate nob_cmd_run_async_redirect_and_reset()
  - Deprecate nob_cmd_run_sync()
  - Deprecate nob_cmd_run_sync_and_reset()
  - Deprecate nob_cmd_run_sync_redirect()
  - Deprecate nob_cmd_run_sync_redirect_and_reset()
  - Deprecate nob_procs_append_with_flush()
  - Deprecate nob_procs_wait_and_reset()
Introduce deprecation mechanism (by @yuI4140, @rexim)
  By default, deprecation warnings are not reported. You have to #define NOB_WARN_DEPRECATED to enable them.
  - Add NOB_DEPRECATED()
  - Add NOB_WARN_DEPRECATED
Add NOB_DECLTYPE_CAST() for C++-compatible casting of allocation results (by @rexim)
Introduce basic performance measuring mechanism (By @mikmart)
  - Add nob_nanos_since_unspecified_epoch()
  - Add NOB_NANOS_PER_SEC

Co-authored-by: yuI4140 <[email protected]>
Co-authored-by: Mikko Marttila <[email protected]>
Co-authored-by: 0x152a <[email protected]>
Co-authored-by: programmerlexi <[email protected]>

Author: 5 people

.github/workflows/nob.yaml

@@ -46,12 +46,12 @@ jobs:
         # https://learn.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-170#create-your-own-command-prompt-shortcut
         run: |
           call "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\VC\\Auxiliary\\Build\\vcvars64.bat"
-          cl.exe ${{ matrix.hotreload }} /Fe:nob nob.c
+          cl.exe /Fe:nob nob.c
           nob.exe
       - name: Build how_to-s
         shell: cmd
         run: |
           call "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\VC\\Auxiliary\\Build\\vcvars64.bat"
           cd how_to/
-          cl.exe ${{ matrix.hotreload }} /Fe:nob nob.c
+          cl.exe /Fe:nob nob.c
           nob.exe

how_to/001_basic_usage/nob.c

@@ -53,10 +53,10 @@ int main(int argc, char **argv)
     nob_cmd_append(&cmd, "cl", "-I.", "-o", BUILD_FOLDER"hello", SRC_FOLDER"hello.c");
 #endif // _MSC_VER
 
-    // Let's execute the command synchronously, that is it will be blocked until it's finished.
-    if (!nob_cmd_run_sync(cmd)) return 1;
-    // Reset the cmd array so you can use it again for another command
-    cmd.count = 0;
+    // Let's execute the command.
+    if (!nob_cmd_run(&cmd)) return 1;
+    // nob_cmd_run() automatically resets the cmd array, so you can nob_cmd_append() more strings
+    // into it.
 
     // nob.h ships with a bunch of nob_cc_* macros that try abstract away the specific compiler.
     // They are verify basic and not particularly flexible, but you can redefine them if you need to
@@ -65,9 +65,7 @@ int main(int argc, char **argv)
     nob_cc_flags(&cmd);
     nob_cc_output(&cmd, BUILD_FOLDER "foo");
     nob_cc_inputs(&cmd, SRC_FOLDER "foo.c");
-
-    // nob_cmd_run_sync_and_reset() resets the cmd for you automatically
-    if (!nob_cmd_run_sync_and_reset(&cmd)) return 1;
+    if (!nob_cmd_run(&cmd)) return 1;
 
     return 0;
 }

how_to/005_parallel_build/nob.c

@@ -1,5 +1,6 @@
 #define NOB_IMPLEMENTATION
 #define NOB_STRIP_PREFIX
+#define NOB_WARN_DEPRECATED
 #include "nob.h"
 
 #define BUILD_FOLDER "build/"
@@ -14,29 +15,28 @@ int main(int argc, char **argv)
 
     if (!mkdir_if_not_exists(BUILD_FOLDER)) return 1;
 
-    // Spawn three async processes collecting them to procs dynamic array
-    nob_cc(&cmd);
-    nob_cc_flags(&cmd);
-    nob_cc_output(&cmd, BUILD_FOLDER"foo");
-    nob_cc_inputs(&cmd, SRC_FOLDER"foo.c");
-    da_append(&procs, cmd_run_async_and_reset(&cmd));
-
-    nob_cc(&cmd);
-    nob_cc_flags(&cmd);
-    nob_cc_output(&cmd, BUILD_FOLDER"bar");
-    nob_cc_inputs(&cmd, SRC_FOLDER"bar.c");
-    da_append(&procs, cmd_run_async_and_reset(&cmd));
-
-    nob_cc(&cmd);
-    nob_cc_flags(&cmd);
-    nob_cc_output(&cmd, BUILD_FOLDER"baz");
-    nob_cc_inputs(&cmd, SRC_FOLDER"baz.c");
-    da_append(&procs, cmd_run_async_and_reset(&cmd));
-
-    // Wait on all the async processes to finish
-    if (!procs_wait_and_reset(&procs)) return 1;
-
-    // TODO: add some examples with nob_procs_append_with_flush()
+    static struct {
+        const char *bin_path;
+        const char *src_path;
+    } targets[] = {
+        { .bin_path = BUILD_FOLDER"foo", .src_path = SRC_FOLDER"foo.c" },
+        { .bin_path = BUILD_FOLDER"bar", .src_path = SRC_FOLDER"bar.c" },
+        { .bin_path = BUILD_FOLDER"baz", .src_path = SRC_FOLDER"baz.c" },
+    };
+
+    // Spawn one async process per target collecting them to procs dynamic array
+    for (size_t i = 0; i < ARRAY_LEN(targets); ++i) {
+        nob_cc(&cmd);
+        nob_cc_flags(&cmd);
+        nob_cc_output(&cmd, targets[i].bin_path);
+        nob_cc_inputs(&cmd, targets[i].src_path);
+        if (!cmd_run(&cmd, .async = &procs)) return 1;
+    }
+
+    // Wait on all the async processes to finish and reset procs dynamic array to 0
+    if (!procs_flush(&procs)) return 1;
+
+    // TODO: add some examples with .max_procs
 
     return 0;
 }

how_to/010_nob_two_stage/README.md

@@ -1,6 +1,6 @@
 # Two Stage Build
 
-Quite often when your project grows big enough you end up wanting to configure the build of your application: different sets of enabled features, compilation flags, etc. The recommended approach to this in nob is to setup Two Stage Build system. That is [nob.c](./nob.c) does not do any actual work except generating initial `./build/config.h` and building `./src_build/nob_configed.c` (which `#include`-s the `./build/config.h` file) and then running it.
+Quite often when your project grows big enough you end up wanting to configure the build of your application: different sets of enabled features, compilation flags, etc. The recommended approach to this in nob is to setup Two Stage Build™ system. That is [nob.c](./nob.c) does not do any actual work except generating initial `./build/config.h` and building `./src_build/nob_configed.c` (which `#include`-s the `./build/config.h` file) and then running it.
 
 Exact details of the setup is up to your. Here we present just one way of doing it. In fact you have a freedom to do as many stages of your build as you want, analysing your environment in all sorts of different ways (you literally have a system programming language at your disposal). The whole point of nob is that you bootstrap it ONLY with `cc -o nob nob.c` (no additional flags or actions should be required form the user) and the rest is taken care of by your C code.
 

how_to/010_nob_two_stage/nob.c

@@ -1,5 +1,6 @@
 #define NOB_IMPLEMENTATION
 #define NOB_STRIP_PREFIX
+#define NOB_WARN_DEPRECATED
 #include "nob.h"
 #include "src_build/folders.h"
 
@@ -36,10 +37,10 @@ int main(int argc, char **argv)
     nob_cmd_append(&cmd, "-I.", "-I"BUILD_FOLDER, "-I"SRC_BUILD_FOLDER); // -I is usually the same across all compilers
     nob_cc_output(&cmd, output_path);
     nob_cc_inputs(&cmd, input_path);
-    if (!cmd_run_sync_and_reset(&cmd)) return 1;
+    if (!cmd_run(&cmd)) return 1;
 
     cmd_append(&cmd, output_path);
-    if (!cmd_run_sync_and_reset(&cmd)) return 1;
+    if (!cmd_run(&cmd)) return 1;
 
     return 0;
 }

how_to/010_nob_two_stage/src_build/nob_configed.c

@@ -1,5 +1,6 @@
 #define NOB_IMPLEMENTATION
 #define NOB_STRIP_PREFIX
+#define NOB_WARN_DEPRECATED
 #include "nob.h"
 #include "config.h"
 #include "folders.h"
@@ -20,6 +21,6 @@ int main(void)
     nob_cmd_append(&cmd, "-I"BUILD_FOLDER, "-I.");
     nob_cc_output(&cmd, output_path);
     nob_cc_inputs(&cmd, input_path);
-    if (!cmd_run_sync_and_reset(&cmd)) return 1;
+    if (!cmd_run(&cmd)) return 1;
     return 0;
 }

how_to/nob.c

@@ -3,6 +3,7 @@
 #define NOB_IMPLEMENTATION
 #define NOB_STRIP_PREFIX
 #define NOB_EXPERIMENTAL_DELETE_OLD
+#define NOB_WARN_DEPRECATED
 #include "../nob.h"
 
 const char *examples[] = {
@@ -25,10 +26,10 @@ int main(int argc, char **argv)
                 nob_cc(&cmd);
                 nob_cc_output(&cmd, "./nob");
                 nob_cc_inputs(&cmd, "nob.c");
-                if (!cmd_run_sync_and_reset(&cmd)) return 1;
+                if (!cmd_run(&cmd)) return 1;
 
                 cmd_append(&cmd, "./nob");
-                if (!cmd_run_sync_and_reset(&cmd)) return 1;
+                if (!cmd_run(&cmd)) return 1;
             if (!set_current_dir("..")) return 1;
         temp_rewind(mark);
     }

nob.c

@@ -3,6 +3,7 @@
 #define NOB_IMPLEMENTATION
 #define NOB_STRIP_PREFIX
 #define NOB_EXPERIMENTAL_DELETE_OLD
+#define NOB_WARN_DEPRECATED
 #include "nob.h"
 #undef rename                   // Testing for backward compatibility after v1.20.6
 
@@ -36,13 +37,13 @@ bool build_and_run_test(Cmd *cmd, const char *test_name)
     nob_cc_flags(cmd);
     nob_cc_output(cmd, bin_path);
     nob_cc_inputs(cmd, src_path);
-    if (!cmd_run_sync_and_reset(cmd)) return false;
+    if (!cmd_run(cmd)) return false;
 
     const char *test_cwd_path = temp_sprintf("%s%s%s.cwd", BUILD_FOLDER, TESTS_FOLDER, test_name);
     if (!mkdir_if_not_exists(test_cwd_path)) return false;
     if (!set_current_dir(test_cwd_path)) return false;
     cmd_append(cmd, temp_sprintf("../%s", test_name));
-    if (!cmd_run_sync_and_reset(cmd))    return false;
+    if (!cmd_run(cmd))    return false;
     if (!set_current_dir("../../../")) return false;
 
     nob_log(INFO, "--- %s finished ---", bin_path);