scc/src/config.h

#ifndef __SCC_CONFIG_H__
#define __SCC_CONFIG_H__

#include <argparse.h>

typedef struct {
    const char *input_file;
    const char *output_file;
    const char *target_description;
    int verbose;
    scc_argparse_list_t include_paths;
    scc_argparse_list_t define_macros;
    const char *entry_point_symbol;
    cbool emit_lex;
    cbool emit_pp;
    cbool emit_ast;
    cbool emit_hir;
    cbool emit_lir;
    cbool emit_mir;

    cbool emit_flatbin;
    cbool emit_sccf;
    cbool emit_target;
    cbool emit_mir_pass_reg_alloc;
    cbool emit_mir_pass_stack_layout;
    cbool emit_mir_pass_prolog_epilog;
} scc_config_t;

static void setup_argparse(scc_argparse_t *argparse, scc_config_t *config,
                           scc_argparse_lang_t lang) {
    enum {
        SCC_HINT_PROG_NAME,
        SCC_HINT_DESCRIPTION,
        SCC_HINT_OUTPUT_FILE,
        SCC_HINT_INPUT_FILE,
        SCC_HINT_INCLUDE_PATH,
        SCC_HINT_DEFINED_MACRO,
        SCC_HINT_TARGET_DESC,
        SCC_HINT_VERBOSE,

        SCC_HINT_ENTRY_POINT_SYMBOL,

        SCC_HINT_EMIT_LEX,
        SCC_HINT_EMIT_PP,
        SCC_HINT_EMIT_AST,
        SCC_HINT_EMIT_HIR,
        SCC_HINT_EMIT_LIR,
        SCC_HINT_EMIT_MIR,

        SCC_HINT_EMIT_FLATBIN,
        SCC_HINT_EMIT_SCCF,
        SCC_HINT_EMIT_TARGET,
    };
    static const char *scc_hints_en[] = {
        [SCC_HINT_PROG_NAME] = "scc",
        [SCC_HINT_DESCRIPTION] = "A simple C compiler",
        [SCC_HINT_OUTPUT_FILE] =
            "Output file (`-` means standard output stream file)",
        [SCC_HINT_INPUT_FILE] = "Input source file",
        [SCC_HINT_INCLUDE_PATH] = "Add directory to the include search paths",
        [SCC_HINT_DEFINED_MACRO] = "Define a macro",
        [SCC_HINT_TARGET_DESC] =
            "Target description(eg. x86_64-pc-windows-msvc)",
        [SCC_HINT_VERBOSE] = "Increase verbosity (can be used multiple times)",

        [SCC_HINT_ENTRY_POINT_SYMBOL] = "Entry point symbol name",

        [SCC_HINT_EMIT_LEX] = "Generate lexer sources tokens and exit",
        [SCC_HINT_EMIT_PP] = "Generate preprocessed tokens and exit",
        [SCC_HINT_EMIT_AST] = "Generate AST and exit",
        [SCC_HINT_EMIT_HIR] = "Generate High-level IR and exit",
        [SCC_HINT_EMIT_LIR] = "Generate Low-level IR and exit",
        [SCC_HINT_EMIT_MIR] = "Generate Machine IR and exit",

        [SCC_HINT_EMIT_FLATBIN] = "Generate flat binary and exit",
        [SCC_HINT_EMIT_SCCF] = "Generate SCCF and exit",
        [SCC_HINT_EMIT_TARGET] = "Generate target description and exit",

    };
    static const char *scc_hints_zh[] = {
        [SCC_HINT_PROG_NAME] = "scc",
        [SCC_HINT_DESCRIPTION] = "一个简单的C编译器",
        [SCC_HINT_OUTPUT_FILE] = "输出文件(`-`表示标准输出流文件)",
        [SCC_HINT_INPUT_FILE] = "输入源文件",
        [SCC_HINT_INCLUDE_PATH] = "添加系统头文件到搜索路径",
        [SCC_HINT_DEFINED_MACRO] = "定义宏",
        [SCC_HINT_TARGET_DESC] = "目标机器描述(eg. x86_64-pc-windows-msvc)",
        [SCC_HINT_VERBOSE] = "增加详细输出(可多次使用)",

        [SCC_HINT_ENTRY_POINT_SYMBOL] = "入口点符号名称",

        [SCC_HINT_EMIT_LEX] = "生成`源代码的词法单元`并退出",
        [SCC_HINT_EMIT_PP] = "生成`预处理后的词法单元`并退出",
        [SCC_HINT_EMIT_AST] = "生成`抽象语法树`并退出",
        [SCC_HINT_EMIT_HIR] = "生成`高级中间代码`并退出",
        [SCC_HINT_EMIT_LIR] = "生成`低级中间代码`并退出",
        [SCC_HINT_EMIT_MIR] = "生成`机器中间代码`并退出",

        [SCC_HINT_EMIT_FLATBIN] = "生成`flat binary`并退出",
        [SCC_HINT_EMIT_SCCF] = "生成`SCCF`并退出",
        [SCC_HINT_EMIT_TARGET] = "生成`目标代码`并退出",
    };

    const char **scc_hints;
    switch (lang) {
    case SCC_ARGPARSE_LANG_EN:
        scc_hints = scc_hints_en;
        break;
    case SCC_ARGPARSE_LANG_ZH:
        scc_hints = scc_hints_zh;
        break;
    default:
        scc_hints = scc_hints_en;
        break;
    }

    scc_argparse_init(argparse, scc_hints[SCC_HINT_PROG_NAME],
                      scc_hints[SCC_HINT_DESCRIPTION]);
    argparse->lang = lang;
    scc_argparse_cmd_t *root = scc_argparse_get_root(argparse);

    // -o, --output
    scc_argparse_opt_t opt_output;
    scc_argparse_opt_init(&opt_output, 'o', "output",
                          scc_hints[SCC_HINT_OUTPUT_FILE]);
    scc_argparse_spec_setup_string(&opt_output.spec, &(config->output_file));
    scc_argparse_cmd_add_opt(root, &opt_output);

    // input file (必需)
    scc_argparse_arg_t arg_input;
    scc_argparse_arg_init(&arg_input, "input", scc_hints[SCC_HINT_INPUT_FILE]);
    scc_argparse_spec_setup_string(&arg_input.spec, &(config->input_file));
    scc_argparse_spec_set_required(&arg_input.spec, true);
    scc_argparse_cmd_add_arg(root, &arg_input);

    // -I, --include (添加额外的系统头文件搜索路径)
    scc_argparse_opt_t opt_include;
    scc_argparse_opt_init(&opt_include, 'I', "include",
                          scc_hints[SCC_HINT_INCLUDE_PATH]);
    scc_argparse_spec_setup_list(&opt_include.spec, &(config->include_paths));
    scc_argparse_cmd_add_opt(root, &opt_include);

    // -D, --define (定义宏)
    scc_argparse_opt_t opt_define;
    scc_argparse_opt_init(&opt_define, 'D', "define",
                          scc_hints[SCC_HINT_DEFINED_MACRO]);
    scc_argparse_spec_setup_list(&opt_define.spec, &(config->define_macros));
    scc_argparse_cmd_add_opt(root, &opt_define);

    // --entry-point-symbol (设置入口点符号名称)
    scc_argparse_opt_t opt_entry_point_symbol;
    scc_argparse_opt_init(&opt_entry_point_symbol, 0, "entry-point-symbol",
                          scc_hints[SCC_HINT_ENTRY_POINT_SYMBOL]);
    scc_argparse_spec_setup_string(&opt_entry_point_symbol.spec,
                                   &(config->entry_point_symbol));
    scc_argparse_cmd_add_opt(root, &opt_entry_point_symbol);

    // --target
    scc_argparse_opt_t opt_target;
    scc_argparse_opt_init(&opt_target, 0, "target",
                          scc_hints[SCC_HINT_TARGET_DESC]);
    scc_argparse_spec_setup_string(&opt_target.spec,
                                   &(config->target_description));
    scc_argparse_cmd_add_opt(root, &opt_target);

    // -v, --verbose (计数)
    scc_argparse_opt_t opt_verbose;
    scc_argparse_opt_init(&opt_verbose, 'V', "verbose",
                          scc_hints[SCC_HINT_VERBOSE]);
    scc_argparse_spec_setup_count(&opt_verbose.spec, &(config->verbose));
    scc_argparse_cmd_add_opt(root, &opt_verbose);

    // --emit-lex
    scc_argparse_opt_t opt_lex;
    scc_argparse_opt_init(&opt_lex, 0, "emit-lex",
                          scc_hints[SCC_HINT_EMIT_LEX]);
    scc_argparse_spec_setup_bool(&opt_lex.spec, &(config->emit_lex));
    scc_argparse_cmd_add_opt(root, &opt_lex);

    // --emit-pp
    scc_argparse_opt_t opt_pp;
    scc_argparse_opt_init(&opt_pp, 0, "emit-pp", scc_hints[SCC_HINT_EMIT_PP]);
    scc_argparse_spec_setup_bool(&opt_pp.spec, &(config->emit_pp));
    scc_argparse_cmd_add_opt(root, &opt_pp);

    // -T, --emit-ast
    scc_argparse_opt_t opt_ast;
    scc_argparse_opt_init(&opt_ast, 'T', "emit-ast",
                          scc_hints[SCC_HINT_EMIT_AST]);
    scc_argparse_spec_setup_bool(&opt_ast.spec, &(config->emit_ast));
    scc_argparse_cmd_add_opt(root, &opt_ast);

    // -H, --emit-hir
    scc_argparse_opt_t opt_hir;
    scc_argparse_opt_init(&opt_hir, 'H', "emit-hir",
                          scc_hints[SCC_HINT_EMIT_HIR]);
    scc_argparse_spec_setup_bool(&opt_hir.spec, &(config->emit_hir));
    scc_argparse_cmd_add_opt(root, &opt_hir);

    // -L, --emit-lir
    scc_argparse_opt_t opt_lir;
    scc_argparse_opt_init(&opt_lir, 'L', "emit-lir",
                          scc_hints[SCC_HINT_EMIT_LIR]);
    scc_argparse_spec_setup_bool(&opt_lir.spec, &(config->emit_lir));
    scc_argparse_cmd_add_opt(root, &opt_lir);

    // -M, --emit-mir
    scc_argparse_opt_t opt_mir;
    scc_argparse_opt_init(&opt_mir, 'M', "emit-mir",
                          scc_hints[SCC_HINT_EMIT_MIR]);
    scc_argparse_spec_setup_bool(&opt_mir.spec, &(config->emit_mir));
    scc_argparse_cmd_add_opt(root, &opt_mir);

    // --emit-flatbin
    scc_argparse_opt_t opt_flatbin;
    scc_argparse_opt_init(&opt_flatbin, 0, "emit-flatbin",
                          scc_hints[SCC_HINT_EMIT_FLATBIN]);
    scc_argparse_spec_setup_bool(&opt_flatbin.spec, &(config->emit_flatbin));
    scc_argparse_cmd_add_opt(root, &opt_flatbin);
    // --emit-sccf
    scc_argparse_opt_t opt_sccf;
    scc_argparse_opt_init(&opt_sccf, 0, "emit-sccf",
                          scc_hints[SCC_HINT_EMIT_SCCF]);
    scc_argparse_spec_setup_bool(&opt_sccf.spec, &(config->emit_sccf));
    scc_argparse_cmd_add_opt(root, &opt_sccf);
    // --emit-target
    scc_argparse_opt_t opt_emit_target;
    scc_argparse_opt_init(&opt_emit_target, 0, "emit-target",
                          scc_hints[SCC_HINT_EMIT_TARGET]);
    scc_argparse_spec_setup_bool(&opt_emit_target.spec, &(config->emit_target));
    scc_argparse_cmd_add_opt(root, &opt_emit_target);
}

#endif /* __SCC_CONFIG_H___ */