banjo-info.c

CLI tool to query Banjo build information.

CLI tool to query Banjo build information.This tool outputs version and build information in formats suitable for both human reading and scripting. Flags can be combined to build custom output strings with sensible separators.

Examples: banjo-info -nvs # banjo-1.0.0-rc.1 banjo-info -Nv # Banjo-1.0.0 banjo-info -a # banjo-1.0.0-rc.1 Debug Build, GCC 13 banjo-info -v # 1.0.0 banjo-info -b # x11 (one per line) banjo-info # full human-readable output

 
#include <banjo/api.h>
#include <banjo/cli.h>
#include <banjo/log.h>
#include <banjo/main.h>
#include <banjo/system.h>
#include <banjo/version.h>
 
#include <ctype.h>
#include <stdio.h>
 
// Output flags - set by CLI parser
static int flag_help       = 0;
static int flag_all        = 0;  // -a: all main info (shorthand for -nvsdc)
static int flag_name_lower = 0;  // -n: lowercase name (banjo)
static int flag_name       = 0;  // -N: name (Banjo)
static int flag_version    = 0;  // -v: version (1.0.0)
static int flag_stage      = 0;  // -s: stage (rc.1)
static int flag_debug      = 0;  // -d: "Debug Build" if debug
static int flag_compiler   = 0;  // -c: compiler info
static int flag_backends   = 0;  // -b: list backends
 
// Helper: get stage type name from stage byte
static const char* stage_type_name(uint8_t stage) {
    if (stage == BJ_VERSION_STABLE) return "stable";
    switch (stage & 0xC0) {
        case BJ_VERSION_ALPHA:   return "alpha";
        case BJ_VERSION_BETA:    return "beta";
        case BJ_VERSION_PREVIEW: return "preview";
        case BJ_VERSION_RC:      return "rc";
        default:                 return "unknown";
    }
}
 
// Helper: format stage string (e.g., "rc.2", "alpha", "stable")
static size_t format_stage(char* buffer, size_t bufsize, uint8_t stage) {
    uint8_t num = stage & 0x3F;
    if (stage == BJ_VERSION_STABLE || num == 0) {
        return (size_t)snprintf(buffer, bufsize, "%s", stage_type_name(stage));
    }
    return (size_t)snprintf(buffer, bufsize, "%s.%u", stage_type_name(stage), num);
}
 
// Print full information (default when no flags)
static void print_all(const bj_build_info* info) {
    char version_string[32];
    bj_format_version(version_string, sizeof(version_string), info->version);
 
    printf("%s version %s (0x%08X) [%s] %s build\n",
        info->name,
        version_string, info->version,
        info->variant,
        info->debug ? "Debug" : "Release"
    );
 
    printf("Compiler: %s %d\n", info->compiler_name, info->compiler_version);
 
    printf("\nBackends:\n");
    printf("  %c alsa\n",       info->backend_alsa       ? '+' : '-');
    printf("  %c cocoa\n",      info->backend_cocoa      ? '+' : '-');
    printf("  %c emscripten\n", info->backend_emscripten ? '+' : '-');
    printf("  %c mme\n",        info->backend_mme        ? '+' : '-');
    printf("  %c wayland\n",    info->backend_wayland    ? '+' : '-');
    printf("  %c win32\n",      info->backend_win32      ? '+' : '-');
    printf("  %c x11\n",        info->backend_x11        ? '+' : '-');
 
    printf("\nConfiguration:\n");
    printf("  %c checks_abort\n", info->checks_abort ? '+' : '-');
    printf("  %c checks_log\n",   info->checks_log   ? '+' : '-');
    printf("  %c fastmath\n",     info->fastmath     ? '+' : '-');
    printf("  %c log_color\n",    info->log_color    ? '+' : '-');
    printf("  %c pedantic\n",     info->pedantic     ? '+' : '-');
 
    const size_t count = bj_video_backends(0, 0);
    printf("\nActive video backends (%zu):\n", count);
    const char* names[16];
    size_t got = bj_video_backends(names, count < 16 ? count : 16);
    for (size_t i = 0; i < got; ++i) {
        printf("  %s\n", names[i]);
    }
}
 
// Print combined output based on flags
static void print_combined(const bj_build_info* info) {
    int printed = 0;  // Track if anything printed on main line
 
    // Identity segment: name and version components
    if (flag_name_lower) {
        for (size_t i = 0; info->name[i]; ++i) {
            putchar(tolower((unsigned char)info->name[i]));
        }
        printed = 1;
    } else if (flag_name) {
        printf("%s", info->name);
        printed = 1;
    }
 
    // Version and stage
    if (flag_version || flag_stage) {
        if (printed) putchar('-');
    }
 
    if (flag_version) {
        printf("%u.%u.%u",
            BJ_VERSION_MAJOR(info->version),
            BJ_VERSION_MINOR(info->version),
            BJ_VERSION_PATCH(info->version));
        printed = 1;
    }
 
    if (flag_stage) {
        if (flag_version) putchar('-');
        char stage_str[16];
        format_stage(stage_str, sizeof(stage_str), BJ_VERSION_STAGE(info->version));
        printf("%s", stage_str);
        printed = 1;
    }
 
    // Build segment: debug and compiler
    if (flag_debug && info->debug) {
        if (printed) putchar(' ');
        printf("Debug Build");
        printed = 1;
    }
 
    if (flag_compiler) {
        if (printed) printf(", ");
        printf("%s %d", info->compiler_name, info->compiler_version);
        printed = 1;
    }
 
    // End main line if we printed anything
    if (printed) {
        putchar('\n');
    }
 
    // Backends segment: one per line
    if (flag_backends) {
        const size_t count = bj_video_backends(0, 0);
        const char* names[16];
        size_t got = bj_video_backends(names, count < 16 ? count : 16);
        for (size_t i = 0; i < got; ++i) {
            printf("%s\n", names[i]);
        }
    }
}
 
int main(int argc, char* argv[]) {
    struct bj_cli_argument args[] = {
        {
            .shortname = 'h',
            .name      = "help",
            .help      = "Show this help message and exit",
            .action    = bj_print_cli_help_action,
            .dest      = &flag_help
        },
        {
            .shortname = 'a',
            .name      = "all",
            .help      = "Print all info (shorthand for -nvsdc)",
            .dest      = &flag_all
        },
        {
            .shortname = 'n',
            .name      = "name-lower",
            .help      = "Print lowercase name (banjo)",
            .dest      = &flag_name_lower
        },
        {
            .shortname = 'N',
            .name      = "name",
            .help      = "Print name (Banjo)",
            .dest      = &flag_name
        },
        {
            .shortname = 'v',
            .name      = "version",
            .help      = "Print version (1.0.0)",
            .dest      = &flag_version
        },
        {
            .shortname = 's',
            .name      = "stage",
            .help      = "Print release stage (rc.1, alpha, stable)",
            .dest      = &flag_stage
        },
        {
            .shortname = 'd',
            .name      = "debug",
            .help      = "Print 'Debug Build' if debug build",
            .dest      = &flag_debug
        },
        {
            .shortname = 'c',
            .name      = "compiler",
            .help      = "Print compiler name and version",
            .dest      = &flag_compiler
        },
        {
            .shortname = 'b',
            .name      = "backends",
            .help      = "Print available backends (one per line)",
            .dest      = &flag_backends
        },
    };
 
    struct bj_cli parser = {
        .prog          = "banjo-info",
        .description   = "Query Banjo build information.\n"
                         "Flags can be combined to build custom output with sensible separators.\n"
                         "With no flags, prints full human-readable information.",
        .epilog        = "Examples:\n"
                         "  banjo-info -nvs            # banjo-1.0.0-rc.1\n"
                         "  banjo-info -Nv             # Banjo-1.0.0\n"
                         "  banjo-info -a              # banjo-1.0.0-rc.1 Debug Build, GCC 13\n"
                         "  banjo-info -v              # 1.0.0\n"
                         "  banjo-info -b              # list backends\n"
                         "  banjo-info                 # full output",
        .arguments_len = sizeof(args) / sizeof(args[0]),
        .arguments     = args,
    };
 
    if (!bj_parse_cli(&parser, argc, argv, 0)) {
        bj_print_cli_help(&parser);
        return 1;
    }
 
    const bj_build_info* info = bj_build_information();
 
    // Expand -a to -nvsdc
    if (flag_all) {
        flag_name_lower = 1;
        flag_version = 1;
        flag_stage = 1;
        flag_debug = 1;
        flag_compiler = 1;
    }
 
    // Check if any output flag was set
    int any_flag = flag_name_lower || flag_name || flag_version || flag_stage ||
                   flag_debug || flag_compiler || flag_backends;
 
    if (!any_flag) {
        print_all(info);
    } else {
        print_combined(info);
    }
 
    return 0;
}