如何将命令行参数字符串解析为可传入posix_spawn/execve的数组

核心解析规则 #

• 初始化三个状态：当前参数缓冲区、引用状态（无引用/单引号引用/双引号引用）、转义标记（下一个字符是否转义）
• 逐字符遍历命令字符串，按POSIX shell分词规则处理：
  1. 若转义标记为真：直接将当前字符写入当前参数缓冲区，清除转义标记
  2. 若遇到反斜杠\：
     • 单引号引用状态下反斜杠无特殊含义，直接写入缓冲区
     • 双引号引用状态下仅当后续字符为$、`、"、\、换行符时作为转义符，其余情况直接写入
     • 无引用状态下设置转义标记为真，不写入反斜杠本身
  3. 若遇到单引号'：
     • 双引号引用状态下直接写入缓冲区
     • 单引号引用状态下退出单引号引用
     • 无引用状态下进入单引号引用
  4. 若遇到双引号"：
     • 单引号引用状态下直接写入缓冲区
     • 双引号引用状态下退出双引号引用
     • 无引用状态下进入双引号引用
  5. 若遇到空白字符（空格、制表符、换行符）：
     • 处于引用状态或转义标记为真时直接写入缓冲区
     • 无引用且无转义时，若当前缓冲区非空则将其作为一个参数加入argv数组，清空缓冲区
  6. 其余普通字符直接写入当前参数缓冲区
• 遍历结束后，若当前缓冲区非空则加入argv数组，最后为argv追加NULL元素（posix_spawn和execve要求参数数组以NULL结尾）

注意事项 #

• 单引号内所有字符均保留字面含义，直到遇到配对的单引号，无转义例外
• 若不需要处理变量展开、命令替换，仅做分词的话，可忽略$和`的特殊处理逻辑，仅保留引号匹配和转义逻辑即可
• 生成的argv数组使用完毕后需逐个释放参数内存，再释放数组本身，避免内存泄漏

C语言实现示例 #

#include <stdlib.h>
#include <string.h>
#include <ctype.h>

char **parse_cmd_to_argv(const char *cmd) {
    size_t argv_cap = 8;
    char **argv = malloc(sizeof(char*) * argv_cap);
    if (!argv) return NULL;
    size_t argv_len = 0;

    size_t buf_cap = 256;
    char *buf = malloc(buf_cap);
    if (!buf) {
        free(argv);
        return NULL;
    }
    size_t buf_len = 0;

    enum { QUOTE_NONE, QUOTE_SINGLE, QUOTE_DOUBLE } quote_state = QUOTE_NONE;
    int escape_next = 0;

    for (const char *p = cmd; *p; p++) {
        // 缓冲区自动扩容
        if (buf_len + 2 > buf_cap) {
            buf_cap *= 2;
            char *new_buf = realloc(buf, buf_cap);
            if (!new_buf) {
                free(buf);
                for (size_t i = 0; i < argv_len; i++) free(argv[i]);
                free(argv);
                return NULL;
            }
            buf = new_buf;
        }

        if (escape_next) {
            buf[buf_len++] = *p;
            escape_next = 0;
            continue;
        }

        if (*p == '\\') {
            if (quote_state == QUOTE_SINGLE) {
                buf[buf_len++] = *p;
            } else if (quote_state == QUOTE_DOUBLE) {
                char next = *(p + 1);
                if (next == '$' || next == '`' || next == '"' || next == '\\' || next == '\n') {
                    escape_next = 1;
                } else {
                    buf[buf_len++] = *p;
                }
            } else {
                escape_next = 1;
            }
            continue;
        }

        if (*p == '\'') {
            if (quote_state == QUOTE_SINGLE) {
                quote_state = QUOTE_NONE;
            } else if (quote_state == QUOTE_NONE) {
                quote_state = QUOTE_SINGLE;
            } else {
                buf[buf_len++] = *p;
            }
            continue;
        }

        if (*p == '"') {
            if (quote_state == QUOTE_DOUBLE) {
                quote_state = QUOTE_NONE;
            } else if (quote_state == QUOTE_NONE) {
                quote_state = QUOTE_DOUBLE;
            } else {
                buf[buf_len++] = *p;
            }
            continue;
        }

        if (isspace((unsigned char)*p)) {
            if (quote_state != QUOTE_NONE) {
                buf[buf_len++] = *p;
            } else {
                if (buf_len > 0) {
                    buf[buf_len] = '\0';
                    // argv自动扩容
                    if (argv_len + 2 > argv_cap) {
                        argv_cap *= 2;
                        char **new_argv = realloc(argv, sizeof(char*) * argv_cap);
                        if (!new_argv) {
                            free(buf);
                            for (size_t i = 0; i < argv_len; i++) free(argv[i]);
                            free(argv);
                            return NULL;
                        }
                        argv = new_argv;
                    }
                    argv[argv_len++] = strdup(buf);
                    buf_len = 0;
                }
            }
            continue;
        }

        buf[buf_len++] = *p;
    }

    // 处理剩余的最后一个参数
    if (buf_len > 0) {
        buf[buf_len] = '\0';
        if (argv_len + 2 > argv_cap) {
            char **new_argv = realloc(argv, sizeof(char*) * (argv_cap + 2));
            if (!new_argv) {
                free(buf);
                for (size_t i = 0; i < argv_len; i++) free(argv[i]);
                free(argv);
                return NULL;
            }
            argv = new_argv;
        }
        argv[argv_len++] = strdup(buf);
    }
    free(buf);
    argv[argv_len] = NULL;
    return argv;
}

// 内存释放工具函数
void free_argv(char **argv) {
    if (!argv) return;
    for (size_t i = 0; argv[i]; i++) {
        free(argv[i]);
    }
    free(argv);
}

内容的提问来源于stack exchange，提问作者iljau