argp包处理命令行参数

argp 是一个在 GNU C Library (glibc) 中的库，用于解析命令行参数。它为 UNIX 风格的命令行参数提供了一种简洁和统一的方法。

以下是一个简单的使用 argp 解析命令行参数的例子：

1. 先确保您的系统中有 argp。它通常随 glibc 一起分发，所以大多数 Linux 系统上应该都有。

2. 下面我们来看一个实例。

// test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <argp.h>

struct arguments
{
    int compile_only;
    int generate_assembly;
    int output;
    char *output_file;
    int verbose;
    char *input_file;
};

char cmd[1024];
char filename[] = "./a.c";
static char doc[] = "Welcome to Argp";

static struct argp_option options[] = {
    {"compile", 'c', 0, 0, "Compile Only"},
    {"assembly", 's', 0, 0, "Generate Assembly Only"},
    {"output", 'o', "FILE", 0, "Output To FILE"},
    {"verbose", 'v', 0, 0, "Verbose mode"},
    {0}};

static error_t parse_opt(int key, char *arg, struct argp_state *state)
{
    struct arguments *arguments = state->input;
    switch (key)
    {
    case 'c':
        arguments->compile_only = 1;
        break;
    case 's':
        arguments->generate_assembly = 1;
        break;
    case 'o':
        arguments->output = 1;
        arguments->output_file = arg;
        break;
    case 'v':
        arguments->verbose = 1;
        break;
    case ARGP_KEY_ARG:
        if (!arguments->input_file)
        {
            arguments->input_file = arg;
            printf("arg = %s\n", arg);
        }
        else
        {
            argp_usage(state);
        }
        break;
    default:
        return ARGP_ERR_UNKNOWN;
    }
    return 0;
}

static void verbose_on(int v, char *s)
{
    if (v)
    {
        puts(s);
    }
}

static struct argp argp = {options, parse_opt, "FILE", doc};

int main(int argc, char *argv[])
{
    struct arguments arguments;
    arguments.compile_only = 0;
    arguments.output = 0;
    arguments.generate_assembly = 1;
    arguments.output_file = "output"; // 默认值
    arguments.verbose = 0;
    arguments.input_file = NULL; // 默认值

    argp_parse(&argp, argc, argv, 0, 0, &arguments);

    if (arguments.compile_only)
    {
        sprintf(cmd, "gcc %s -o ./a.o", filename);
        verbose_on(arguments.verbose, cmd);
        if (system(cmd) != 0)
        {
            fprintf(stderr, "Assembly failed.\n");
            return 1;
        }
    }

    if (arguments.generate_assembly)
    {
        sprintf(cmd, "gcc -S %s -o a.s", filename);
        verbose_on(arguments.verbose, cmd);
        if (system(cmd) != 0)
        {
            fprintf(stderr, "Assembly failed.\n");
            return 1;
        }
    }

    if (arguments.output)
    {
        sprintf(cmd, "gcc %s -o %s", filename, arguments.output_file);
        verbose_on(arguments.verbose, cmd);
        if (system(cmd) != 0)
        {
            fprintf(stderr, "Linking failed.\n");
            return 1;
        }
    }

    return 0;
}

// ./test a.c         默认  生成a.s
// ./test -c a.c      生成a.o
// ./test -s a.c      汇编  生成a.s
// ./test -v -c a.c   生成a.o           同时输出编译过程
// ./test -v -s a.c   汇编  生成a.s     同时输出编译过程
// ./test --help      输出全部编译选项信息

---

parse_opt

当使用 argp 库进行命令行参数解析时，需要定义一个函数来处理每一个命令行参数。这个函数通常命名为 parse_opt，但实际上可以命名为任何想要的名字。这个函数的签名必须匹配 argp 期望的格式，即接受三个参数，并返回一个 error_t 类型的值。

static error_t parse_opt(int key, char *arg, struct argp_state *state);

这里，我们来深入探究 parse_opt 函数的参数：

1. int key:

   • 这个参数表示当前正在处理的命令行参数的标识符或键。
   • 对于短选项（例如 -v），它是字符的 ASCII 值（在这种情况下，'v'）。
   • 对于长选项（例如 --verbose），它是在 argp_option 结构体中为这个选项指定的值。
   • 还有一些预定义的键值（例如 ARGP_KEY_ARG 或 ARGP_KEY_END），它们表示特定的解析事件而不是特定的选项。

2. char *arg:

   • 当当前处理的命令行参数带有关联值时（例如 -o output.txt 或 --output=output.txt），arg 指向这个关联值（在这个例子中是 "output.txt"）。
   • 如果当前处理的参数没有关联值，arg 将为 NULL。

3. struct argp_state *state:

   • 这是一个指向当前解析状态的指针，其类型为 struct argp_state。
   • 通过这个结构体，可以访问有关当前解析状态的多种信息，例如：还有多少参数未解析、当前解析的是哪个参数、在调用 argp_parse 时传入的输入数据等。
   • 常见的用途是通过 state->input 来获取一个指向存储解析结果的结构体的指针，但还有许多其他字段和用途。

在 parse_opt 函数内部，通常会使用一个 switch 语句来检查 key 参数，并据此决定如何处理当前的命令行参数。如果发现任何错误（例如一个参数没有预期的关联值，或者提供了不支持的参数），可以返回一个错误代码。如果一切正常，可以简单地返回 0（代表成功）。

---

argp_usage

argp_usage 是 C 语言的 argp 库函数，用于输出关于如何使用程序的信息，然后退出程序。这通常在用户提供了某些无效的命令行参数时被调用，以通知用户正确的使用方法。

argp_usage(state);

参数：

• state: 指向一个 argp_state 结构的指针，该结构包含了 argp 的解析状态。这通常是在 argp 的解析函数中被传入的。

用法：

当你检测到用户的输入是非法的或者不完整的，你可以调用 argp_usage 来显示帮助信息。例如，如果你的程序需要至少一个命令行参数，但用户没有提供任何参数，你可以这样使用它：

if (state->argc == 1) {
    argp_usage(state);
}

输出内容：

默认情况下，argp_usage 输出以下内容：

1. 如果设置了，那么程序的用法语法。
2. 由 ARGP_HELP_STD_USAGE、ARGP_HELP_SEE 和 ARGP_HELP_LONG 这三个标志决定的标准帮助消息。
3. 如果设置了，那么 argp 结构中的 args_doc 和 doc 字段。

此外，你可以通过 state 结构中的 flags 成员进一步定制输出。

示例：

考虑一个简单的 argp 例子，其中 argp_usage 用于确保至少有一个命令行参数：

const char *argp_program_version = "program 1.0";
const char *argp_program_bug_address = "<email@example.com>";
static char doc[] = "A simple program using argp";
static char args_doc[] = "ARG1 [STRING...]";

static error_t parse_opt(int key, char *arg, struct argp_state *state) {
    switch (key) {
        case ARGP_KEY_ARG:
            // 添加参数处理
            break;
        case ARGP_KEY_END:
            if (state->arg_num < 1) {
                // 如果没有足够的参数
                argp_usage(state);
            }
            break;
        default:
            return ARGP_ERR_UNKNOWN;
    }
    return 0;
}

static struct argp_option options[] = { {0} };
static struct argp argp = { options, parse_opt, args_doc, doc };

int main(int argc, char **argv) {
    argp_parse(&argp, argc, argv, 0, 0, 0);
    return 0;
}

在上面的例子中，如果没有提供至少一个命令行参数，argp_usage 将被调用，并显示一个标准的用法消息。

---

有一个重要的细节。当使用 argp 解析命令行参数时，state->argc 包含了程序的名称及其参数。因此，如果用户只输入了程序的名字而没有提供任何其他参数，state->argc 就会是 1。

例如，考虑命令行调用：

./my_program

在这种情况下，state->argc 将会是 1，因为只有一个字符串（即程序的名称）在参数列表中。

另一方面，如果用户调用程序并提供了一个参数：

./my_program some_arg

那么 state->argc 将会是 2，因为参数列表中有两个字符串：程序的名称和 some_arg。

因此，检查 state->argc == 1 是为了确定用户是否只提供了程序的名称而没有任何其他参数。

---

arg_num 和 argc 之间的区别：

• state->argc 表示命令行上提供的所有字符串的总数（包括程序名）。
• state->arg_num 是已经解析的非选项参数的数量。这不包括程序名或任何前导选项。

所以，当我们检查 state->arg_num 时，我们只是查看非选项参数的数量。

如果你希望程序接受一个且仅一个非选项参数（例如输入文件名），那么当 state->arg_num >= 1 时，我们确实已经得到了一个参数。但如果用户提供了更多的非选项参数，我们应该在下一次解析中捕获它们，并可能决定调用 argp_usage(state)。

在 ARGP_KEY_ARG 事件下，每次解析到一个非选项参数，state->arg_num 会增加。这意味着，在 ARGP_KEY_ARG 下，state->arg_num 的值从 0 开始，并在每次解析到一个新的非选项参数时增加。

因此，考虑以下逻辑：

switch (key) {
    case ARGP_KEY_ARG:
        if (state->arg_num >= 1) {
            argp_usage(state);
        }
        break;
    // ... 其他代码 ...
}

在这里，当我们解析到第一个非选项参数时（例如输入文件名），state->arg_num 为 0，因此不会调用 argp_usage(state)。但是，当我们解析到第二个非选项参数时，state->arg_num 将为 1，我们会调用 argp_usage(state)，因为这表示用户提供了多余的参数。

总之，当你希望确保只有一个非选项参数时，检查 state->arg_num >= 1 是正确的。