banjo-info.c

Go to the documentation of this file.

 
#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;
}