diff options
Diffstat (limited to 'src/lib/stb_cbuild.h')
| -rw-r--r-- | src/lib/stb_cbuild.h | 1368 |
1 files changed, 1368 insertions, 0 deletions
diff --git a/src/lib/stb_cbuild.h b/src/lib/stb_cbuild.h new file mode 100644 index 0000000..3714437 --- /dev/null +++ b/src/lib/stb_cbuild.h @@ -0,0 +1,1368 @@ +#ifndef _STB_CB_H +#define _STB_CB_H +#include <openssl/md5.h> // Requires OpenSSL +#include <stdarg.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +//============================= arglist.h +//======================================= +typedef struct { + char **list; + int count; + int capacity; +} CB_ARGLIST; + +static inline CB_ARGLIST *arglist_new(); +static inline void arglist_append(CB_ARGLIST *arglist, ...); // sentinel: NULL +static inline void arglist_append_array(CB_ARGLIST *arglist, const char **arr); +static inline void arglist_free(CB_ARGLIST *arglist); + +//============================= platform & macros +//=============================== +#if defined(_WIN32) +#define OS_WIN 1 +#include <process.h> +#include <windows.h> +#else +#define OS_UNIX 1 +#include <sys/wait.h> +#include <unistd.h> +#endif + +#if defined(__APPLE__) +#define OS_MACOS 1 +#endif + +#ifdef CB_DEBUG +#define CB_DEBUG_LOG(fmt, ...) \ + fprintf(stderr, "\x1b[36m[DEBUG] %s:%d: " fmt "\x1b[0m\n", __FILE__, \ + __LINE__, ##__VA_ARGS__) +#else +#define CB_DEBUG_LOG(fmt, ...) +#endif + +#if OS_UNIX +#include <ctype.h> +#include <errno.h> +#include <glob.h> +#include <limits.h> +#include <sys/types.h> +#endif + +// Allow override by macro or environment +#ifndef CB_COMPILER +#if OS_WIN +#define COMPILER_NAME_DEFAULT "cl" +#elif defined(OS_MACOS) +#define COMPILER_NAME_DEFAULT "clang" +#else +#define COMPILER_NAME_DEFAULT "cc" +#endif +#else +#define COMPILER_NAME_DEFAULT CB_COMPILER +#endif + +#define COLOR_RESET "\x1b[0m" +#define COLOR_RED "\x1b[31m" +#define COLOR_GREEN "\x1b[32m" +#define COLOR_YELLOW "\x1b[33m" +#define COLOR_CYAN "\x1b[36m" + +typedef enum { BUILD_EXEC, BUILD_STATIC, BUILD_SHARED } _CB_BUILD_TYPE; + +typedef struct _CB_PROJECT { + char *name; + char *output; + CB_ARGLIST *files; // may contain wildcard patterns; expanded before build + CB_ARGLIST *buildflags; + CB_ARGLIST *flags; + char *compile_command; + int is_rebuild; + _CB_BUILD_TYPE build_type; + int CB_PYTHON; +} _CB_PROJECT; + +typedef struct { + _CB_PROJECT **projects; + int run; // run produced outputs? + int run_if_skipped; // run even if build skipped (cache hit) + int parallel_build; // NEW: number of parallel build jobs + int parallel_run; // NEW: number of parallel run jobs + int parallel; // DEPRECATED: kept for back-compat; treated as parallel_run if + // >0 +} CB_PROJECT_BUILD_CONFIG; + +#define CB_STRLIST(...) ((const char *[]){__VA_ARGS__, NULL}) +#define CB_PROJECT_LIST(...) ((_CB_PROJECT *[]){__VA_ARGS__, NULL}) + +#define _CB_CREATE_PROJECT(var, ...) \ + _CB_PROJECT *var = (_CB_PROJECT *)malloc(sizeof(_CB_PROJECT)); \ + if (!(var)) { \ + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); \ + exit(1); \ + } \ + memset(var, 0, sizeof(_CB_PROJECT)); \ + struct { \ + char *name; \ + char *output; \ + const char **files; \ + const char **buildflags; \ + const char **flags; \ + int is_rebuild; \ + _CB_BUILD_TYPE build_type; \ + int CB_PYTHON; \ + } var##_init = {__VA_ARGS__}; \ + var->name = var##_init.name; \ + var->output = var##_init.output; \ + var->files = arglist_new(); \ + var->buildflags = arglist_new(); \ + var->flags = arglist_new(); \ + var->is_rebuild = var##_init.is_rebuild; \ + var->build_type = var##_init.build_type; \ + var->CB_PYTHON = var##_init.CB_PYTHON; \ + if (var##_init.files) \ + arglist_append_array(var->files, var##_init.files); \ + if (var##_init.buildflags) \ + arglist_append_array(var->buildflags, var##_init.buildflags); \ + if (var##_init.flags) \ + arglist_append_array(var->flags, var##_init.flags) + +#define CB_NEEDED_LIBS "-lssl -lcrypto" + +// — forward decls — +static char *cb_concat_compile_command(_CB_PROJECT *proj); +#define _CB_BUILD_COMPILE_COMMAND(proj) \ + do { \ + if ((proj)->compile_command) { \ + free((proj)->compile_command); \ + } \ + (proj)->compile_command = cb_concat_compile_command(proj); \ + } while (0) + +static void cb_dump_to_console(const _CB_PROJECT *project); +static void cb_free_project(_CB_PROJECT *project); +static char *cb_compute_md5(const char *data, size_t len); +static char *cb_read_file_content(const char *filepath, size_t *out_len); +static char *cb_compute_project_checksum(_CB_PROJECT *proj); +static char *cb_read_checksum(const char *filename); +static int cb_write_checksum(const char *filename, const char *checksum); +static void cb_expand_project_wildcards(_CB_PROJECT *proj); // NEW + +typedef struct { +#if OS_WIN + PROCESS_INFORMATION pi; +#else + pid_t pid; +#endif + int running; + _CB_PROJECT *project; + int is_build; +} proc_t; + +static int proc_start_run(proc_t *proc, _CB_PROJECT *proj, char **argv); +static int proc_start_build_cmd(proc_t *proc, _CB_PROJECT *proj, + const char *cmdline); +static int proc_poll(proc_t *proc); +static void proc_wait_all(proc_t *procs, int count); + +#define _CB_PROJECT_BUILD(...) \ + _cb_project_build_internal((CB_PROJECT_BUILD_CONFIG){__VA_ARGS__}) +static void _cb_project_build_internal(CB_PROJECT_BUILD_CONFIG config); + +#define _CB_IMPLEMENTATION +//============================= implementation +//================================== +#ifdef _CB_IMPLEMENTATION + +//---------- small utils ---------- +static char *cb_strdup(const char *s) { + if (!s) + return NULL; + size_t n = strlen(s) + 1; + char *p = (char *)malloc(n); + if (!p) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + exit(1); + } + memcpy(p, s, n); + return p; +} +static void *cb_realloc(void *p, size_t sz) { + void *q = realloc(p, sz); + if (!q) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + exit(1); + } + return q; +} +static int cb_str_has_wildcards(const char *s) { + if (!s) + return 0; + for (; *s; ++s) { + if (*s == '*' || *s == '?' || *s == '[') + return 1; +#if OS_WIN + // Windows doesn't support [...] in FindFirstFile, but treat it as pattern + // anyway +#endif + } + return 0; +} + +// Growable string builder append +static void cb_strcatf(char **dst, size_t *cap, size_t *len, const char *fmt, + ...) { + va_list ap; + for (;;) { + va_start(ap, fmt); + int need = vsnprintf((*dst) ? *dst + *len : NULL, (*dst) ? *cap - *len : 0, + fmt, ap); + va_end(ap); + if (need < 0) { // encoding error + return; + } + size_t req = (size_t)need; + if ((*dst) && *len + req < *cap) { + *len += req; + return; + } + size_t newcap = (*cap ? *cap : 64); + while (newcap <= *len + req) + newcap *= 2; + *dst = (char *)cb_realloc(*dst, newcap); + if (*cap == 0) { + (*dst)[0] = '\0'; + } + *cap = newcap; + } +} + +//---------- arglist ---------- +static inline CB_ARGLIST *arglist_new() { + CB_ARGLIST *a = (CB_ARGLIST *)malloc(sizeof(CB_ARGLIST)); + if (!a) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + exit(1); + } + a->count = 0; + a->capacity = 8; + a->list = (char **)malloc(sizeof(char *) * a->capacity); + if (!a->list) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + exit(1); + } + return a; +} +static void arglist__ensure(CB_ARGLIST *a, int need) { + if (a->count + need <= a->capacity) + return; + while (a->count + need > a->capacity) + a->capacity *= 2; + a->list = (char **)cb_realloc(a->list, sizeof(char *) * a->capacity); +} +static inline void arglist_append(CB_ARGLIST *arglist, ...) { + if (!arglist) + return; + va_list args; + va_start(args, arglist); + for (;;) { + char *arg = va_arg(args, char *); + if (!arg) + break; + arglist__ensure(arglist, 1); + arglist->list[arglist->count++] = cb_strdup(arg); + } + va_end(args); +} +static inline void arglist_append_array(CB_ARGLIST *arglist, const char **arr) { + if (!arglist || !arr) + return; + for (int i = 0; arr[i] != NULL; i++) { + arglist_append(arglist, arr[i], NULL); + } +} +static inline void arglist_free(CB_ARGLIST *arglist) { + if (!arglist) + return; + for (int i = 0; i < arglist->count; i++) + free(arglist->list[i]); + free(arglist->list); + free(arglist); +} + +//---------- compiler selection ---------- +static const char *cb_pick_compiler_name(void) { + const char *env = getenv("CB_CC"); + if (env && env[0]) + return env; + return COMPILER_NAME_DEFAULT; +} + +//---------- wildcard expansion ---------- +static void cb_files_add(CB_ARGLIST *files, const char *s) { + arglist_append(files, s, NULL); +} + +#if OS_WIN +static void cb_expand_pattern_win(CB_ARGLIST *out, const char *pattern) { + // Split directory part to preserve prefix + char dir[MAX_PATH]; + const char *slash = strrchr(pattern, '\\'); + const char *slash2 = strrchr(pattern, '/'); + const char *cut = slash ? slash : slash2; + size_t dlen = 0; + if (cut) { + dlen = (size_t)(cut - pattern + 1); + if (dlen >= sizeof(dir)) + dlen = sizeof(dir) - 1; + memcpy(dir, pattern, dlen); + dir[dlen] = '\0'; + } else { + dir[0] = '\0'; + } + + WIN32_FIND_DATAA fd; + HANDLE h = FindFirstFileA(pattern, &fd); + if (h == INVALID_HANDLE_VALUE) { + // no match: keep literal to let compiler report it + cb_files_add(out, pattern); + return; + } + do { + if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { + char path[MAX_PATH * 2]; + snprintf(path, sizeof(path), "%s%s", dir, fd.cFileName); + cb_files_add(out, path); + } + } while (FindNextFileA(h, &fd)); + FindClose(h); +} +#else +static void cb_expand_pattern_unix(CB_ARGLIST *out, const char *pattern) { + glob_t gl; + memset(&gl, 0, sizeof(gl)); + int r = glob(pattern, GLOB_TILDE, NULL, &gl); + if (r == 0) { + for (size_t i = 0; i < gl.gl_pathc; i++) { + cb_files_add(out, gl.gl_pathv[i]); + } + globfree(&gl); + return; + } + // No matches or error — keep as literal so the compiler can error out if + // needed. + cb_files_add(out, pattern); +} +#endif + +static void cb_expand_project_wildcards(_CB_PROJECT *proj) { + if (!proj || !proj->files) + return; + CB_ARGLIST *expanded = arglist_new(); + for (int i = 0; i < proj->files->count; i++) { + const char *f = proj->files->list[i]; + if (cb_str_has_wildcards(f)) { +#if OS_WIN + cb_expand_pattern_win(expanded, f); +#else + cb_expand_pattern_unix(expanded, f); +#endif + } else { + cb_files_add(expanded, f); + } + } + // swap lists + arglist_free(proj->files); + proj->files = expanded; + CB_DEBUG_LOG("Wildcard expansion for %s produced %d file(s)", proj->name, + proj->files->count); +} + +#ifdef _CB_PY + +#include "cb_py.h" + + + +typedef struct { + const char *name; + + char *file_data; + int file_size; + + char ***code_blocks; + int code_block_count; + int *code_block_sizes; + int *code_block_starts; + +} _CB_PROJECT_TRANSPILE; + +static void _cb_project_transpile_free(_CB_PROJECT_TRANSPILE *transpile) { + for (int i = 0; i < transpile->code_block_count; i++) { + for (int j = 0; j < transpile->code_block_sizes[i]; j++) { + free(transpile->code_blocks[i][j]); // free each line + } + free(transpile->code_blocks[i]); // free line array + } + free(transpile->code_blocks); + free(transpile->code_block_sizes); + free(transpile->code_block_starts); + free(transpile->file_data); + free(transpile); +} + +static void _cb_project_transpile_append(_CB_PROJECT_TRANSPILE *transpile, + char **code_block, int code_block_size, + int start_line) { + transpile->code_blocks = + (char ***)realloc(transpile->code_blocks, + (transpile->code_block_count + 1) * sizeof(char **)); + transpile->code_block_sizes = + (int *)realloc(transpile->code_block_sizes, + (transpile->code_block_count + 1) * sizeof(int)); + transpile->code_block_starts = + (int *)realloc(transpile->code_block_starts, + (transpile->code_block_count + 1) * sizeof(int)); + + transpile->code_blocks[transpile->code_block_count] = code_block; + transpile->code_block_sizes[transpile->code_block_count] = code_block_size; + transpile->code_block_starts[transpile->code_block_count] = start_line; + transpile->code_block_count++; + + // Debug print + CB_DEBUG_LOG("Captured code block #%d starting at line %d (%d lines):", + transpile->code_block_count, start_line, code_block_size); +} + +static char *cb_strip_comment_prefix(const char *line) { + const char *p = line; + while (*p == ' ' || *p == '\t') + p++; + + if (p[0] == '/' && p[1] == '/') { + p += 2; + if (*p == ' ') + p++; + } + + return strdup(p); // return cleaned line +} +static int _py_to_c99(_CB_PROJECT *proj) { + for (int i = 0; i < proj->files->count; i++) { + const char *f = proj->files->list[i]; + FILE *fp = fopen(f, "r"); + if (!fp) { + CB_DEBUG_LOG("Failed to open file %s", f); + return -1; + } + + // read file into memory + fseek(fp, 0, SEEK_END); + int file_size = ftell(fp); + fseek(fp, 0, SEEK_SET); + char *file_data = (char *)malloc(file_size + 1); + if (!file_data) { + CB_DEBUG_LOG("Failed to allocate memory for file %s", f); + fclose(fp); + return -1; + } + fread(file_data, 1, file_size, fp); + file_data[file_size] = '\0'; + fclose(fp); + + // split into lines + int line_count = 0; + char **lines = NULL; + char *saveptr; + char *tok = strtok_r(file_data, "\n", &saveptr); + while (tok) { + lines = (char **)realloc(lines, (line_count + 1) * sizeof(char *)); + lines[line_count++] = strdup(tok); + tok = strtok_r(NULL, "\n", &saveptr); + } + + // process file: detect blocks + int in_block = 0; + char **current_block = NULL; + int current_size = 0; + int start_line = 0; + + // new file buffer (lines replaced) + char **new_lines = NULL; + int new_count = 0; + + for (int j = 0; j < line_count; j++) { + const char *line = lines[j]; + if (!in_block && strstr(line, "__CB_PY_BEGIN")) { + in_block = 1; + start_line = j; + // keep a marker comment in output + new_lines = + (char **)realloc(new_lines, (new_count + 1) * sizeof(char *)); + new_lines[new_count++] = strdup("// transpiled block begin"); + continue; + } + + if (in_block && strstr(line, "__CB_PY_END")) { + in_block = 0; + + CB_DEBUG_LOG("Captured code block #%d starting at line %d (%d lines):", + new_count, start_line, current_size); + for (int k = 0; k < current_size; k++) { + CB_DEBUG_LOG(" %s", current_block[k]); + } + // transpile captured block + int out_size = 0; + char **c_lines = + transpile_py_block(current_block, current_size, &out_size); + + for (int k = 0; k < out_size; k++) { + new_lines = + (char **)realloc(new_lines, (new_count + 1) * sizeof(char *)); + new_lines[new_count++] = c_lines[k]; // already malloc’d + } + + // cleanup block + for (int k = 0; k < current_size; k++) + free(current_block[k]); + free(current_block); + current_block = NULL; + current_size = 0; + + new_lines = + (char **)realloc(new_lines, (new_count + 1) * sizeof(char *)); + new_lines[new_count++] = strdup("// transpiled block end"); + continue; + } + + if (in_block) { + // capture block lines (strip // prefix) + current_block = (char **)realloc(current_block, + (current_size + 1) * sizeof(char *)); + current_block[current_size++] = cb_strip_comment_prefix(line); + } else { + // just copy normal line + new_lines = + (char **)realloc(new_lines, (new_count + 1) * sizeof(char *)); + new_lines[new_count++] = strdup(line); + } + } + + // write file back + fp = fopen(f, "w"); + if (!fp) { + CB_DEBUG_LOG("Failed to write file %s", f); + return -1; + } + for (int j = 0; j < new_count; j++) { + fprintf(fp, "%s\n", new_lines[j]); + free(new_lines[j]); + } + fclose(fp); + + // cleanup + for (int j = 0; j < line_count; j++) + free(lines[j]); + free(lines); + free(new_lines); + free(file_data); + + CB_DEBUG_LOG("Transpiled %s", f); + } + return 0; +} + +#define _CB_PYTHON_TRANSPILE(proj) int ret = _py_to_c99(proj) + +#endif // _CB_PY +//---------- compile command ---------- +static char *cb_concat_compile_command(_CB_PROJECT *proj) { + if (!proj || !proj->files || proj->files->count == 0) + return cb_strdup("[error] No source files"); + +#ifdef _CB_PY + if (proj->CB_PYTHON) { + CB_DEBUG_LOG("Project is set to have _PY() blocks: %s", proj->output); + CB_DEBUG_LOG("Will try to transpile into c99."); + _CB_PYTHON_TRANSPILE(proj); + if (ret != 0) { + return cb_strdup("[error] Failed to transpile project"); + } + CB_DEBUG_LOG("Transpilation successful for %s.", proj->output); + } +#endif // _CB_PY + const char *cc = cb_pick_compiler_name(); + char *cmd = NULL; + size_t cap = 0, len = 0; + +#if OS_WIN + switch (proj->build_type) { + case BUILD_EXEC: + cb_strcatf(&cmd, &cap, &len, "%s", cc); + break; + case BUILD_STATIC: + // compile to .obj files + for (int i = 0; i < proj->files->count; i++) + cb_strcatf(&cmd, &cap, &len, "%s /c %s && ", cc, proj->files->list[i]); + cb_strcatf(&cmd, &cap, &len, "lib /OUT:%s", proj->output); + return cmd; + case BUILD_SHARED: + cb_strcatf(&cmd, &cap, &len, "%s /LD", cc); + break; + } +#else // Unix + switch (proj->build_type) { + case BUILD_EXEC: + cb_strcatf(&cmd, &cap, &len, "%s", cc); + break; + case BUILD_STATIC: + // compile all to .o then archive + for (int i = 0; i < proj->files->count; i++) + cb_strcatf(&cmd, &cap, &len, "%s -c %s && ", cc, proj->files->list[i]); + cb_strcatf(&cmd, &cap, &len, "ar rcs %s *.o", proj->output); + return cmd; + case BUILD_SHARED: + cb_strcatf(&cmd, &cap, &len, "%s -fPIC -shared", cc); + break; + } +#endif + + // Common flags + for (int i = 0; i < proj->buildflags->count; i++) + cb_strcatf(&cmd, &cap, &len, " %s", proj->buildflags->list[i]); + + if (proj->is_rebuild) + cb_strcatf(&cmd, &cap, &len, " %s", CB_NEEDED_LIBS); + + // Add sources + for (int i = 0; i < proj->files->count; i++) + cb_strcatf(&cmd, &cap, &len, " %s", proj->files->list[i]); + + // Output handling + if (proj->output) { +#if OS_WIN + if (proj->build_type == BUILD_EXEC) + cb_strcatf(&cmd, &cap, &len, " /Fe%s", proj->output); + else if (proj->build_type == BUILD_SHARED) + cb_strcatf(&cmd, &cap, &len, " /Fe%s", proj->output); +#else + if (proj->build_type == BUILD_EXEC) + cb_strcatf(&cmd, &cap, &len, " -o %s", proj->output); + else if (proj->build_type == BUILD_SHARED) + cb_strcatf(&cmd, &cap, &len, " -o %s", proj->output); +#endif + } + + CB_DEBUG_LOG("Generated compile command: %s", cmd); + return cmd; +} + +//---------- info & free ---------- +static void _cb_project_dump(_CB_PROJECT *proj) { + if (!proj) + return; + + printf("== Project Dump ==\n"); + printf("Name: %s\n", proj->name ? proj->name : "(unnamed)"); + printf("Output: %s\n", proj->output ? proj->output : "(none)"); + + // Build type + const char *type_str = "EXEC"; + if (proj->build_type == BUILD_STATIC) + type_str = "STATIC"; + else if (proj->build_type == BUILD_SHARED) + type_str = "SHARED"; + printf("Build type: %s\n", type_str); + + // Files + printf("Files (%d):\n", proj->files ? proj->files->count : 0); + if (proj->files) + for (int i = 0; i < proj->files->count; i++) + printf(" %s\n", proj->files->list[i]); + + // Build Flags + printf("Build flags (%d):\n", proj->buildflags ? proj->buildflags->count : 0); + if (proj->buildflags) + for (int i = 0; i < proj->buildflags->count; i++) + printf(" %s\n", proj->buildflags->list[i]); + + // Flags + printf("Flags (%d):\n", proj->flags ? proj->flags->count : 0); + if (proj->flags) + for (int i = 0; i < proj->flags->count; i++) + printf(" %s\n", proj->flags->list[i]); + + // Command + printf("Compile command: %s\n", + proj->compile_command ? proj->compile_command : "(none)"); +} + +static void cb_free_project(_CB_PROJECT *project) { + if (!project) + return; + if (project->files) + arglist_free(project->files); + if (project->buildflags) + arglist_free(project->buildflags); + if (project->flags) + arglist_free(project->flags); + if (project->compile_command) + free(project->compile_command); + free(project); +} + +//---------- checksum ---------- +static char *cb_compute_md5(const char *data, size_t len) { + unsigned char digest[MD5_DIGEST_LENGTH]; + MD5((const unsigned char *)data, len, digest); + char *out = (char *)malloc(MD5_DIGEST_LENGTH * 2 + 1); + if (!out) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + exit(1); + } + for (int i = 0; i < MD5_DIGEST_LENGTH; i++) + sprintf(out + i * 2, "%02x", digest[i]); + out[MD5_DIGEST_LENGTH * 2] = 0; + return out; +} + +static char *cb_read_file_content(const char *filepath, size_t *out_len) { + FILE *f = fopen(filepath, "rb"); + if (!f) + return NULL; + if (fseek(f, 0, SEEK_END) != 0) { + fclose(f); + return NULL; + } + long size = ftell(f); + if (size < 0) { + fclose(f); + return NULL; + } + if (fseek(f, 0, SEEK_SET) != 0) { + fclose(f); + return NULL; + } + char *buffer = (char *)malloc((size_t)size); + if (!buffer) { + fclose(f); + return NULL; + } + size_t read_len = fread(buffer, 1, (size_t)size, f); + fclose(f); + if (out_len) + *out_len = read_len; + return buffer; +} + +static char *cb_compute_project_checksum(_CB_PROJECT *proj) { + if (!proj) + return NULL; + MD5_CTX ctx; + MD5_Init(&ctx); + + // include compile command, which includes flags & file list + if (proj->compile_command) + MD5_Update(&ctx, proj->compile_command, strlen(proj->compile_command)); + + // include file contents + for (int i = 0; i < proj->files->count; i++) { + size_t flen = 0; + char *fcontent = cb_read_file_content(proj->files->list[i], &flen); + if (fcontent) { + MD5_Update(&ctx, fcontent, flen); + free(fcontent); + } + } + + unsigned char digest[MD5_DIGEST_LENGTH]; + MD5_Final(digest, &ctx); + + char *checksum = (char *)malloc(MD5_DIGEST_LENGTH * 2 + 1); + if (!checksum) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + exit(1); + } + for (int i = 0; i < MD5_DIGEST_LENGTH; i++) + sprintf(checksum + i * 2, "%02x", digest[i]); + checksum[MD5_DIGEST_LENGTH * 2] = 0; + return checksum; +} + +static char *cb_read_checksum(const char *filename) { + FILE *f = fopen(filename, "r"); + if (!f) + return NULL; + char buf[MD5_DIGEST_LENGTH * 2 + 1]; + size_t r = fread(buf, 1, MD5_DIGEST_LENGTH * 2, f); + fclose(f); + if (r != MD5_DIGEST_LENGTH * 2) + return NULL; + buf[r] = 0; + return cb_strdup(buf); +} + +static int cb_write_checksum(const char *filename, const char *checksum) { + FILE *f = fopen(filename, "w"); + if (!f) + return -1; + size_t w = fwrite(checksum, 1, strlen(checksum), f); + fclose(f); + return (w == strlen(checksum)) ? 0 : -1; +} + +//---------- process helpers ---------- +static int proc_start_build_cmd(proc_t *proc, _CB_PROJECT *proj, + const char *cmdline) { + if (!cmdline) + return -1; +#if OS_WIN + STARTUPINFOA si; + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + ZeroMemory(&proc->pi, sizeof(proc->pi)); + + // run through cmd.exe to avoid manual argument parsing + char *full = NULL; + size_t cap = 0, len = 0; + cb_strcatf(&full, &cap, &len, "cmd.exe /C %s", cmdline); + + BOOL ok = CreateProcessA(NULL, full, NULL, NULL, FALSE, 0, NULL, NULL, &si, + &proc->pi); + free(full); + if (!ok) { + fprintf(stderr, COLOR_RED "[error] Failed to start build: %s\n" COLOR_RESET, + cmdline); + proc->running = 0; + return -1; + } + proc->running = 1; + proc->project = proj; + proc->is_build = 1; + return 0; +#else + pid_t pid = fork(); + if (pid == 0) { + // child: run via /bin/sh -c "cmdline" + execl("/bin/sh", "sh", "-c", cmdline, (char *)NULL); + perror("execl"); + _exit(127); + } else if (pid > 0) { + proc->pid = pid; + proc->running = 1; + proc->project = proj; + proc->is_build = 1; + return 0; + } else { + perror("fork"); + proc->running = 0; + return -1; + } +#endif +} + +static int proc_start_run(proc_t *proc, _CB_PROJECT *proj, char **argv) { +#if OS_WIN + STARTUPINFOA si; + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + ZeroMemory(&proc->pi, sizeof(proc->pi)); + + // Build a quoted commandline + size_t cmdlen = 0; + for (int i = 0; argv[i]; i++) { + size_t arglen = strlen(argv[i]); + int needs_quotes = strchr(argv[i], ' ') != NULL; + cmdlen += arglen + (needs_quotes ? 2 : 0) + 1; + } + char *cmdline = (char *)malloc(cmdlen + 1); + if (!cmdline) + return -1; + cmdline[0] = 0; + for (int i = 0; argv[i]; i++) { + int needs_quotes = strchr(argv[i], ' ') != NULL; + if (i > 0) + strcat(cmdline, " "); + if (needs_quotes) + strcat(cmdline, "\""); + strcat(cmdline, argv[i]); + if (needs_quotes) + strcat(cmdline, "\""); + } + BOOL success = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, + &si, &proc->pi); + free(cmdline); + if (!success) { + fprintf(stderr, COLOR_RED "[error] Failed to run %s\n" COLOR_RESET, + argv[0]); + proc->running = 0; + return -1; + } + proc->running = 1; + proc->project = proj; + proc->is_build = 0; + return 0; +#else + pid_t pid = fork(); + if (pid == 0) { + execvp(argv[0], argv); + perror("execvp"); + _exit(127); + } else if (pid > 0) { + proc->pid = pid; + proc->running = 1; + proc->project = proj; + proc->is_build = 0; + return 0; + } else { + perror("fork"); + proc->running = 0; + return -1; + } +#endif +} + +static int proc_poll(proc_t *proc) { + if (!proc->running) + return -1; +#if OS_WIN + DWORD res = WaitForSingleObject(proc->pi.hProcess, 0); + if (res == WAIT_OBJECT_0) { + DWORD code; + GetExitCodeProcess(proc->pi.hProcess, &code); + CloseHandle(proc->pi.hProcess); + CloseHandle(proc->pi.hThread); + proc->running = 0; + return (int)code; + } + return -1; +#else + int status; + pid_t ret = waitpid(proc->pid, &status, WNOHANG); + if (ret == 0) + return -1; // still running + else if (ret == proc->pid) { + proc->running = 0; + if (WIFEXITED(status)) + return WEXITSTATUS(status); + else + return -1; + } + return -1; +#endif +} + +static void proc_wait_all(proc_t *procs, int count) { + int running = count; + while (running > 0) { + running = 0; + for (int i = 0; i < count; i++) { + if (procs[i].running) { + int ret = proc_poll(&procs[i]); + if (ret < 0) + running++; + } + } +#if OS_WIN + Sleep(10); +#else + struct timespec ts; + ts.tv_sec = 0; + ts.tv_nsec = 10000000; + nanosleep(&ts, NULL); +#endif + } +} + +//---------- main build driver ---------- +static void _cb_project_build_internal(CB_PROJECT_BUILD_CONFIG config) { + if (!config.projects) { + fprintf(stderr, COLOR_RED "[error] No projects to build.\n" COLOR_RESET); + return; + } + + // Back-compat: old .parallel means parallel_run if caller used it + if (config.parallel_run <= 0 && config.parallel > 0) + config.parallel_run = config.parallel; + if (config.parallel_build <= 0) + config.parallel_build = 1; + if (config.parallel_run <= 0) + config.parallel_run = 1; + +#ifdef _CB_LOG_TO_FILE + FILE *log = fopen(".cb_build.out", "a"); + if (!log) { + perror("fopen"); + return; + } + time_t now = time(NULL); + fprintf(log, "\n=== Build Started: %s", ctime(&now)); +#endif + + // 1) Prepare: expand wildcards, build commands, compute checksums, decide + // build/no-build + typedef struct { + _CB_PROJECT *proj; + int should_build; + char checksum_file[512]; + char *new_checksum; + char *old_checksum; + } item_t; + + int nproj = 0; + while (config.projects[nproj]) + nproj++; + item_t *items = (item_t *)calloc(nproj, sizeof(item_t)); + if (!items) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + return; + } + + for (int i = 0; i < nproj; i++) { + _CB_PROJECT *proj = config.projects[i]; + + // Expand wildcards BEFORE command & checksum + cb_expand_project_wildcards(proj); + _CB_BUILD_COMPILE_COMMAND(proj); + + // checksum filename (safe-ish) + snprintf(items[i].checksum_file, sizeof(items[i].checksum_file), + ".cb_checksum_%s", proj->name ? proj->name : "noname"); + items[i].proj = proj; + + // compute checksums + items[i].new_checksum = cb_compute_project_checksum(proj); + items[i].old_checksum = cb_read_checksum(items[i].checksum_file); + items[i].should_build = 1; + if (items[i].new_checksum && items[i].old_checksum && + strcmp(items[i].new_checksum, items[i].old_checksum) == 0) { + items[i].should_build = 0; + } + } + + // 2) Build stage (parallel if requested) + int build_jobs = 0; + for (int i = 0; i < nproj; i++) + if (items[i].should_build) + build_jobs++; + + if (build_jobs == 0) { + for (int i = 0; i < nproj; i++) { + printf(COLOR_YELLOW + "[build] Skipping %s (no changes detected)\n\n" COLOR_RESET, + items[i].proj->name); +#ifdef _CB_LOG_TO_FILE + if (log) + fprintf(log, "[build] Skipped project: %s\n", items[i].proj->name); +#endif + } + } else if (config.parallel_build <= 1) { + for (int i = 0; i < nproj; i++) { + if (!items[i].should_build) { + printf(COLOR_YELLOW + "[build] Skipping %s (no changes detected)\n\n" COLOR_RESET, + items[i].proj->name); + continue; + } + _CB_PROJECT *proj = items[i].proj; + printf(COLOR_YELLOW "[build] Building %s\n" COLOR_RESET, proj->name); + printf(" %s\n", proj->compile_command); +#ifdef _CB_LOG_TO_FILE + if (log) + fprintf(log, "[build] Project: %s\nCommand: %s\n", proj->name, + proj->compile_command); +#endif + clock_t start = clock(); + // Run synchronously (serial mode) +#if OS_WIN + // Use system here; it will invoke cmd.exe + int ret = system(proj->compile_command); +#else + int ret = system(proj->compile_command); +#endif + clock_t end = clock(); + if (ret != 0) { + fprintf(stderr, COLOR_RED "[error] Build failed for %s\n" COLOR_RESET, + proj->name); +#ifdef _CB_LOG_TO_FILE + if (log) + fprintf(log, "[error] Build failed for %s\n", proj->name); +#endif + continue; + } + double duration = (double)(end - start) / CLOCKS_PER_SEC; + printf(COLOR_GREEN "[success] Built in %.2fs\n" COLOR_RESET, duration); +#ifdef _CB_LOG_TO_FILE + if (log) + fprintf(log, "[success] Built in %.2fs\n", duration); +#endif + cb_write_checksum(items[i].checksum_file, items[i].new_checksum); + } + } else { + // Parallel build pool + int maxp = config.parallel_build; + proc_t *pool = (proc_t *)calloc(maxp, sizeof(proc_t)); + if (!pool) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + goto after_builds; + } + int active = 0, next = 0; + + while (1) { + // launch while capacity + while (active < maxp && next < nproj) { + if (!items[next].should_build) { + next++; + continue; + } + _CB_PROJECT *proj = items[next].proj; + printf(COLOR_YELLOW "[build] Building %s (parallel)\n" COLOR_RESET, + proj->name); + printf(" %s\n", proj->compile_command); +#ifdef _CB_LOG_TO_FILE + if (log) + fprintf(log, "[build] Project: %s\nCommand: %s\n", proj->name, + proj->compile_command); +#endif + // find free slot + int k = -1; + for (int t = 0; t < maxp; t++) + if (!pool[t].running) { + k = t; + break; + } + if (k == -1) + break; // shouldn't happen due to active<maxp + if (proc_start_build_cmd(&pool[k], proj, proj->compile_command) == 0) { + active++; + } else { + fprintf(stderr, + COLOR_RED + "[error] Failed to start build for %s\n" COLOR_RESET, + proj->name); + } + next++; + } + + if (active == 0) { + // maybe there are only skipped projects left + int remaining = 0; + for (int j = next; j < nproj; j++) + if (items[j].should_build) + remaining++; + if (remaining == 0) + break; + } + + // poll + for (int t = 0; t < maxp; t++) { + if (pool[t].running) { + int ret = proc_poll(&pool[t]); + if (ret >= 0) { + active--; + if (ret != 0) { + fprintf(stderr, + COLOR_RED + "[error] Build failed for %s (exit %d)\n" COLOR_RESET, + pool[t].project ? pool[t].project->name : "(unknown)", + ret); +#ifdef _CB_LOG_TO_FILE + if (log) + fprintf(log, "[error] Build failed for %s\n", + pool[t].project ? pool[t].project->name : "(unknown)"); +#endif + } else { + // success → write checksum + for (int i = 0; i < nproj; i++) + if (items[i].proj == pool[t].project) + cb_write_checksum(items[i].checksum_file, + items[i].new_checksum); + printf(COLOR_GREEN "[success] Built %s\n" COLOR_RESET, + pool[t].project ? pool[t].project->name : ""); + } + } + } + } +#if OS_WIN + Sleep(10); +#else + struct timespec ts; + ts.tv_sec = 0; + ts.tv_nsec = 10000000; + nanosleep(&ts, NULL); + +#endif + if (next >= nproj && active == 0) + break; + } + free(pool); + after_builds:; + // Print skips that never printed + for (int i = 0; i < nproj; i++) + if (!items[i].should_build) + printf(COLOR_YELLOW + "[build] Skipping %s (no changes detected)\n" COLOR_RESET, + items[i].proj->name); + } + + // 3) Optional run stage (may be parallel) + if (config.run) { + int maxp = (config.parallel_run > 0 ? config.parallel_run : 1); + proc_t *pool = (proc_t *)calloc(maxp, sizeof(proc_t)); + if (!pool) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + goto cleanup; + } + int active = 0; + for (int i = 0; i < nproj; i++) { + _CB_PROJECT *proj = items[i].proj; + + int should_run = proj->output != NULL && + (items[i].should_build || config.run_if_skipped); + if (!should_run) + continue; + + int argc = proj->flags ? proj->flags->count : 0; + char **argv = (char **)malloc(sizeof(char *) * (argc + 2)); + if (!argv) { + fprintf(stderr, COLOR_RED "[error] OOM\n" COLOR_RESET); + continue; + } + + char output_path[512]; +#if OS_WIN + snprintf(output_path, sizeof(output_path), "%s", proj->output); +#else + snprintf(output_path, sizeof(output_path), "./%s", proj->output); +#endif + argv[0] = cb_strdup(output_path); + for (int j = 0; j < argc; j++) + argv[j + 1] = proj->flags->list[j]; + argv[argc + 1] = NULL; + + if (maxp <= 1) { + // run serially and wait + printf(COLOR_CYAN "[run] %s\n" COLOR_RESET, argv[0]); +#if OS_WIN + STARTUPINFOA si; + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + PROCESS_INFORMATION pi; + ZeroMemory(&pi, sizeof(pi)); + // Build cmdline + size_t cmdlen = 0; + for (int z = 0; argv[z]; z++) { + size_t L = strlen(argv[z]); + int q = strchr(argv[z], ' ') != NULL; + cmdlen += L + (q ? 2 : 0) + 1; + } + char *cmdline = (char *)malloc(cmdlen + 1); + cmdline[0] = 0; + for (int z = 0; argv[z]; z++) { + int q = strchr(argv[z], ' ') != NULL; + if (z > 0) + strcat(cmdline, " "); + if (q) + strcat(cmdline, "\""); + strcat(cmdline, argv[z]); + if (q) + strcat(cmdline, "\""); + } + if (CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, + &pi)) { + WaitForSingleObject(pi.hProcess, INFINITE); + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + } else { + fprintf(stderr, COLOR_RED "[error] Failed to run %s\n" COLOR_RESET, + argv[0]); + } + free(cmdline); +#else + pid_t pid = fork(); + if (pid == 0) { + execvp(argv[0], argv); + perror("execvp"); + _exit(127); + } else if (pid > 0) { + waitpid(pid, NULL, 0); + } else { + perror("fork"); + } +#endif + free(argv[0]); + free(argv); + if (proj->is_rebuild) { + // as per your debug note: stop the program if it's just a rebuild + exit(1); + } + } else { + // run in parallel pool + // ensure slot + for (;;) { + int used = 0; + for (int k = 0; k < maxp; k++) + if (pool[k].running) + used++; + if (used < maxp) + break; + for (int k = 0; k < maxp; k++) { + if (pool[k].running) { + int ret = proc_poll(&pool[k]); + (void)ret; + } + } +#if OS_WIN + Sleep(10); +#else + struct timespec ts; + ts.tv_sec = 0; + ts.tv_nsec = 10000000; + nanosleep(&ts, NULL); +#endif + } + // find free slot + int k = -1; + for (int t = 0; t < maxp; t++) + if (!pool[t].running) { + k = t; + break; + } + if (k >= 0) { + printf(COLOR_CYAN "[run] %s (parallel)\n" COLOR_RESET, argv[0]); + if (proc_start_run(&pool[k], proj, argv) != 0) { + fprintf(stderr, + COLOR_RED "[error] Failed to start %s\n" COLOR_RESET, + argv[0]); + } + } + // argv memory: argv[0] was strdup'ed; the child process duplicates + // memory; we can free now + free(argv[0]); + free(argv); + } + } + if (maxp > 1) { + proc_wait_all(pool, maxp); + } + free(pool); + } + +cleanup: +#ifdef _CB_LOG_TO_FILE + if (log) + fclose(log); +#endif + for (int i = 0; i < nproj; i++) { + free(items[i].old_checksum); + free(items[i].new_checksum); + } + free(items); +} + +#endif // _CB_IMPLEMENTATION +#endif // _STB_CB_H |