summaryrefslogtreecommitdiffstats
path: root/src/b.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/b.h')
-rw-r--r--src/b.h860
1 files changed, 860 insertions, 0 deletions
diff --git a/src/b.h b/src/b.h
new file mode 100644
index 0000000..cdf6772
--- /dev/null
+++ b/src/b.h
@@ -0,0 +1,860 @@
+// This is an attempt on build library for building C with C akin to nob.h from
+// tsoding which is itself based on https://github.com/tsoding/nobuild
+//
+// 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.
+
+#ifndef B_H_
+#define B_H_
+
+#define B_ASSERT assert
+#define B_REALLOC realloc
+#define B_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 <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+#define B_ARRAY_LEN(array) (sizeof(array)/sizeof(array[0]))
+#define B_ARRAY_GET(array, index) \
+ (B_ASSERT(index >= 0), B_ASSERT(index < B_ARRAY_LEN(array)), array[index])
+
+typedef enum {
+ B_INFO,
+ B_WARNING,
+ B_ERROR,
+} B_Log_Level;
+
+void b_log(B_Log_Level level, const char *fmt, ...);
+
+// It is an equivalent of shift command from bash. It basically pops a command line
+// argument from the beginning.
+char *b_shift_args(int *argc, char ***argv);
+
+typedef struct {
+ const char **items;
+ size_t count;
+ size_t capacity;
+} B_File_Paths;
+
+typedef enum {
+ B_FILE_REGULAR = 0,
+ B_FILE_DIRECTORY,
+ B_FILE_SYMLINK,
+ B_FILE_OTHER,
+} B_File_Type;
+
+bool b_mkdir_if_not_exists(const char *path);
+bool b_copy_file(const char *src_path, const char *dst_path);
+bool b_copy_directory_recursively(const char *src_path, const char *dst_path);
+bool b_read_entire_dir(const char *parent, B_File_Paths *children);
+bool b_write_entire_file(const char *path, const void *data, size_t size);
+B_File_Type b_get_file_type(const char *path);
+
+#define b_return_defer(value) do { result = (value); goto defer; } while(0)
+
+// Initial capacity of a dynamic array
+#define B_DA_INIT_CAP 256
+
+// Append an item to a dynamic array
+#define b_da_append(da, item) \
+ do { \
+ if ((da)->count >= (da)->capacity) { \
+ (da)->capacity = (da)->capacity == 0 ? B_DA_INIT_CAP : (da)->capacity*2; \
+ (da)->items = B_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items)); \
+ B_ASSERT((da)->items != NULL && "Buy more RAM lol"); \
+ } \
+ \
+ (da)->items[(da)->count++] = (item); \
+ } while (0)
+
+#define b_da_free(da) B_FREE((da).items)
+
+// Append several items to a dynamic array
+#define b_da_append_many(da, new_items, new_items_count) \
+ do { \
+ if ((da)->count + (new_items_count) > (da)->capacity) { \
+ if ((da)->capacity == 0) { \
+ (da)->capacity = B_DA_INIT_CAP; \
+ } \
+ while ((da)->count + (new_items_count) > (da)->capacity) { \
+ (da)->capacity *= 2; \
+ } \
+ (da)->items = B_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items)); \
+ B_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;
+} B_String_Builder;
+
+bool b_read_entire_file(const char *path, B_String_Builder *sb);
+
+// Append a sized buffer to a string builder
+#define b_sb_append_buf(sb, buf, size) b_da_append_many(sb, buf, size)
+
+// Append a NULL-terminated string to a string builder
+#define b_sb_append_cstr(sb, cstr) \
+ do { \
+ const char *s = (cstr); \
+ size_t n = strlen(s); \
+ b_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 b_sb_append_null(sb) b_da_append_many(sb, "", 1)
+
+// Free the memory allocated by a string builder
+#define b_sb_free(sb) B_FREE((sb).items)
+
+// Process handle
+typedef int B_Proc;
+#define B_INVALID_PROC (-1)
+
+typedef struct {
+ B_Proc *items;
+ size_t count;
+ size_t capacity;
+} B_Procs;
+
+bool b_procs_wait(B_Procs procs);
+
+// Wait until the process has finished
+bool b_proc_wait(B_Proc proc);
+
+// A command - the main workhorse of B. B is all about building commands an running them
+typedef struct {
+ const char **items;
+ size_t count;
+ size_t capacity;
+} B_Cmd;
+
+// 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 b_sb_append_null if you plan to
+// use it as a C string.
+void b_cmd_render(B_Cmd cmd, B_String_Builder *render);
+
+#define b_cmd_append(cmd, ...) \
+ b_da_append_many(cmd, ((const char*[]){__VA_ARGS__}), (sizeof((const char*[]){__VA_ARGS__})/sizeof(const char*)))
+
+// Free all the memory allocated by command arguments
+#define b_cmd_free(cmd) B_FREE(cmd.items)
+
+// Run command asynchronously
+B_Proc b_cmd_run_async(B_Cmd cmd);
+
+// Run command synchronously
+bool b_cmd_run_sync(B_Cmd cmd);
+
+#ifndef B_TEMP_CAPACITY
+#define B_TEMP_CAPACITY (8*1024*1024)
+#endif // B_TEMP_CAPACITY
+char *b_temp_strdup(const char *cstr);
+void *b_temp_alloc(size_t size);
+char *b_temp_sprintf(const char *format, ...);
+void b_temp_reset(void);
+size_t b_temp_save(void);
+void b_temp_rewind(size_t checkpoint);
+
+int is_path1_modified_after_path2(const char *path1, const char *path2);
+bool b_rename(const char *old_path, const char *new_path);
+int b_needs_rebuild(const char *output_path, const char **input_paths, size_t input_paths_count);
+int b_needs_rebuild1(const char *output_path, const char *input_path);
+int b_file_exists(const char *file_path);
+
+// TODO: add MinGW support for Go Rebuild Urself™ Technology
+#ifndef B_REBUILD_URSELF
+# if _WIN32
+# if defined(__GNUC__)
+# define B_REBUILD_URSELF(binary_path, source_path) "gcc", "-o", binary_path, source_path
+# elif defined(__clang__)
+# define B_REBUILD_URSELF(binary_path, source_path) "clang", "-o", binary_path, source_path
+# elif defined(_MSC_VER)
+# define B_REBUILD_URSELF(binary_path, source_path) "cl.exe", b_temp_sprintf("/Fe:%s", (binary_path)), source_path
+# endif
+# else
+# if defined(__clang__)
+# define B_REBUILD_URSELF(binary_path, source_path) "clang", "-o", binary_path, source_path
+# else
+# define B_REBUILD_URSELF(binary_path, source_path) "cc", "-o", binary_path, source_path
+# endif
+# endif
+#endif
+
+// Go Rebuild Urself™ Technology
+//
+// How to use it:
+// int main(int argc, char** argv) {
+// GO_REBUILD_URSELF(argc, argv);
+// // actual work
+// return 0;
+// }
+//
+// After your added this macro every time you run ./build 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 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 build is to keep the process of bootstrapping
+// as simple as possible and doing all of the actual work inside of the build)
+//
+#define B_GO_REBUILD_URSELF(argc, argv) \
+ do { \
+ const char *source_path = __FILE__; \
+ assert(argc >= 1); \
+ const char *binary_path = argv[0]; \
+ \
+ int rebuild_is_needed = b_needs_rebuild(binary_path, &source_path, 1); \
+ if (rebuild_is_needed < 0) exit(1); \
+ if (rebuild_is_needed) { \
+ B_String_Builder sb = {0}; \
+ b_sb_append_cstr(&sb, binary_path); \
+ b_sb_append_cstr(&sb, ".old"); \
+ b_sb_append_null(&sb); \
+ \
+ if (!b_rename(binary_path, sb.items)) exit(1); \
+ B_Cmd rebuild = {0}; \
+ b_cmd_append(&rebuild, B_REBUILD_URSELF(binary_path, source_path)); \
+ bool rebuild_succeeded = b_cmd_run_sync(rebuild); \
+ b_cmd_free(rebuild); \
+ if (!rebuild_succeeded) { \
+ b_rename(sb.items, binary_path); \
+ exit(1); \
+ } \
+ \
+ B_Cmd cmd = {0}; \
+ b_da_append_many(&cmd, argv, argc); \
+ if (!b_cmd_run_sync(cmd)) exit(1); \
+ exit(0); \
+ } \
+ } while(0)
+// The implementation idea is stolen from https://github.com/zhiayang/nabs
+
+typedef struct {
+ size_t count;
+ const char *data;
+} B_String_View;
+
+const char *b_temp_sv_to_cstr(B_String_View sv);
+
+B_String_View b_sv_chop_by_delim(B_String_View *sv, char delim);
+B_String_View b_sv_trim(B_String_View sv);
+bool b_sv_eq(B_String_View a, B_String_View b);
+B_String_View b_sv_from_cstr(const char *cstr);
+B_String_View b_sv_from_parts(const char *data, size_t 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));
+
+#endif // B_H_
+
+#ifdef B_IMPLEMENTATION
+
+static size_t b_temp_size = 0;
+static char b_temp[B_TEMP_CAPACITY] = {0};
+
+bool b_mkdir_if_not_exists(const char *path)
+{
+ int result = mkdir(path, 0755);
+ if (result < 0) {
+ if (errno == EEXIST) {
+ b_log(B_INFO, "directory `%s` already exists", path);
+ return true;
+ }
+ b_log(B_ERROR, "could not create directory `%s`: %s", path, strerror(errno));
+ return false;
+ }
+
+ b_log(B_INFO, "created directory `%s`", path);
+ return true;
+}
+
+bool b_copy_file(const char *src_path, const char *dst_path)
+{
+ b_log(B_INFO, "copying %s -> %s", src_path, dst_path);
+
+ int src_fd = -1;
+ int dst_fd = -1;
+ size_t buf_size = 32*1024;
+ char *buf = B_REALLOC(NULL, buf_size);
+ B_ASSERT(buf != NULL && "Buy more RAM lol!!");
+ bool result = true;
+
+ src_fd = open(src_path, O_RDONLY);
+ if (src_fd < 0) {
+ b_log(B_ERROR, "Could not open file %s: %s", src_path, strerror(errno));
+ b_return_defer(false);
+ }
+
+ struct stat src_stat;
+ if (fstat(src_fd, &src_stat) < 0) {
+ b_log(B_ERROR, "Could not get mode of file %s: %s", src_path, strerror(errno));
+ b_return_defer(false);
+ }
+
+ dst_fd = open(dst_path, O_CREAT | O_TRUNC | O_WRONLY, src_stat.st_mode);
+ if (dst_fd < 0) {
+ b_log(B_ERROR, "Could not create file %s: %s", dst_path, strerror(errno));
+ b_return_defer(false);
+ }
+
+ for (;;) {
+ ssize_t n = read(src_fd, buf, buf_size);
+ if (n == 0) break;
+ if (n < 0) {
+ b_log(B_ERROR, "Could not read from file %s: %s", src_path, strerror(errno));
+ b_return_defer(false);
+ }
+ char *buf2 = buf;
+ while (n > 0) {
+ ssize_t m = write(dst_fd, buf2, n);
+ if (m < 0) {
+ b_log(B_ERROR, "Could not write to file %s: %s", dst_path, strerror(errno));
+ b_return_defer(false);
+ }
+ n -= m;
+ buf2 += m;
+ }
+ }
+
+defer:
+ free(buf);
+ close(src_fd);
+ close(dst_fd);
+ return result;
+}
+
+void b_cmd_render(B_Cmd cmd, B_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) b_sb_append_cstr(render, " ");
+ if (!strchr(arg, ' ')) {
+ b_sb_append_cstr(render, arg);
+ } else {
+ b_da_append(render, '\'');
+ b_sb_append_cstr(render, arg);
+ b_da_append(render, '\'');
+ }
+ }
+}
+
+B_Proc b_cmd_run_async(B_Cmd cmd)
+{
+ if (cmd.count < 1) {
+ b_log(B_ERROR, "Could not run empty command");
+ return B_INVALID_PROC;
+ }
+
+ B_String_Builder sb = {0};
+ b_cmd_render(cmd, &sb);
+ b_sb_append_null(&sb);
+ b_log(B_INFO, "CMD: %s", sb.items);
+ b_sb_free(sb);
+ memset(&sb, 0, sizeof(sb));
+
+ pid_t cpid = fork();
+ if (cpid < 0) {
+ b_log(B_ERROR, "Could not fork child process: %s", strerror(errno));
+ return B_INVALID_PROC;
+ }
+
+ if (cpid == 0) {
+ // NOTE: This leaks a bit of memory in the child process.
+ // But do we actually care? It's a one off leak anyway...
+ B_Cmd cmd_null = {0};
+ b_da_append_many(&cmd_null, cmd.items, cmd.count);
+ b_cmd_append(&cmd_null, NULL);
+
+ if (execvp(cmd.items[0], (char * const*) cmd_null.items) < 0) {
+ b_log(B_ERROR, "Could not exec child process: %s", strerror(errno));
+ exit(1);
+ }
+ B_ASSERT(0 && "unreachable");
+ }
+
+ return cpid;
+}
+
+bool b_procs_wait(B_Procs procs)
+{
+ bool success = true;
+ for (size_t i = 0; i < procs.count; ++i) {
+ success = b_proc_wait(procs.items[i]) && success;
+ }
+ return success;
+}
+
+bool b_proc_wait(B_Proc proc)
+{
+ if (proc == B_INVALID_PROC) return false;
+
+ for (;;) {
+ int wstatus = 0;
+ if (waitpid(proc, &wstatus, 0) < 0) {
+ b_log(B_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) {
+ b_log(B_ERROR, "command exited with exit code %d", exit_status);
+ return false;
+ }
+
+ break;
+ }
+
+ if (WIFSIGNALED(wstatus)) {
+ b_log(B_ERROR, "command process was terminated by %s", strsignal(WTERMSIG(wstatus)));
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool b_cmd_run_sync(B_Cmd cmd)
+{
+ B_Proc p = b_cmd_run_async(cmd);
+ if (p == B_INVALID_PROC) return false;
+ return b_proc_wait(p);
+}
+
+char *b_shift_args(int *argc, char ***argv)
+{
+ B_ASSERT(*argc > 0);
+ char *result = **argv;
+ (*argv) += 1;
+ (*argc) -= 1;
+ return result;
+}
+
+void b_log(B_Log_Level level, const char *fmt, ...)
+{
+ switch (level) {
+ case B_INFO:
+ fprintf(stderr, "[INFO] ");
+ break;
+ case B_WARNING:
+ fprintf(stderr, "[WARNING] ");
+ break;
+ case B_ERROR:
+ fprintf(stderr, "[ERROR] ");
+ break;
+ default:
+ B_ASSERT(0 && "unreachable");
+ }
+
+ va_list args;
+ va_start(args, fmt);
+ vfprintf(stderr, fmt, args);
+ va_end(args);
+ fprintf(stderr, "\n");
+}
+
+bool b_read_entire_dir(const char *parent, B_File_Paths *children)
+{
+ bool result = true;
+ DIR *dir = NULL;
+
+ dir = opendir(parent);
+ if (dir == NULL) {
+ b_log(B_ERROR, "Could not open directory %s: %s", parent, strerror(errno));
+ b_return_defer(false);
+ }
+
+ errno = 0;
+ struct dirent *ent = readdir(dir);
+ while (ent != NULL) {
+ b_da_append(children, b_temp_strdup(ent->d_name));
+ ent = readdir(dir);
+ }
+
+ if (errno != 0) {
+ b_log(B_ERROR, "Could not read directory %s: %s", parent, strerror(errno));
+ b_return_defer(false);
+ }
+
+defer:
+ if (dir) closedir(dir);
+ return result;
+}
+
+bool b_write_entire_file(const char *path, const void *data, size_t size)
+{
+ bool result = true;
+
+ FILE *f = fopen(path, "wb");
+ if (f == NULL) {
+ b_log(B_ERROR, "Could not open file %s for writing: %s\n", path, strerror(errno));
+ b_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)) {
+ b_log(B_ERROR, "Could not write into file %s: %s\n", path, strerror(errno));
+ b_return_defer(false);
+ }
+ size -= n;
+ buf += n;
+ }
+
+defer:
+ if (f) fclose(f);
+ return result;
+}
+
+B_File_Type b_get_file_type(const char *path)
+{
+ struct stat statbuf;
+ if (stat(path, &statbuf) < 0) {
+ b_log(B_ERROR, "Could not get stat of %s: %s", path, strerror(errno));
+ return -1;
+ }
+
+ switch (statbuf.st_mode & S_IFMT) {
+ case S_IFDIR: return B_FILE_DIRECTORY;
+ case S_IFREG: return B_FILE_REGULAR;
+ case S_IFLNK: return B_FILE_SYMLINK;
+ default: return B_FILE_OTHER;
+ }
+}
+
+bool b_copy_directory_recursively(const char *src_path, const char *dst_path)
+{
+ bool result = true;
+ B_File_Paths children = {0};
+ B_String_Builder src_sb = {0};
+ B_String_Builder dst_sb = {0};
+ size_t temp_checkpoint = b_temp_save();
+
+ B_File_Type type = b_get_file_type(src_path);
+ if (type < 0) return false;
+
+ switch (type) {
+ case B_FILE_DIRECTORY: {
+ if (!b_mkdir_if_not_exists(dst_path)) b_return_defer(false);
+ if (!b_read_entire_dir(src_path, &children)) b_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;
+ b_sb_append_cstr(&src_sb, src_path);
+ b_sb_append_cstr(&src_sb, "/");
+ b_sb_append_cstr(&src_sb, children.items[i]);
+ b_sb_append_null(&src_sb);
+
+ dst_sb.count = 0;
+ b_sb_append_cstr(&dst_sb, dst_path);
+ b_sb_append_cstr(&dst_sb, "/");
+ b_sb_append_cstr(&dst_sb, children.items[i]);
+ b_sb_append_null(&dst_sb);
+
+ if (!b_copy_directory_recursively(src_sb.items, dst_sb.items)) {
+ b_return_defer(false);
+ }
+ }
+ } break;
+
+ case B_FILE_REGULAR: {
+ if (!b_copy_file(src_path, dst_path)) {
+ b_return_defer(false);
+ }
+ } break;
+
+ case B_FILE_SYMLINK: {
+ b_log(B_WARNING, "TODO: Copying symlinks is not supported yet");
+ } break;
+
+ case B_FILE_OTHER: {
+ b_log(B_ERROR, "Unsupported type of file %s", src_path);
+ b_return_defer(false);
+ } break;
+
+ default: B_ASSERT(0 && "unreachable");
+ }
+
+defer:
+ b_temp_rewind(temp_checkpoint);
+ b_da_free(src_sb);
+ b_da_free(dst_sb);
+ b_da_free(children);
+ return result;
+}
+
+char *b_temp_strdup(const char *cstr)
+{
+ size_t n = strlen(cstr);
+ char *result = b_temp_alloc(n + 1);
+ B_ASSERT(result != NULL && "Increase B_TEMP_CAPACITY");
+ memcpy(result, cstr, n);
+ result[n] = '\0';
+ return result;
+}
+
+void *b_temp_alloc(size_t size)
+{
+ if (b_temp_size + size > B_TEMP_CAPACITY) return NULL;
+ void *result = &b_temp[b_temp_size];
+ b_temp_size += size;
+ return result;
+}
+
+char *b_temp_sprintf(const char *format, ...)
+{
+ va_list args;
+ va_start(args, format);
+ int n = vsnprintf(NULL, 0, format, args);
+ va_end(args);
+
+ B_ASSERT(n >= 0);
+ char *result = b_temp_alloc(n + 1);
+ B_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 b_temp_reset(void)
+{
+ b_temp_size = 0;
+}
+
+size_t b_temp_save(void)
+{
+ return b_temp_size;
+}
+
+void b_temp_rewind(size_t checkpoint)
+{
+ b_temp_size = checkpoint;
+}
+
+const char *b_temp_sv_to_cstr(B_String_View sv)
+{
+ char *result = b_temp_alloc(sv.count + 1);
+ B_ASSERT(result != NULL && "Extend the size of the temporary allocator");
+ memcpy(result, sv.data, sv.count);
+ result[sv.count] = '\0';
+ return result;
+}
+
+int b_needs_rebuild(const char *output_path, const char **input_paths, size_t input_paths_count)
+{
+ 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;
+ b_log(B_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
+ b_log(B_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;
+}
+
+int b_needs_rebuild1(const char *output_path, const char *input_path)
+{
+ return b_needs_rebuild(output_path, &input_path, 1);
+}
+
+bool b_rename(const char *old_path, const char *new_path)
+{
+ b_log(B_INFO, "renaming %s -> %s", old_path, new_path);
+ if (rename(old_path, new_path) < 0) {
+ b_log(B_ERROR, "could not rename %s to %s: %s", old_path, new_path, strerror(errno));
+ return false;
+ }
+ return true;
+}
+
+bool b_read_entire_file(const char *path, B_String_Builder *sb)
+{
+ bool result = true;
+
+ FILE *f = fopen(path, "rb");
+ if (f == NULL) b_return_defer(false);
+ if (fseek(f, 0, SEEK_END) < 0) b_return_defer(false);
+ long m = ftell(f);
+ if (m < 0) b_return_defer(false);
+ if (fseek(f, 0, SEEK_SET) < 0) b_return_defer(false);
+
+ size_t new_count = sb->count + m;
+ if (new_count > sb->capacity) {
+ sb->items = realloc(sb->items, new_count);
+ B_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.
+ b_return_defer(false);
+ }
+ sb->count = new_count;
+
+defer:
+ if (!result) b_log(B_ERROR, "Could not read file %s: %s", path, strerror(errno));
+ if (f) fclose(f);
+ return result;
+}
+
+B_String_View b_sv_chop_by_delim(B_String_View *sv, char delim)
+{
+ size_t i = 0;
+ while (i < sv->count && sv->data[i] != delim) {
+ i += 1;
+ }
+
+ B_String_View result = b_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;
+}
+
+B_String_View b_sv_from_parts(const char *data, size_t count)
+{
+ B_String_View sv;
+ sv.count = count;
+ sv.data = data;
+ return sv;
+}
+
+B_String_View b_sv_trim_left(B_String_View sv)
+{
+ size_t i = 0;
+ while (i < sv.count && isspace(sv.data[i])) {
+ i += 1;
+ }
+
+ return b_sv_from_parts(sv.data + i, sv.count - i);
+}
+
+B_String_View b_sv_trim_right(B_String_View sv)
+{
+ size_t i = 0;
+ while (i < sv.count && isspace(sv.data[sv.count - 1 - i])) {
+ i += 1;
+ }
+
+ return b_sv_from_parts(sv.data, sv.count - i);
+}
+
+B_String_View b_sv_trim(B_String_View sv)
+{
+ return b_sv_trim_right(b_sv_trim_left(sv));
+}
+
+B_String_View b_sv_from_cstr(const char *cstr)
+{
+ return b_sv_from_parts(cstr, strlen(cstr));
+}
+
+bool b_sv_eq(B_String_View a, B_String_View b)
+{
+ if (a.count != b.count) {
+ return false;
+ } else {
+ return memcmp(a.data, b.data, a.count) == 0;
+ }
+}
+
+// RETURNS:
+// 0 - file does not exists
+// 1 - file exists
+// -1 - error while checking if file exists. The error is logged
+int b_file_exists(const char *file_path)
+{
+ struct stat statbuf;
+ if (stat(file_path, &statbuf) < 0) {
+ if (errno == ENOENT) return 0;
+ b_log(B_ERROR, "Could not check if file %s exists: %s", file_path, strerror(errno));
+ return -1;
+ }
+ return 1;
+}
+
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 20:55:49 +0000