+++ /dev/null
-/* nob - v1.9.0 - Public Domain - https://github.com/tsoding/nob
-
- This library is the next generation of the [NoBuild](https://github.com/tsoding/nobuild) idea.
-
- # Quick Example
-
- ```c
- // nob.c
- #define NOB_IMPLEMENTATION
- #include "nob.h"
-
- int main(int argc, char **argv)
- {
- NOB_GO_REBUILD_URSELF(argc, argv);
- Nob_Cmd cmd = {0};
- nob_cmd_append(&cmd, "cc", "-Wall", "-Wextra", "-o", "main", "main.c");
- if (!nob_cmd_run_sync(cmd)) return 1;
- return 0;
- }
- ```
-
- ```console
- $ cc -o nob nob.c
- $ ./nob
- ```
-
- The `nob` automatically rebuilds itself if `nob.c` is modified thanks to
- the `NOB_GO_REBUILD_URSELF` macro (don't forget to check out how it works below)
-
- # The Zoo of `nob_cmd_run_*` Functions
-
- `Nob_Cmd` is just a dynamic array of strings which represents a command and its arguments.
- First you append the arguments
-
- ```c
- Nob_Cmd cmd = {0};
- nob_cmd_append(&cmd, "cc", "-Wall", "-Wextra", "-o", "main", "main.c");
- ```
-
- Then you run it
-
- ```c
- if (!nob_cmd_run_sync(cmd)) return 1;
- ```
-
- `*_sync` at the end indicates that the function blocks until the command finishes executing
- and returns `true` on success and `false` on failure. You can run the command asynchronously
- but you have to explitictly wait for it afterwards:
-
- ```c
- Nob_Proc p = nob_cmd_run_async(cmd);
- if (p == NOB_INVALID_PROC) return 1;
- if (!nob_proc_wait(p)) return 1;
- ```
-
- One of the problems with running commands like that is that `Nob_Cmd` still contains the arguments
- from the previously run command. If you want to reuse the same `Nob_Cmd` you have to not forget to reset
- it
-
- ```c
- Nob_Cmd cmd = {0};
-
- nob_cmd_append(&cmd, "cc", "-Wall", "-Wextra", "-o", "main", "main.c");
- if (!nob_cmd_run_sync(cmd)) return 1;
- cmd.count = 0;
-
- nob_cmd_append(&cmd, "./main", "foo", "bar", "baz");
- if (!nob_cmd_run_sync(cmd)) return 1;
- cmd.count = 0;
- ```
-
- Which is a bit error prone. To make it a bit easier we have `nob_cmd_run_sync_and_reset()` which
- accepts `Nob_Cmd` by reference and resets it for you:
-
- ```c
- Nob_Cmd cmd = {0};
-
- nob_cmd_append(&cmd, "cc", "-Wall", "-Wextra", "-o", "main", "main.c");
- if (!nob_cmd_run_sync_and_reset(&cmd)) return 1;
-
- nob_cmd_append(&cmd, "./main", "foo", "bar", "baz");
- if (!nob_cmd_run_sync_and_reset(&cmd)) return 1;
- ```
-
- There is of course also `nob_cmd_run_async_and_reset()` to maintain the pattern.
-
- The stdin, stdout and stderr of any command can be redirected by using `Nob_Cmd_Redirect` structure
- along with `nob_cmd_run_sync_redirect()` or `nob_cmd_run_async_redirect()`
-
- ```c
- // Opening all the necessary files
- Nob_Fd fdin = nob_fd_open_for_read("input.txt");
- if (fdin == NOB_INVALID_FD) return 1;
- Nob_Fd fdout = nob_fd_open_for_read("output.txt");
- if (fdout == NOB_INVALID_FD) return 1;
- Nob_Fd fderr = nob_fd_open_for_read("error.txt");
- if (fderr == NOB_INVALID_FD) return 1;
-
- // Preparing the command
- Nob_Cmd cmd = {0};
- nob_cmd_append(&cmd, "./main", "foo", "bar", "baz");
-
- // Running the command synchronously redirecting the standard streams
- bool ok = nob_cmd_run_sync_redirect(cmd, (Nob_Cmd_Redirect) {
- .fdin = fdin,
- .fdout = fdout,
- .fderr = fderr,
- });
- if (!ok) return 1;
-
- // Closing all the files
- nob_fd_close(fdin);
- nob_fd_close(fdout);
- nob_fd_close(fderr);
-
- // Reseting the command
- cmd.count = 0;
- ```
-
- And of course if you find closing the files and reseting the command annoying we have
- `nob_cmd_run_sync_redirect_and_reset()` and `nob_cmd_run_async_redirect_and_reset()`
- which do all of that for you automatically.
-
- All the Zoo of `nob_cmd_run_*` functions follows the same pattern: sync/async,
- redirect/no redirect, and_reset/no and_reset. They always come in that order.
-
- # Stripping off `nob_` Prefixes
-
- Since Pure C does not have any namespaces we prefix each name of the API with the `nob_` to avoid any
- potential conflicts with any other names in your code. But sometimes it is very annoying and makes
- the code noisy. If you know that none of the names from nob.h conflict with anything in your code
- you can enable NOB_STRIP_PREFIX macro and just drop all the prefixes:
-
- ```c
- // nob.c
- #define NOB_IMPLEMENTATION
- #define NOB_STRIP_PREFIX
- #include "nob.h"
-
- int main(int argc, char **argv)
- {
- NOB_GO_REBUILD_URSELF(argc, argv);
- Cmd cmd = {0};
- cmd_append(&cmd, "cc", "-Wall", "-Wextra", "-o", "main", "main.c");
- if (!cmd_run_sync(cmd)) return 1;
- return 0;
- }
- ```
-
- Not all the names have strippable prefixes. All the redefinable names like `NOB_GO_REBUILD_URSELF`
- for instance will retain their prefix even if NOB_STRIP_PREFIX is enabled. Notable exception is the
- nob_log() function. Stripping away the prefix results in log() which was historically always referring
- to the natural logarithmic function that is already defined in math.h. So there is no reason to strip
- off the prefix for nob_log().
-
- The prefixes are stripped off only on the level of preprocessor. The names of the functions in the
- compiled object file will still retain the `nob_` prefix. Keep that in mind when you FFI with nob.h
- from other languages (for whatever reason).
-
- If only few specific names create conflicts for you, you can just #undef those names after the
- `#include <nob.h>` since they are macros anyway.
-*/
-
-#ifndef NOB_H_
-#define NOB_H_
-
-#define NOB_ASSERT assert
-#define NOB_REALLOC realloc
-#define NOB_FREE free
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-#include <errno.h>
-#include <ctype.h>
-#include <limits.h>
-
-#ifdef _WIN32
-# define WIN32_LEAN_AND_MEAN
-# define _WINUSER_
-# define _WINGDI_
-# define _IMM_
-# define _WINCON_
-# include <windows.h>
-# include <direct.h>
-# include <shellapi.h>
-#else
-# include <sys/types.h>
-# include <sys/wait.h>
-# include <sys/stat.h>
-# include <unistd.h>
-# include <fcntl.h>
-#endif
-
-#ifdef _WIN32
-# define NOB_LINE_END "\r\n"
-#else
-# define NOB_LINE_END "\n"
-#endif
-
-#define NOB_UNUSED(value) (void)(value)
-#define NOB_TODO(message) do { fprintf(stderr, "%s:%d: TODO: %s\n", __FILE__, __LINE__, message); abort(); } while(0)
-#define NOB_UNREACHABLE(message) do { fprintf(stderr, "%s:%d: UNREACHABLE: %s\n", __FILE__, __LINE__, message); abort(); } while(0)
-
-#define NOB_ARRAY_LEN(array) (sizeof(array)/sizeof(array[0]))
-#define NOB_ARRAY_GET(array, index) \
- (NOB_ASSERT((size_t)index < NOB_ARRAY_LEN(array)), array[(size_t)index])
-
-typedef enum {
- NOB_INFO,
- NOB_WARNING,
- NOB_ERROR,
- NOB_NO_LOGS,
-} Nob_Log_Level;
-
-// Any messages with the level below nob_minimal_log_level are going to be suppressed.
-extern Nob_Log_Level nob_minimal_log_level;
-
-void nob_log(Nob_Log_Level level, const char *fmt, ...);
-
-// It is an equivalent of shift command from bash. It basically pops an element from
-// the beginning of a sized array.
-#define nob_shift(xs, xs_sz) (NOB_ASSERT((xs_sz) > 0), (xs_sz)--, *(xs)++)
-// NOTE: nob_shift_args() is an alias for an old variant of nob_shift that only worked with
-// the command line arguments passed to the main() function. nob_shift() is more generic.
-// So nob_shift_args() is semi-deprecated, but I don't see much reason to urgently
-// remove it. This alias does not hurt anybody.
-#define nob_shift_args(argc, argv) nob_shift(*argv, *argc)
-
-typedef struct {
- const char **items;
- size_t count;
- size_t capacity;
-} Nob_File_Paths;
-
-typedef enum {
- NOB_FILE_REGULAR = 0,
- NOB_FILE_DIRECTORY,
- NOB_FILE_SYMLINK,
- NOB_FILE_OTHER,
-} Nob_File_Type;
-
-bool nob_mkdir_if_not_exists(const char *path);
-bool nob_copy_file(const char *src_path, const char *dst_path);
-bool nob_copy_directory_recursively(const char *src_path, const char *dst_path);
-bool nob_read_entire_dir(const char *parent, Nob_File_Paths *children);
-bool nob_write_entire_file(const char *path, const void *data, size_t size);
-Nob_File_Type nob_get_file_type(const char *path);
-
-#define nob_return_defer(value) do { result = (value); goto defer; } while(0)
-
-// Initial capacity of a dynamic array
-#ifndef NOB_DA_INIT_CAP
-#define NOB_DA_INIT_CAP 256
-#endif
-
-// Append an item to a dynamic array
-#define nob_da_append(da, item) \
- do { \
- if ((da)->count >= (da)->capacity) { \
- (da)->capacity = (da)->capacity == 0 ? NOB_DA_INIT_CAP : (da)->capacity*2; \
- (da)->items = NOB_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items)); \
- NOB_ASSERT((da)->items != NULL && "Buy more RAM lol"); \
- } \
- \
- (da)->items[(da)->count++] = (item); \
- } while (0)
-
-#define nob_da_free(da) NOB_FREE((da).items)
-
-// Append several items to a dynamic array
-#define nob_da_append_many(da, new_items, new_items_count) \
- do { \
- if ((da)->count + (new_items_count) > (da)->capacity) { \
- if ((da)->capacity == 0) { \
- (da)->capacity = NOB_DA_INIT_CAP; \
- } \
- while ((da)->count + (new_items_count) > (da)->capacity) { \
- (da)->capacity *= 2; \
- } \
- (da)->items = NOB_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items)); \
- NOB_ASSERT((da)->items != NULL && "Buy more RAM lol"); \
- } \
- memcpy((da)->items + (da)->count, (new_items), (new_items_count)*sizeof(*(da)->items)); \
- (da)->count += (new_items_count); \
- } while (0)
-
-typedef struct {
- char *items;
- size_t count;
- size_t capacity;
-} Nob_String_Builder;
-
-bool nob_read_entire_file(const char *path, Nob_String_Builder *sb);
-
-// Append a sized buffer to a string builder
-#define nob_sb_append_buf(sb, buf, size) nob_da_append_many(sb, buf, size)
-
-// Append a NULL-terminated string to a string builder
-#define nob_sb_append_cstr(sb, cstr) \
- do { \
- const char *s = (cstr); \
- size_t n = strlen(s); \
- nob_da_append_many(sb, s, n); \
- } while (0)
-
-// Append a single NULL character at the end of a string builder. So then you can
-// use it a NULL-terminated C string
-#define nob_sb_append_null(sb) nob_da_append_many(sb, "", 1)
-
-// Free the memory allocated by a string builder
-#define nob_sb_free(sb) NOB_FREE((sb).items)
-
-// Process handle
-#ifdef _WIN32
-typedef HANDLE Nob_Proc;
-#define NOB_INVALID_PROC INVALID_HANDLE_VALUE
-typedef HANDLE Nob_Fd;
-#define NOB_INVALID_FD INVALID_HANDLE_VALUE
-#else
-typedef int Nob_Proc;
-#define NOB_INVALID_PROC (-1)
-typedef int Nob_Fd;
-#define NOB_INVALID_FD (-1)
-#endif // _WIN32
-
-Nob_Fd nob_fd_open_for_read(const char *path);
-Nob_Fd nob_fd_open_for_write(const char *path);
-void nob_fd_close(Nob_Fd fd);
-
-typedef struct {
- Nob_Proc *items;
- size_t count;
- size_t capacity;
-} Nob_Procs;
-
-bool nob_procs_wait(Nob_Procs procs);
-bool nob_procs_wait_and_reset(Nob_Procs *procs);
-
-// Wait until the process has finished
-bool nob_proc_wait(Nob_Proc proc);
-
-// A command - the main workhorse of Nob. Nob is all about building commands an running them
-typedef struct {
- const char **items;
- size_t count;
- size_t capacity;
-} Nob_Cmd;
-
-// Example:
-// ```c
-// Nob_Fd fdin = nob_fd_open_for_read("input.txt");
-// if (fdin == NOB_INVALID_FD) fail();
-// Nob_Fd fdout = nob_fd_open_for_write("output.txt");
-// if (fdout == NOB_INVALID_FD) fail();
-// Nob_Cmd cmd = {0};
-// nob_cmd_append(&cmd, "cat");
-// if (!nob_cmd_run_sync_redirect_and_reset(&cmd, (Nob_Cmd_Redirect) {
-// .fdin = &fdin,
-// .fdout = &fdout
-// })) fail();
-// ```
-typedef struct {
- Nob_Fd *fdin;
- Nob_Fd *fdout;
- Nob_Fd *fderr;
-} Nob_Cmd_Redirect;
-
-// Render a string representation of a command into a string builder. Keep in mind the the
-// string builder is not NULL-terminated by default. Use nob_sb_append_null if you plan to
-// use it as a C string.
-void nob_cmd_render(Nob_Cmd cmd, Nob_String_Builder *render);
-
-#define nob_cmd_append(cmd, ...) \
- nob_da_append_many(cmd, \
- ((const char*[]){__VA_ARGS__}), \
- (sizeof((const char*[]){__VA_ARGS__})/sizeof(const char*)))
-
-#define nob_cmd_extend(cmd, other_cmd) \
- nob_da_append_many(cmd, (other_cmd)->items, (other_cmd)->count)
-
-// Free all the memory allocated by command arguments
-#define nob_cmd_free(cmd) NOB_FREE(cmd.items)
-
-// Run command asynchronously
-#define nob_cmd_run_async(cmd) nob_cmd_run_async_redirect(cmd, (Nob_Cmd_Redirect) {0})
-// NOTE: nob_cmd_run_async_and_reset() is just like nob_cmd_run_async() except it also resets cmd.count to 0
-// so the Nob_Cmd instance can be seamlessly used several times in a row
-Nob_Proc nob_cmd_run_async_and_reset(Nob_Cmd *cmd);
-// Run redirected command asynchronously
-Nob_Proc nob_cmd_run_async_redirect(Nob_Cmd cmd, Nob_Cmd_Redirect redirect);
-// Run redirected command asynchronously and set cmd.count to 0 and close all the opened files
-Nob_Proc nob_cmd_run_async_redirect_and_reset(Nob_Cmd *cmd, Nob_Cmd_Redirect redirect);
-
-// Run command synchronously
-bool nob_cmd_run_sync(Nob_Cmd cmd);
-// NOTE: nob_cmd_run_sync_and_reset() is just like nob_cmd_run_sync() except it also resets cmd.count to 0
-// so the Nob_Cmd instance can be seamlessly used several times in a row
-bool nob_cmd_run_sync_and_reset(Nob_Cmd *cmd);
-// Run redirected command synchronously
-bool nob_cmd_run_sync_redirect(Nob_Cmd cmd, Nob_Cmd_Redirect redirect);
-// Run redirected command synchronously and set cmd.count to 0 and close all the opened files
-bool nob_cmd_run_sync_redirect_and_reset(Nob_Cmd *cmd, Nob_Cmd_Redirect redirect);
-
-#ifndef NOB_TEMP_CAPACITY
-#define NOB_TEMP_CAPACITY (8*1024*1024)
-#endif // NOB_TEMP_CAPACITY
-char *nob_temp_strdup(const char *cstr);
-void *nob_temp_alloc(size_t size);
-char *nob_temp_sprintf(const char *format, ...);
-void nob_temp_reset(void);
-size_t nob_temp_save(void);
-void nob_temp_rewind(size_t checkpoint);
-
-// Given any path returns the last part of that path.
-// "/path/to/a/file.c" -> "file.c"; "/path/to/a/directory" -> "directory"
-const char *nob_path_name(const char *path);
-bool nob_rename(const char *old_path, const char *new_path);
-int nob_needs_rebuild(const char *output_path, const char **input_paths, size_t input_paths_count);
-int nob_needs_rebuild1(const char *output_path, const char *input_path);
-int nob_file_exists(const char *file_path);
-const char *nob_get_current_dir_temp(void);
-bool nob_set_current_dir(const char *path);
-
-// TODO: add MinGW support for Go Rebuild Urself™ Technology
-#ifndef NOB_REBUILD_URSELF
-# if _WIN32
-# if defined(__GNUC__)
-# define NOB_REBUILD_URSELF(binary_path, source_path) "gcc", "-o", binary_path, source_path
-# elif defined(__clang__)
-# define NOB_REBUILD_URSELF(binary_path, source_path) "clang", "-o", binary_path, source_path
-# elif defined(_MSC_VER)
-# define NOB_REBUILD_URSELF(binary_path, source_path) "cl.exe", nob_temp_sprintf("/Fe:%s", (binary_path)), source_path
-# endif
-# else
-# define NOB_REBUILD_URSELF(binary_path, source_path) "cc", "-o", binary_path, source_path
-# endif
-#endif
-
-// Go Rebuild Urself™ Technology
-//
-// How to use it:
-// int main(int argc, char** argv) {
-// NOB_GO_REBUILD_URSELF(argc, argv);
-// // actual work
-// return 0;
-// }
-//
-// After your added this macro every time you run ./nob it will detect
-// that you modified its original source code and will try to rebuild itself
-// before doing any actual work. So you only need to bootstrap your build system
-// once.
-//
-// The modification is detected by comparing the last modified times of the executable
-// and its source code. The same way the make utility usually does it.
-//
-// The rebuilding is done by using the NOB_REBUILD_URSELF macro which you can redefine
-// if you need a special way of bootstraping your build system. (which I personally
-// do not recommend since the whole idea of NoBuild is to keep the process of bootstrapping
-// as simple as possible and doing all of the actual work inside of ./nob)
-//
-void nob__go_rebuild_urself(const char *source_path, int argc, char **argv);
-#define NOB_GO_REBUILD_URSELF(argc, argv) nob__go_rebuild_urself(__FILE__, argc, argv)
-
-typedef struct {
- size_t count;
- const char *data;
-} Nob_String_View;
-
-const char *nob_temp_sv_to_cstr(Nob_String_View sv);
-
-Nob_String_View nob_sv_chop_by_delim(Nob_String_View *sv, char delim);
-Nob_String_View nob_sv_trim(Nob_String_View sv);
-Nob_String_View nob_sv_trim_left(Nob_String_View sv);
-Nob_String_View nob_sv_trim_right(Nob_String_View sv);
-bool nob_sv_eq(Nob_String_View a, Nob_String_View b);
-bool nob_sv_end_with(Nob_String_View sv, const char *cstr);
-Nob_String_View nob_sv_from_cstr(const char *cstr);
-Nob_String_View nob_sv_from_parts(const char *data, size_t count);
-// nob_sb_to_sv() enables you to just view Nob_String_Builder as Nob_String_View
-#define nob_sb_to_sv(sb) nob_sv_from_parts((sb).items, (sb).count)
-
-// printf macros for String_View
-#ifndef SV_Fmt
-#define SV_Fmt "%.*s"
-#endif // SV_Fmt
-#ifndef SV_Arg
-#define SV_Arg(sv) (int) (sv).count, (sv).data
-#endif // SV_Arg
-// USAGE:
-// String_View name = ...;
-// printf("Name: "SV_Fmt"\n", SV_Arg(name));
-
-
-// minirent.h HEADER BEGIN ////////////////////////////////////////
-// Copyright 2021 Alexey Kutepov <reximkut@gmail.com>
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-// ============================================================
-//
-// minirent — 0.0.1 — A subset of dirent interface for Windows.
-//
-// https://github.com/tsoding/minirent
-//
-// ============================================================
-//
-// ChangeLog (https://semver.org/ is implied)
-//
-// 0.0.2 Automatically include dirent.h on non-Windows
-// platforms
-// 0.0.1 First Official Release
-
-#ifndef _WIN32
-#include <dirent.h>
-#else // _WIN32
-
-#define WIN32_LEAN_AND_MEAN
-#include "windows.h"
-
-struct dirent
-{
- char d_name[MAX_PATH+1];
-};
-
-typedef struct DIR DIR;
-
-static DIR *opendir(const char *dirpath);
-static struct dirent *readdir(DIR *dirp);
-static int closedir(DIR *dirp);
-
-#endif // _WIN32
-// minirent.h HEADER END ////////////////////////////////////////
-
-#ifdef _WIN32
-
-char *nob_win32_error_message(DWORD err);
-
-#endif // _WIN32
-
-#endif // NOB_H_
-
-#ifdef NOB_IMPLEMENTATION
-
-// Any messages with the level below nob_minimal_log_level are going to be suppressed.
-Nob_Log_Level nob_minimal_log_level = NOB_INFO;
-
-#ifdef _WIN32
-
-// Base on https://stackoverflow.com/a/75644008
-// > .NET Core uses 4096 * sizeof(WCHAR) buffer on stack for FormatMessageW call. And...thats it.
-// >
-// > https://github.com/dotnet/runtime/blob/3b63eb1346f1ddbc921374a5108d025662fb5ffd/src/coreclr/utilcode/posterror.cpp#L264-L265
-#ifndef NOB_WIN32_ERR_MSG_SIZE
-#define NOB_WIN32_ERR_MSG_SIZE (4 * 1024)
-#endif // NOB_WIN32_ERR_MSG_SIZE
-
-char *nob_win32_error_message(DWORD err) {
- static char win32ErrMsg[NOB_WIN32_ERR_MSG_SIZE] = {0};
- DWORD errMsgSize = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, LANG_USER_DEFAULT, win32ErrMsg,
- NOB_WIN32_ERR_MSG_SIZE, NULL);
-
- if (errMsgSize == 0) {
- if (GetLastError() != ERROR_MR_MID_NOT_FOUND) {
- if (sprintf(win32ErrMsg, "Could not get error message for 0x%lX", err) > 0) {
- return (char *)&win32ErrMsg;
- } else {
- return NULL;
- }
- } else {
- if (sprintf(win32ErrMsg, "Invalid Windows Error code (0x%lX)", err) > 0) {
- return (char *)&win32ErrMsg;
- } else {
- return NULL;
- }
- }
- }
-
- while (errMsgSize > 1 && isspace(win32ErrMsg[errMsgSize - 1])) {
- win32ErrMsg[--errMsgSize] = '\0';
- }
-
- return win32ErrMsg;
-}
-
-#endif // _WIN32
-
-// The implementation idea is stolen from https://github.com/zhiayang/nabs
-void nob__go_rebuild_urself(const char *source_path, int argc, char **argv)
-{
- const char *binary_path = nob_shift(argv, argc);
-#ifdef _WIN32
- // On Windows executables almost always invoked without extension, so
- // it's ./nob, not ./nob.exe. For renaming the extension is a must.
- if (!nob_sv_end_with(nob_sv_from_cstr(binary_path), ".exe")) {
- binary_path = nob_temp_sprintf("%s.exe", binary_path);
- }
-#endif
-
- int rebuild_is_needed = nob_needs_rebuild1(binary_path, source_path);
- if (rebuild_is_needed < 0) exit(1); // error
- if (!rebuild_is_needed) return; // no rebuild is needed
-
- Nob_Cmd cmd = {0};
-
- const char *old_binary_path = nob_temp_sprintf("%s.old", binary_path);
-
- if (!nob_rename(binary_path, old_binary_path)) exit(1);
- nob_cmd_append(&cmd, NOB_REBUILD_URSELF(binary_path, source_path));
- if (!nob_cmd_run_sync_and_reset(&cmd)) {
- nob_rename(old_binary_path, binary_path);
- exit(1);
- }
-
- nob_cmd_append(&cmd, binary_path);
- nob_da_append_many(&cmd, argv, argc);
- if (!nob_cmd_run_sync_and_reset(&cmd)) exit(1);
- exit(0);
-}
-
-static size_t nob_temp_size = 0;
-static char nob_temp[NOB_TEMP_CAPACITY] = {0};
-
-bool nob_mkdir_if_not_exists(const char *path)
-{
-#ifdef _WIN32
- int result = mkdir(path);
-#else
- int result = mkdir(path, 0755);
-#endif
- if (result < 0) {
- if (errno == EEXIST) {
- nob_log(NOB_INFO, "directory `%s` already exists", path);
- return true;
- }
- nob_log(NOB_ERROR, "could not create directory `%s`: %s", path, strerror(errno));
- return false;
- }
-
- nob_log(NOB_INFO, "created directory `%s`", path);
- return true;
-}
-
-bool nob_copy_file(const char *src_path, const char *dst_path)
-{
- nob_log(NOB_INFO, "copying %s -> %s", src_path, dst_path);
-#ifdef _WIN32
- if (!CopyFile(src_path, dst_path, FALSE)) {
- nob_log(NOB_ERROR, "Could not copy file: %s", nob_win32_error_message(GetLastError()));
- return false;
- }
- return true;
-#else
- int src_fd = -1;
- int dst_fd = -1;
- size_t buf_size = 32*1024;
- char *buf = NOB_REALLOC(NULL, buf_size);
- NOB_ASSERT(buf != NULL && "Buy more RAM lol!!");
- bool result = true;
-
- src_fd = open(src_path, O_RDONLY);
- if (src_fd < 0) {
- nob_log(NOB_ERROR, "Could not open file %s: %s", src_path, strerror(errno));
- nob_return_defer(false);
- }
-
- struct stat src_stat;
- if (fstat(src_fd, &src_stat) < 0) {
- nob_log(NOB_ERROR, "Could not get mode of file %s: %s", src_path, strerror(errno));
- nob_return_defer(false);
- }
-
- dst_fd = open(dst_path, O_CREAT | O_TRUNC | O_WRONLY, src_stat.st_mode);
- if (dst_fd < 0) {
- nob_log(NOB_ERROR, "Could not create file %s: %s", dst_path, strerror(errno));
- nob_return_defer(false);
- }
-
- for (;;) {
- ssize_t n = read(src_fd, buf, buf_size);
- if (n == 0) break;
- if (n < 0) {
- nob_log(NOB_ERROR, "Could not read from file %s: %s", src_path, strerror(errno));
- nob_return_defer(false);
- }
- char *buf2 = buf;
- while (n > 0) {
- ssize_t m = write(dst_fd, buf2, n);
- if (m < 0) {
- nob_log(NOB_ERROR, "Could not write to file %s: %s", dst_path, strerror(errno));
- nob_return_defer(false);
- }
- n -= m;
- buf2 += m;
- }
- }
-
-defer:
- free(buf);
- close(src_fd);
- close(dst_fd);
- return result;
-#endif
-}
-
-void nob_cmd_render(Nob_Cmd cmd, Nob_String_Builder *render)
-{
- for (size_t i = 0; i < cmd.count; ++i) {
- const char *arg = cmd.items[i];
- if (arg == NULL) break;
- if (i > 0) nob_sb_append_cstr(render, " ");
- if (!strchr(arg, ' ')) {
- nob_sb_append_cstr(render, arg);
- } else {
- nob_da_append(render, '\'');
- nob_sb_append_cstr(render, arg);
- nob_da_append(render, '\'');
- }
- }
-}
-
-Nob_Proc nob_cmd_run_async_redirect(Nob_Cmd cmd, Nob_Cmd_Redirect redirect)
-{
- if (cmd.count < 1) {
- nob_log(NOB_ERROR, "Could not run empty command");
- return NOB_INVALID_PROC;
- }
-
- Nob_String_Builder sb = {0};
- nob_cmd_render(cmd, &sb);
- nob_sb_append_null(&sb);
- nob_log(NOB_INFO, "CMD: %s", sb.items);
- nob_sb_free(sb);
- memset(&sb, 0, sizeof(sb));
-
-#ifdef _WIN32
- // https://docs.microsoft.com/en-us/windows/win32/procthread/creating-a-child-process-with-redirected-input-and-output
-
- STARTUPINFO siStartInfo;
- ZeroMemory(&siStartInfo, sizeof(siStartInfo));
- siStartInfo.cb = sizeof(STARTUPINFO);
- // NOTE: theoretically setting NULL to std handles should not be a problem
- // https://docs.microsoft.com/en-us/windows/console/getstdhandle?redirectedfrom=MSDN#attachdetach-behavior
- // TODO: check for errors in GetStdHandle
- siStartInfo.hStdError = redirect.fderr ? *redirect.fderr : GetStdHandle(STD_ERROR_HANDLE);
- siStartInfo.hStdOutput = redirect.fdout ? *redirect.fdout : GetStdHandle(STD_OUTPUT_HANDLE);
- siStartInfo.hStdInput = redirect.fdin ? *redirect.fdin : GetStdHandle(STD_INPUT_HANDLE);
- siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
-
- PROCESS_INFORMATION piProcInfo;
- ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));
-
- // TODO: use a more reliable rendering of the command instead of cmd_render
- // cmd_render is for logging primarily
- nob_cmd_render(cmd, &sb);
- nob_sb_append_null(&sb);
- BOOL bSuccess = CreateProcessA(NULL, sb.items, NULL, NULL, TRUE, 0, NULL, NULL, &siStartInfo, &piProcInfo);
- nob_sb_free(sb);
-
- if (!bSuccess) {
- nob_log(NOB_ERROR, "Could not create child process: %s", nob_win32_error_message(GetLastError()));
- return NOB_INVALID_PROC;
- }
-
- CloseHandle(piProcInfo.hThread);
-
- return piProcInfo.hProcess;
-#else
- pid_t cpid = fork();
- if (cpid < 0) {
- nob_log(NOB_ERROR, "Could not fork child process: %s", strerror(errno));
- return NOB_INVALID_PROC;
- }
-
- if (cpid == 0) {
- if (redirect.fdin) {
- if (dup2(*redirect.fdin, STDIN_FILENO) < 0) {
- nob_log(NOB_ERROR, "Could not setup stdin for child process: %s", strerror(errno));
- exit(1);
- }
- }
-
- if (redirect.fdout) {
- if (dup2(*redirect.fdout, STDOUT_FILENO) < 0) {
- nob_log(NOB_ERROR, "Could not setup stdout for child process: %s", strerror(errno));
- exit(1);
- }
- }
-
- if (redirect.fderr) {
- if (dup2(*redirect.fderr, STDERR_FILENO) < 0) {
- nob_log(NOB_ERROR, "Could not setup stderr for child process: %s", strerror(errno));
- exit(1);
- }
- }
-
- // NOTE: This leaks a bit of memory in the child process.
- // But do we actually care? It's a one off leak anyway...
- Nob_Cmd cmd_null = {0};
- nob_da_append_many(&cmd_null, cmd.items, cmd.count);
- nob_cmd_append(&cmd_null, NULL);
-
- if (execvp(cmd.items[0], (char * const*) cmd_null.items) < 0) {
- nob_log(NOB_ERROR, "Could not exec child process: %s", strerror(errno));
- exit(1);
- }
- NOB_UNREACHABLE("nob_cmd_run_async_redirect");
- }
-
- return cpid;
-#endif
-}
-
-Nob_Proc nob_cmd_run_async_and_reset(Nob_Cmd *cmd)
-{
- Nob_Proc proc = nob_cmd_run_async(*cmd);
- cmd->count = 0;
- return proc;
-}
-
-Nob_Proc nob_cmd_run_async_redirect_and_reset(Nob_Cmd *cmd, Nob_Cmd_Redirect redirect)
-{
- Nob_Proc proc = nob_cmd_run_async_redirect(*cmd, redirect);
- cmd->count = 0;
- if (redirect.fdin) {
- nob_fd_close(*redirect.fdin);
- *redirect.fdin = NOB_INVALID_FD;
- }
- if (redirect.fdout) {
- nob_fd_close(*redirect.fdout);
- *redirect.fdout = NOB_INVALID_FD;
- }
- if (redirect.fderr) {
- nob_fd_close(*redirect.fderr);
- *redirect.fderr = NOB_INVALID_FD;
- }
- return proc;
-}
-
-Nob_Fd nob_fd_open_for_read(const char *path)
-{
-#ifndef _WIN32
- Nob_Fd result = open(path, O_RDONLY);
- if (result < 0) {
- nob_log(NOB_ERROR, "Could not open file %s: %s", path, strerror(errno));
- return NOB_INVALID_FD;
- }
- return result;
-#else
- // https://docs.microsoft.com/en-us/windows/win32/fileio/opening-a-file-for-reading-or-writing
- SECURITY_ATTRIBUTES saAttr = {0};
- saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
- saAttr.bInheritHandle = TRUE;
-
- Nob_Fd result = CreateFile(
- path,
- GENERIC_READ,
- 0,
- &saAttr,
- OPEN_EXISTING,
- FILE_ATTRIBUTE_READONLY,
- NULL);
-
- if (result == INVALID_HANDLE_VALUE) {
- nob_log(NOB_ERROR, "Could not open file %s: %s", path, nob_win32_error_message(GetLastError()));
- return NOB_INVALID_FD;
- }
-
- return result;
-#endif // _WIN32
-}
-
-Nob_Fd nob_fd_open_for_write(const char *path)
-{
-#ifndef _WIN32
- Nob_Fd result = open(path,
- O_WRONLY | O_CREAT | O_TRUNC,
- S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
- if (result < 0) {
- nob_log(NOB_ERROR, "could not open file %s: %s", path, strerror(errno));
- return NOB_INVALID_FD;
- }
- return result;
-#else
- SECURITY_ATTRIBUTES saAttr = {0};
- saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
- saAttr.bInheritHandle = TRUE;
-
- Nob_Fd result = CreateFile(
- path, // name of the write
- GENERIC_WRITE, // open for writing
- 0, // do not share
- &saAttr, // default security
- OPEN_ALWAYS, // open always
- FILE_ATTRIBUTE_NORMAL, // normal file
- NULL // no attr. template
- );
-
- if (result == INVALID_HANDLE_VALUE) {
- nob_log(NOB_ERROR, "Could not open file %s: %s", path, nob_win32_error_message(GetLastError()));
- return NOB_INVALID_FD;
- }
-
- return result;
-#endif // _WIN32
-}
-
-void nob_fd_close(Nob_Fd fd)
-{
-#ifdef _WIN32
- CloseHandle(fd);
-#else
- close(fd);
-#endif // _WIN32
-}
-
-bool nob_procs_wait(Nob_Procs procs)
-{
- bool success = true;
- for (size_t i = 0; i < procs.count; ++i) {
- success = nob_proc_wait(procs.items[i]) && success;
- }
- return success;
-}
-
-bool nob_procs_wait_and_reset(Nob_Procs *procs)
-{
- bool success = nob_procs_wait(*procs);
- procs->count = 0;
- return success;
-}
-
-bool nob_proc_wait(Nob_Proc proc)
-{
- if (proc == NOB_INVALID_PROC) return false;
-
-#ifdef _WIN32
- DWORD result = WaitForSingleObject(
- proc, // HANDLE hHandle,
- INFINITE // DWORD dwMilliseconds
- );
-
- if (result == WAIT_FAILED) {
- nob_log(NOB_ERROR, "could not wait on child process: %s", nob_win32_error_message(GetLastError()));
- return false;
- }
-
- DWORD exit_status;
- if (!GetExitCodeProcess(proc, &exit_status)) {
- nob_log(NOB_ERROR, "could not get process exit code: %s", nob_win32_error_message(GetLastError()));
- return false;
- }
-
- if (exit_status != 0) {
- nob_log(NOB_ERROR, "command exited with exit code %lu", exit_status);
- return false;
- }
-
- CloseHandle(proc);
-
- return true;
-#else
- for (;;) {
- int wstatus = 0;
- if (waitpid(proc, &wstatus, 0) < 0) {
- nob_log(NOB_ERROR, "could not wait on command (pid %d): %s", proc, strerror(errno));
- return false;
- }
-
- if (WIFEXITED(wstatus)) {
- int exit_status = WEXITSTATUS(wstatus);
- if (exit_status != 0) {
- nob_log(NOB_ERROR, "command exited with exit code %d", exit_status);
- return false;
- }
-
- break;
- }
-
- if (WIFSIGNALED(wstatus)) {
- nob_log(NOB_ERROR, "command process was terminated by %s", strsignal(WTERMSIG(wstatus)));
- return false;
- }
- }
-
- return true;
-#endif
-}
-
-bool nob_cmd_run_sync_redirect(Nob_Cmd cmd, Nob_Cmd_Redirect redirect)
-{
- Nob_Proc p = nob_cmd_run_async_redirect(cmd, redirect);
- if (p == NOB_INVALID_PROC) return false;
- return nob_proc_wait(p);
-}
-
-bool nob_cmd_run_sync(Nob_Cmd cmd)
-{
- Nob_Proc p = nob_cmd_run_async(cmd);
- if (p == NOB_INVALID_PROC) return false;
- return nob_proc_wait(p);
-}
-
-bool nob_cmd_run_sync_and_reset(Nob_Cmd *cmd)
-{
- bool p = nob_cmd_run_sync(*cmd);
- cmd->count = 0;
- return p;
-}
-
-bool nob_cmd_run_sync_redirect_and_reset(Nob_Cmd *cmd, Nob_Cmd_Redirect redirect)
-{
- bool p = nob_cmd_run_sync_redirect(*cmd, redirect);
- cmd->count = 0;
- if (redirect.fdin) {
- nob_fd_close(*redirect.fdin);
- *redirect.fdin = NOB_INVALID_FD;
- }
- if (redirect.fdout) {
- nob_fd_close(*redirect.fdout);
- *redirect.fdout = NOB_INVALID_FD;
- }
- if (redirect.fderr) {
- nob_fd_close(*redirect.fderr);
- *redirect.fderr = NOB_INVALID_FD;
- }
- return p;
-}
-
-void nob_log(Nob_Log_Level level, const char *fmt, ...)
-{
- if (level < nob_minimal_log_level) return;
-
- switch (level) {
- case NOB_INFO:
- fprintf(stderr, "[INFO] ");
- break;
- case NOB_WARNING:
- fprintf(stderr, "[WARNING] ");
- break;
- case NOB_ERROR:
- fprintf(stderr, "[ERROR] ");
- break;
- case NOB_NO_LOGS: return;
- default:
- NOB_UNREACHABLE("nob_log");
- }
-
- va_list args;
- va_start(args, fmt);
- vfprintf(stderr, fmt, args);
- va_end(args);
- fprintf(stderr, "\n");
-}
-
-bool nob_read_entire_dir(const char *parent, Nob_File_Paths *children)
-{
- bool result = true;
- DIR *dir = NULL;
-
- dir = opendir(parent);
- if (dir == NULL) {
- #ifdef _WIN32
- nob_log(NOB_ERROR, "Could not open directory %s: %s", parent, nob_win32_error_message(GetLastError()));
- #else
- nob_log(NOB_ERROR, "Could not open directory %s: %s", parent, strerror(errno));
- #endif // _WIN32
- nob_return_defer(false);
- }
-
- errno = 0;
- struct dirent *ent = readdir(dir);
- while (ent != NULL) {
- nob_da_append(children, nob_temp_strdup(ent->d_name));
- ent = readdir(dir);
- }
-
- if (errno != 0) {
- #ifdef _WIN32
- nob_log(NOB_ERROR, "Could not read directory %s: %s", parent, nob_win32_error_message(GetLastError()));
- #else
- nob_log(NOB_ERROR, "Could not read directory %s: %s", parent, strerror(errno));
- #endif // _WIN32
- nob_return_defer(false);
- }
-
-defer:
- if (dir) closedir(dir);
- return result;
-}
-
-bool nob_write_entire_file(const char *path, const void *data, size_t size)
-{
- bool result = true;
-
- FILE *f = fopen(path, "wb");
- if (f == NULL) {
- nob_log(NOB_ERROR, "Could not open file %s for writing: %s\n", path, strerror(errno));
- nob_return_defer(false);
- }
-
- // len
- // v
- // aaaaaaaaaa
- // ^
- // data
-
- const char *buf = data;
- while (size > 0) {
- size_t n = fwrite(buf, 1, size, f);
- if (ferror(f)) {
- nob_log(NOB_ERROR, "Could not write into file %s: %s\n", path, strerror(errno));
- nob_return_defer(false);
- }
- size -= n;
- buf += n;
- }
-
-defer:
- if (f) fclose(f);
- return result;
-}
-
-Nob_File_Type nob_get_file_type(const char *path)
-{
-#ifdef _WIN32
- DWORD attr = GetFileAttributesA(path);
- if (attr == INVALID_FILE_ATTRIBUTES) {
- nob_log(NOB_ERROR, "Could not get file attributes of %s: %s", path, nob_win32_error_message(GetLastError()));
- return -1;
- }
-
- if (attr & FILE_ATTRIBUTE_DIRECTORY) return NOB_FILE_DIRECTORY;
- // TODO: detect symlinks on Windows (whatever that means on Windows anyway)
- return NOB_FILE_REGULAR;
-#else // _WIN32
- struct stat statbuf;
- if (stat(path, &statbuf) < 0) {
- nob_log(NOB_ERROR, "Could not get stat of %s: %s", path, strerror(errno));
- return -1;
- }
-
- switch (statbuf.st_mode & S_IFMT) {
- case S_IFDIR: return NOB_FILE_DIRECTORY;
- case S_IFREG: return NOB_FILE_REGULAR;
- case S_IFLNK: return NOB_FILE_SYMLINK;
- default: return NOB_FILE_OTHER;
- }
-#endif // _WIN32
-}
-
-bool nob_copy_directory_recursively(const char *src_path, const char *dst_path)
-{
- bool result = true;
- Nob_File_Paths children = {0};
- Nob_String_Builder src_sb = {0};
- Nob_String_Builder dst_sb = {0};
- size_t temp_checkpoint = nob_temp_save();
-
- Nob_File_Type type = nob_get_file_type(src_path);
- if (type < 0) return false;
-
- switch (type) {
- case NOB_FILE_DIRECTORY: {
- if (!nob_mkdir_if_not_exists(dst_path)) nob_return_defer(false);
- if (!nob_read_entire_dir(src_path, &children)) nob_return_defer(false);
-
- for (size_t i = 0; i < children.count; ++i) {
- if (strcmp(children.items[i], ".") == 0) continue;
- if (strcmp(children.items[i], "..") == 0) continue;
-
- src_sb.count = 0;
- nob_sb_append_cstr(&src_sb, src_path);
- nob_sb_append_cstr(&src_sb, "/");
- nob_sb_append_cstr(&src_sb, children.items[i]);
- nob_sb_append_null(&src_sb);
-
- dst_sb.count = 0;
- nob_sb_append_cstr(&dst_sb, dst_path);
- nob_sb_append_cstr(&dst_sb, "/");
- nob_sb_append_cstr(&dst_sb, children.items[i]);
- nob_sb_append_null(&dst_sb);
-
- if (!nob_copy_directory_recursively(src_sb.items, dst_sb.items)) {
- nob_return_defer(false);
- }
- }
- } break;
-
- case NOB_FILE_REGULAR: {
- if (!nob_copy_file(src_path, dst_path)) {
- nob_return_defer(false);
- }
- } break;
-
- case NOB_FILE_SYMLINK: {
- nob_log(NOB_WARNING, "TODO: Copying symlinks is not supported yet");
- } break;
-
- case NOB_FILE_OTHER: {
- nob_log(NOB_ERROR, "Unsupported type of file %s", src_path);
- nob_return_defer(false);
- } break;
-
- default: NOB_UNREACHABLE("nob_copy_directory_recursively");
- }
-
-defer:
- nob_temp_rewind(temp_checkpoint);
- nob_da_free(src_sb);
- nob_da_free(dst_sb);
- nob_da_free(children);
- return result;
-}
-
-char *nob_temp_strdup(const char *cstr)
-{
- size_t n = strlen(cstr);
- char *result = nob_temp_alloc(n + 1);
- NOB_ASSERT(result != NULL && "Increase NOB_TEMP_CAPACITY");
- memcpy(result, cstr, n);
- result[n] = '\0';
- return result;
-}
-
-void *nob_temp_alloc(size_t size)
-{
- if (nob_temp_size + size > NOB_TEMP_CAPACITY) return NULL;
- void *result = &nob_temp[nob_temp_size];
- nob_temp_size += size;
- return result;
-}
-
-char *nob_temp_sprintf(const char *format, ...)
-{
- va_list args;
- va_start(args, format);
- int n = vsnprintf(NULL, 0, format, args);
- va_end(args);
-
- NOB_ASSERT(n >= 0);
- char *result = nob_temp_alloc(n + 1);
- NOB_ASSERT(result != NULL && "Extend the size of the temporary allocator");
- // TODO: use proper arenas for the temporary allocator;
- va_start(args, format);
- vsnprintf(result, n + 1, format, args);
- va_end(args);
-
- return result;
-}
-
-void nob_temp_reset(void)
-{
- nob_temp_size = 0;
-}
-
-size_t nob_temp_save(void)
-{
- return nob_temp_size;
-}
-
-void nob_temp_rewind(size_t checkpoint)
-{
- nob_temp_size = checkpoint;
-}
-
-const char *nob_temp_sv_to_cstr(Nob_String_View sv)
-{
- char *result = nob_temp_alloc(sv.count + 1);
- NOB_ASSERT(result != NULL && "Extend the size of the temporary allocator");
- memcpy(result, sv.data, sv.count);
- result[sv.count] = '\0';
- return result;
-}
-
-int nob_needs_rebuild(const char *output_path, const char **input_paths, size_t input_paths_count)
-{
-#ifdef _WIN32
- BOOL bSuccess;
-
- HANDLE output_path_fd = CreateFile(output_path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
- if (output_path_fd == INVALID_HANDLE_VALUE) {
- // NOTE: if output does not exist it 100% must be rebuilt
- if (GetLastError() == ERROR_FILE_NOT_FOUND) return 1;
- nob_log(NOB_ERROR, "Could not open file %s: %s", output_path, nob_win32_error_message(GetLastError()));
- return -1;
- }
- FILETIME output_path_time;
- bSuccess = GetFileTime(output_path_fd, NULL, NULL, &output_path_time);
- CloseHandle(output_path_fd);
- if (!bSuccess) {
- nob_log(NOB_ERROR, "Could not get time of %s: %s", output_path, nob_win32_error_message(GetLastError()));
- return -1;
- }
-
- for (size_t i = 0; i < input_paths_count; ++i) {
- const char *input_path = input_paths[i];
- HANDLE input_path_fd = CreateFile(input_path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
- if (input_path_fd == INVALID_HANDLE_VALUE) {
- // NOTE: non-existing input is an error cause it is needed for building in the first place
- nob_log(NOB_ERROR, "Could not open file %s: %s", input_path, nob_win32_error_message(GetLastError()));
- return -1;
- }
- FILETIME input_path_time;
- bSuccess = GetFileTime(input_path_fd, NULL, NULL, &input_path_time);
- CloseHandle(input_path_fd);
- if (!bSuccess) {
- nob_log(NOB_ERROR, "Could not get time of %s: %s", input_path, nob_win32_error_message(GetLastError()));
- return -1;
- }
-
- // NOTE: if even a single input_path is fresher than output_path that's 100% rebuild
- if (CompareFileTime(&input_path_time, &output_path_time) == 1) return 1;
- }
-
- return 0;
-#else
- struct stat statbuf = {0};
-
- if (stat(output_path, &statbuf) < 0) {
- // NOTE: if output does not exist it 100% must be rebuilt
- if (errno == ENOENT) return 1;
- nob_log(NOB_ERROR, "could not stat %s: %s", output_path, strerror(errno));
- return -1;
- }
- int output_path_time = statbuf.st_mtime;
-
- for (size_t i = 0; i < input_paths_count; ++i) {
- const char *input_path = input_paths[i];
- if (stat(input_path, &statbuf) < 0) {
- // NOTE: non-existing input is an error cause it is needed for building in the first place
- nob_log(NOB_ERROR, "could not stat %s: %s", input_path, strerror(errno));
- return -1;
- }
- int input_path_time = statbuf.st_mtime;
- // NOTE: if even a single input_path is fresher than output_path that's 100% rebuild
- if (input_path_time > output_path_time) return 1;
- }
-
- return 0;
-#endif
-}
-
-int nob_needs_rebuild1(const char *output_path, const char *input_path)
-{
- return nob_needs_rebuild(output_path, &input_path, 1);
-}
-
-const char *nob_path_name(const char *path)
-{
-#ifdef _WIN32
- const char *p1 = strrchr(path, '/');
- const char *p2 = strrchr(path, '\\');
- const char *p = (p1 > p2)? p1 : p2; // NULL is ignored if the other search is successful
- return p ? p + 1 : path;
-#else
- const char *p = strrchr(path, '/');
- return p ? p + 1 : path;
-#endif // _WIN32
-}
-
-bool nob_rename(const char *old_path, const char *new_path)
-{
- nob_log(NOB_INFO, "renaming %s -> %s", old_path, new_path);
-#ifdef _WIN32
- if (!MoveFileEx(old_path, new_path, MOVEFILE_REPLACE_EXISTING)) {
- nob_log(NOB_ERROR, "could not rename %s to %s: %s", old_path, new_path, nob_win32_error_message(GetLastError()));
- return false;
- }
-#else
- if (rename(old_path, new_path) < 0) {
- nob_log(NOB_ERROR, "could not rename %s to %s: %s", old_path, new_path, strerror(errno));
- return false;
- }
-#endif // _WIN32
- return true;
-}
-
-bool nob_read_entire_file(const char *path, Nob_String_Builder *sb)
-{
- bool result = true;
-
- FILE *f = fopen(path, "rb");
- if (f == NULL) nob_return_defer(false);
- if (fseek(f, 0, SEEK_END) < 0) nob_return_defer(false);
- long m = ftell(f);
- if (m < 0) nob_return_defer(false);
- if (fseek(f, 0, SEEK_SET) < 0) nob_return_defer(false);
-
- size_t new_count = sb->count + m;
- if (new_count > sb->capacity) {
- sb->items = realloc(sb->items, new_count);
- NOB_ASSERT(sb->items != NULL && "Buy more RAM lool!!");
- sb->capacity = new_count;
- }
-
- fread(sb->items + sb->count, m, 1, f);
- if (ferror(f)) {
- // TODO: Afaik, ferror does not set errno. So the error reporting in defer is not correct in this case.
- nob_return_defer(false);
- }
- sb->count = new_count;
-
-defer:
- if (!result) nob_log(NOB_ERROR, "Could not read file %s: %s", path, strerror(errno));
- if (f) fclose(f);
- return result;
-}
-
-Nob_String_View nob_sv_chop_by_delim(Nob_String_View *sv, char delim)
-{
- size_t i = 0;
- while (i < sv->count && sv->data[i] != delim) {
- i += 1;
- }
-
- Nob_String_View result = nob_sv_from_parts(sv->data, i);
-
- if (i < sv->count) {
- sv->count -= i + 1;
- sv->data += i + 1;
- } else {
- sv->count -= i;
- sv->data += i;
- }
-
- return result;
-}
-
-Nob_String_View nob_sv_from_parts(const char *data, size_t count)
-{
- Nob_String_View sv;
- sv.count = count;
- sv.data = data;
- return sv;
-}
-
-Nob_String_View nob_sv_trim_left(Nob_String_View sv)
-{
- size_t i = 0;
- while (i < sv.count && isspace(sv.data[i])) {
- i += 1;
- }
-
- return nob_sv_from_parts(sv.data + i, sv.count - i);
-}
-
-Nob_String_View nob_sv_trim_right(Nob_String_View sv)
-{
- size_t i = 0;
- while (i < sv.count && isspace(sv.data[sv.count - 1 - i])) {
- i += 1;
- }
-
- return nob_sv_from_parts(sv.data, sv.count - i);
-}
-
-Nob_String_View nob_sv_trim(Nob_String_View sv)
-{
- return nob_sv_trim_right(nob_sv_trim_left(sv));
-}
-
-Nob_String_View nob_sv_from_cstr(const char *cstr)
-{
- return nob_sv_from_parts(cstr, strlen(cstr));
-}
-
-bool nob_sv_eq(Nob_String_View a, Nob_String_View b)
-{
- if (a.count != b.count) {
- return false;
- } else {
- return memcmp(a.data, b.data, a.count) == 0;
- }
-}
-
-bool nob_sv_end_with(Nob_String_View sv, const char *cstr)
-{
- size_t cstr_count = strlen(cstr);
- if (sv.count >= cstr_count) {
- size_t ending_start = sv.count - cstr_count;
- Nob_String_View sv_ending = nob_sv_from_parts(sv.data + ending_start, cstr_count);
- return nob_sv_eq(sv_ending, nob_sv_from_cstr(cstr));
- }
- return false;
-}
-
-// RETURNS:
-// 0 - file does not exists
-// 1 - file exists
-// -1 - error while checking if file exists. The error is logged
-int nob_file_exists(const char *file_path)
-{
-#if _WIN32
- // TODO: distinguish between "does not exists" and other errors
- DWORD dwAttrib = GetFileAttributesA(file_path);
- return dwAttrib != INVALID_FILE_ATTRIBUTES;
-#else
- struct stat statbuf;
- if (stat(file_path, &statbuf) < 0) {
- if (errno == ENOENT) return 0;
- nob_log(NOB_ERROR, "Could not check if file %s exists: %s", file_path, strerror(errno));
- return -1;
- }
- return 1;
-#endif
-}
-
-const char *nob_get_current_dir_temp()
-{
-#ifdef _WIN32
- DWORD nBufferLength = GetCurrentDirectory(0, NULL);
- if (nBufferLength == 0) {
- nob_log(NOB_ERROR, "could not get current directory: %s", nob_win32_error_message(GetLastError()));
- return NULL;
- }
-
- char *buffer = (char*) nob_temp_alloc(nBufferLength);
- if (GetCurrentDirectory(nBufferLength, buffer) == 0) {
- nob_log(NOB_ERROR, "could not get current directory: %s", nob_win32_error_message(GetLastError()));
- return NULL;
- }
-
- return buffer;
-#else
- char *buffer = (char*) nob_temp_alloc(PATH_MAX);
- if (getcwd(buffer, PATH_MAX) == NULL) {
- nob_log(NOB_ERROR, "could not get current directory: %s", strerror(errno));
- return NULL;
- }
-
- return buffer;
-#endif // _WIN32
-}
-
-bool nob_set_current_dir(const char *path)
-{
-#ifdef _WIN32
- if (!SetCurrentDirectory(path)) {
- nob_log(NOB_ERROR, "could not set current directory to %s: %s", path, nob_win32_error_message(GetLastError()));
- return false;
- }
- return true;
-#else
- if (chdir(path) < 0) {
- nob_log(NOB_ERROR, "could not set current directory to %s: %s", path, strerror(errno));
- return false;
- }
- return true;
-#endif // _WIN32
-}
-
-// minirent.h SOURCE BEGIN ////////////////////////////////////////
-#ifdef _WIN32
-struct DIR
-{
- HANDLE hFind;
- WIN32_FIND_DATA data;
- struct dirent *dirent;
-};
-
-DIR *opendir(const char *dirpath)
-{
- assert(dirpath);
-
- char buffer[MAX_PATH];
- snprintf(buffer, MAX_PATH, "%s\\*", dirpath);
-
- DIR *dir = (DIR*)calloc(1, sizeof(DIR));
-
- dir->hFind = FindFirstFile(buffer, &dir->data);
- if (dir->hFind == INVALID_HANDLE_VALUE) {
- // TODO: opendir should set errno accordingly on FindFirstFile fail
- // https://docs.microsoft.com/en-us/windows/win32/api/errhandlingapi/nf-errhandlingapi-getlasterror
- errno = ENOSYS;
- goto fail;
- }
-
- return dir;
-
-fail:
- if (dir) {
- free(dir);
- }
-
- return NULL;
-}
-
-struct dirent *readdir(DIR *dirp)
-{
- assert(dirp);
-
- if (dirp->dirent == NULL) {
- dirp->dirent = (struct dirent*)calloc(1, sizeof(struct dirent));
- } else {
- if(!FindNextFile(dirp->hFind, &dirp->data)) {
- if (GetLastError() != ERROR_NO_MORE_FILES) {
- // TODO: readdir should set errno accordingly on FindNextFile fail
- // https://docs.microsoft.com/en-us/windows/win32/api/errhandlingapi/nf-errhandlingapi-getlasterror
- errno = ENOSYS;
- }
-
- return NULL;
- }
- }
-
- memset(dirp->dirent->d_name, 0, sizeof(dirp->dirent->d_name));
-
- strncpy(
- dirp->dirent->d_name,
- dirp->data.cFileName,
- sizeof(dirp->dirent->d_name) - 1);
-
- return dirp->dirent;
-}
-
-int closedir(DIR *dirp)
-{
- assert(dirp);
-
- if(!FindClose(dirp->hFind)) {
- // TODO: closedir should set errno accordingly on FindClose fail
- // https://docs.microsoft.com/en-us/windows/win32/api/errhandlingapi/nf-errhandlingapi-getlasterror
- errno = ENOSYS;
- return -1;
- }
-
- if (dirp->dirent) {
- free(dirp->dirent);
- }
- free(dirp);
-
- return 0;
-}
-#endif // _WIN32
-// minirent.h SOURCE END ////////////////////////////////////////
-
-#endif // NOB_IMPLEMENTATION
-
-#ifndef NOB_STRIP_PREFIX_GUARD_
-#define NOB_STRIP_PREFIX_GUARD_
- // NOTE: The name stripping should be part of the header so it's not accidentally included
- // several times. At the same time, it should be at the end of the file so to not create any
- // potential conflicts in the NOB_IMPLEMENTATION. The header obviously cannot be at the end
- // of the file because NOB_IMPLEMENTATION needs the forward declarations from there. So the
- // solution is to split the header into two parts where the name stripping part is at the
- // end of the file after the NOB_IMPLEMENTATION.
- #ifdef NOB_STRIP_PREFIX
- #define TODO NOB_TODO
- #define UNREACHABLE NOB_UNREACHABLE
- #define UNUSED NOB_UNUSED
- #define ARRAY_LEN NOB_ARRAY_LEN
- #define ARRAY_GET NOB_ARRAY_GET
- #define INFO NOB_INFO
- #define WARNING NOB_WARNING
- #define ERROR NOB_ERROR
- #define NO_LOGS NOB_NO_LOGS
- #define Log_Level Nob_Log_Level
- #define minimal_log_level nob_minimal_log_level
- // NOTE: Name log is already defined in math.h and historically always was the natural logarithmic function.
- // So there should be no reason to strip the `nob_` prefix in this specific case.
- // #define log nob_log
- #define shift nob_shift
- #define shift_args nob_shift_args
- #define File_Paths Nob_File_Paths
- #define FILE_REGULAR NOB_FILE_REGULAR
- #define FILE_DIRECTORY NOB_FILE_DIRECTORY
- #define FILE_SYMLINK NOB_FILE_SYMLINK
- #define FILE_OTHER NOB_FILE_OTHER
- #define File_Type Nob_File_Type
- #define mkdir_if_not_exists nob_mkdir_if_not_exists
- #define copy_file nob_copy_file
- #define copy_directory_recursively nob_copy_directory_recursively
- #define read_entire_dir nob_read_entire_dir
- #define write_entire_file nob_write_entire_file
- #define get_file_type nob_get_file_type
- #define return_defer nob_return_defer
- #define da_append nob_da_append
- #define da_free nob_da_free
- #define da_append_many nob_da_append_many
- #define String_Builder Nob_String_Builder
- #define read_entire_file nob_read_entire_file
- #define sb_append_buf nob_sb_append_buf
- #define sb_append_cstr nob_sb_append_cstr
- #define sb_append_null nob_sb_append_null
- #define sb_free nob_sb_free
- #define Proc Nob_Proc
- #define INVALID_PROC NOB_INVALID_PROC
- #define Fd Nob_Fd
- #define INVALID_FD NOB_INVALID_FD
- #define fd_open_for_read nob_fd_open_for_read
- #define fd_open_for_write nob_fd_open_for_write
- #define fd_close nob_fd_close
- #define Procs Nob_Procs
- #define procs_wait nob_procs_wait
- #define procs_wait_and_reset nob_procs_wait_and_reset
- #define proc_wait nob_proc_wait
- #define Cmd Nob_Cmd
- #define Cmd_Redirect Nob_Cmd_Redirect
- #define cmd_render nob_cmd_render
- #define cmd_append nob_cmd_append
- #define cmd_extend nob_cmd_extend
- #define cmd_free nob_cmd_free
- #define cmd_run_async nob_cmd_run_async
- #define cmd_run_async_and_reset nob_cmd_run_async_and_reset
- #define cmd_run_async_redirect nob_cmd_run_async_redirect
- #define cmd_run_async_redirect_and_reset nob_cmd_run_async_redirect_and_reset
- #define cmd_run_sync nob_cmd_run_sync
- #define cmd_run_sync_and_reset nob_cmd_run_sync_and_reset
- #define cmd_run_sync_redirect nob_cmd_run_sync_redirect
- #define cmd_run_sync_redirect_and_reset nob_cmd_run_sync_redirect_and_reset
- #define temp_strdup nob_temp_strdup
- #define temp_alloc nob_temp_alloc
- #define temp_sprintf nob_temp_sprintf
- #define temp_reset nob_temp_reset
- #define temp_save nob_temp_save
- #define temp_rewind nob_temp_rewind
- #define path_name nob_path_name
- #define rename nob_rename
- #define needs_rebuild nob_needs_rebuild
- #define needs_rebuild1 nob_needs_rebuild1
- #define file_exists nob_file_exists
- #define get_current_dir_temp nob_get_current_dir_temp
- #define set_current_dir nob_set_current_dir
- #define String_View Nob_String_View
- #define temp_sv_to_cstr nob_temp_sv_to_cstr
- #define sv_chop_by_delim nob_sv_chop_by_delim
- #define sv_trim nob_sv_trim
- #define sv_trim_left nob_sv_trim_left
- #define sv_trim_right nob_sv_trim_right
- #define sv_eq nob_sv_eq
- #define sv_end_with nob_sv_end_with
- #define sv_from_cstr nob_sv_from_cstr
- #define sv_from_parts nob_sv_from_parts
- #define sb_to_sv nob_sb_to_sv
- #define win32_error_message nob_win32_error_message
- #endif // NOB_STRIP_PREFIX
-#endif // NOB_STRIP_PREFIX_GUARD_
-
-/*
- Revision history:
-
- 1.9.0 (2024-11-06) Add Nob_Cmd_Redirect mechanism (By @rexim)
- Add nob_path_name() (By @0dminnimda)
- 1.8.0 (2024-11-03) Add nob_cmd_extend() (By @0dminnimda)
- 1.7.0 (2024-11-03) Add nob_win32_error_message and NOB_WIN32_ERR_MSG_SIZE (By @KillerxDBr)
- 1.6.0 (2024-10-27) Add nob_cmd_run_sync_and_reset()
- Add nob_sb_to_sv()
- Add nob_procs_wait_and_reset()
- 1.5.1 (2024-10-25) Include limits.h for Linux musl libc (by @pgalkin)
- 1.5.0 (2024-10-23) Add nob_get_current_dir_temp()
- Add nob_set_current_dir()
- 1.4.0 (2024-10-21) Fix UX issues with NOB_GO_REBUILD_URSELF on Windows when you call nob without the .exe extension (By @pgalkin)
- Add nob_sv_end_with (By @pgalkin)
- 1.3.2 (2024-10-21) Fix unreachable error in nob_log on passing NOB_NO_LOGS
- 1.3.1 (2024-10-21) Fix redeclaration error for minimal_log_level (By @KillerxDBr)
- 1.3.0 (2024-10-17) Add NOB_UNREACHABLE
- 1.2.2 (2024-10-16) Fix compilation of nob_cmd_run_sync_and_reset on Windows (By @KillerxDBr)
- 1.2.1 (2024-10-16) Add a separate include guard for NOB_STRIP_PREFIX.
- 1.2.0 (2024-10-15) Make NOB_DA_INIT_CAP redefinable
- Add NOB_STRIP_PREFIX which strips off nob_* prefix from all the user facing names
- Add NOB_UNUSED macro
- Add NOB_TODO macro
- Add nob_sv_trim_left and nob_sv_trim_right declarations to the header part
- 1.1.1 (2024-10-15) Remove forward declaration for is_path1_modified_after_path2
- 1.1.0 (2024-10-15) nob_minimal_log_level
- nob_cmd_run_sync_and_reset
- 1.0.0 (2024-10-15) first release based on https://github.com/tsoding/musializer/blob/4ac7cce9874bc19e02d8c160c8c6229de8919401/nob.h
-*/
-
-/*
- Version Conventions:
-
- We are following https://semver.org/ so the version has a format MAJOR.MINOR.PATCH:
- - Modifying comments does not update the version.
- - PATCH is incremented in case of a bug fix or refactoring without touching the API.
- - MINOR is incremented when new functions and/or types are added in a way that does
- not break any existing user code. We want to do this in the majority of the situation.
- If we want to delete a certain function or type in favor of another one we should
- just add the new function/type and deprecate the old one in a backward compatible way
- and let them co-exist for a while.
- - MAJOR update should be just a periodic cleanup of the deprecated functions and types
- without really modifying any existing functionality.
-
- Naming Conventions:
-
- - All the user facing names should be prefixed with `nob_` or `NOB_` depending on the case.
- - The prefixes of non-redefinable names should be strippable with NOB_STRIP_PREFIX (unless
- explicitly stated otherwise like in case of nob_log).
- - Internal functions should be prefixed with `nob__` (double underscore).
-*/
-
-/*
- ------------------------------------------------------------------------------
- This software is available under 2 licenses -- choose whichever you prefer.
- ------------------------------------------------------------------------------
- ALTERNATIVE A - MIT License
- Copyright (c) 2024 Alexey Kutepov
- Permission is hereby granted, free of charge, to any person obtaining a copy of
- this software and associated documentation files (the "Software"), to deal in
- the Software without restriction, including without limitation the rights to
- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is furnished to do
- so, subject to the following conditions:
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- ------------------------------------------------------------------------------
- ALTERNATIVE B - Public Domain (www.unlicense.org)
- This is free and unencumbered software released into the public domain.
- Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
- software, either in source code form or as a compiled binary, for any purpose,
- commercial or non-commercial, and by any means.
- In jurisdictions that recognize copyright laws, the author or authors of this
- software dedicate any and all copyright interest in the software to the public
- domain. We make this dedication for the benefit of the public at large and to
- the detriment of our heirs and successors. We intend this dedication to be an
- overt act of relinquishment in perpetuity of all present and future rights to
- this software under copyright law.
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- ------------------------------------------------------------------------------
-*/
projects / commonlib.git / commitdiff