zzy
b705e5d0ad
新增 scc_argparse_list_t 类型用于处理多个字符串值的参数， 并添加相应的配置函数 scc_argparse_spec_setup_list。 fix(lexer): 调整关键字标记处理逻辑 将关键字子类型从 SCC_TOK_SUBTYPE_KEYWORD 改为 SCC_TOK_SUBTYPE_IDENTIFIER，并移除相关的枚举定义。 refactor(lexer): 优化跳过换行功能实现 修改 scc_lexer_skip_until_newline 函数实现，改进循环逻辑和错误处理。 feat(pproc): 完善预处理器条件编译支持 重构条件编译状态管理，添加对 #ifdef、#ifndef、#elifdef、 #else、#endif 等指令的支持，并实现嵌套条件处理。 refactor(pproc): 优化文件包含路径处理 添加最大包含深度限制，改进包含路径添加功能， 修复文件状态结构命名。 docs(log): 更新日志模块标准库依赖 调整 stdarg.h 包含逻辑，更新编译器内置宏定义名称。 feat(core): 扩展核心类型定义 添加基础数据类型别名定义，完善类型系统支持。 feat(main): 实现命令行包含路径参数 添加 -I/--include 参数支持，允许用户指定额外的头文件搜索路径。
367 lines
14 KiB
C
367 lines
14 KiB
C
#include <assert.h>
|
|
#include <scc_pproc.h>
|
|
#include <string.h>
|
|
#include <utest/acutest.h>
|
|
|
|
static cbool process_input(const char *input, scc_cstring_t *output) {
|
|
int ret = 0;
|
|
scc_sstream_t mem_stream;
|
|
ret = scc_sstream_init_by_buffer(&mem_stream, input, strlen(input), false,
|
|
16);
|
|
Assert(ret == 0);
|
|
|
|
scc_lexer_t lexer;
|
|
scc_lexer_init(&lexer, scc_sstream_to_ring(&mem_stream));
|
|
|
|
scc_pproc_t pp;
|
|
scc_pproc_init(&pp, scc_lexer_to_ring(&lexer, 8, true));
|
|
|
|
scc_lexer_tok_ring_t *tok_ring = scc_pproc_to_ring(&pp, 8);
|
|
*output = scc_cstring_from_cstr("");
|
|
scc_lexer_tok_t tok;
|
|
while (1) {
|
|
scc_ring_next_consume(*tok_ring, tok, ret);
|
|
if (!ret) {
|
|
break;
|
|
}
|
|
scc_cstring_append(output, &tok.lexeme);
|
|
scc_lexer_tok_drop(&tok);
|
|
}
|
|
|
|
scc_pproc_drop(&pp);
|
|
scc_lexer_drop(&lexer);
|
|
scc_sstream_drop(&mem_stream);
|
|
return true;
|
|
}
|
|
|
|
#define CHECK_PP_OUTPUT_EXACT(input, expect) \
|
|
do { \
|
|
scc_cstring_t output; \
|
|
process_input(input, &output); \
|
|
assert(output.data != NULL); \
|
|
TEST_CHECK(strcmp(output.data, expect) == 0); \
|
|
TEST_MSG("Expected: %s", expect); \
|
|
TEST_MSG("Produced: %s", output.data); \
|
|
} while (0)
|
|
|
|
#define CHECK_PP_OUTPUT_CONTAIN(input, expect) \
|
|
do { \
|
|
scc_cstring_t output; \
|
|
process_input(input, &output); \
|
|
assert(output.data != NULL); \
|
|
TEST_CHECK(strstr(output.data, expect) != NULL); \
|
|
TEST_MSG("Expected: %s", expect); \
|
|
TEST_MSG("Produced: %s", output.data); \
|
|
} while (0)
|
|
|
|
static void test_define_simple_no_macro(void) {
|
|
TEST_CASE("simple no macro");
|
|
CHECK_PP_OUTPUT_EXACT("a", "a");
|
|
CHECK_PP_OUTPUT_EXACT("a()", "a()");
|
|
CHECK_PP_OUTPUT_EXACT("a(b)", "a(b)");
|
|
CHECK_PP_OUTPUT_EXACT("a(b, c)", "a(b, c)");
|
|
CHECK_PP_OUTPUT_EXACT("a(b, c, d)", "a(b, c, d)");
|
|
}
|
|
|
|
static void test_define_simple_object_macro(void) {
|
|
TEST_CASE("simple object-like macro");
|
|
CHECK_PP_OUTPUT_EXACT("#define MAX 100\nMAX\n", "100\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define NAME test\r\nNAME\n", "test\n");
|
|
}
|
|
|
|
static void test_define_complex_object_macro(void) {
|
|
TEST_CASE("complex object-like macro");
|
|
CHECK_PP_OUTPUT_EXACT("#define VALUE (100 + 50)\nVALUE\n", "(100 + 50)\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define PI 3.14159\nPI\n", "3.14159\n");
|
|
}
|
|
|
|
static void test_define_object_macro_backspace(void) {
|
|
TEST_CASE("object-like macro check backspace");
|
|
CHECK_PP_OUTPUT_EXACT("#define MAX 100\nMAX\n", "100\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define NAME \ttest\r\nNAME\n", "test\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define \tVALUE (100 \t+ 50)\nVALUE\n",
|
|
"(100 + 50)\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define \tPI \t 3.14159\nPI\n", "3.14159\n");
|
|
}
|
|
|
|
static void test_define_function_macro(void) {
|
|
TEST_CASE("function-like macro");
|
|
CHECK_PP_OUTPUT_EXACT("#define ADD(a,b) a + b\nADD(1, 2)\n", "1 + 2\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define ADD( a , b ) a + b\nADD(1, 2)\n", "1 + 2\n");
|
|
CHECK_PP_OUTPUT_EXACT(
|
|
"#define MAX(a,b) ((a) > (b) ? (a) : (b))\nMAX(10, 20)\n",
|
|
"((10) > (20) ? (10) : (20))\n");
|
|
}
|
|
|
|
static void test_define_stringify_operator(void) {
|
|
TEST_CASE("stringify operator (#)");
|
|
CHECK_PP_OUTPUT_EXACT("#define STRINGIFY(x) #x\nSTRINGIFY(hello)\n",
|
|
"\"hello\"\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define STR(x) #x\nSTR(test value)\n",
|
|
"\"test value\"\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define STR(x) #x\nSTR(A B \"ab\")\n",
|
|
"\"A B \"ab\"\"\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define STR(x) # x\nSTR(A B \"ab\")\n",
|
|
"\"A B \"ab\"\"\n");
|
|
}
|
|
|
|
static void test_define_concat_operator(void) {
|
|
TEST_CASE("concatenation operator (##)");
|
|
CHECK_PP_OUTPUT_EXACT("#define CONCAT a##b\nCONCAT\n", "ab\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define CONCAT a ## b\nCONCAT\n", "ab\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define CONCAT(a,b) a##b\nCONCAT(hello,world)\n",
|
|
"helloworld\n");
|
|
CHECK_PP_OUTPUT_EXACT(
|
|
"#define CONCAT( a , b ) a ## b\nCONCAT( hello , world )\n",
|
|
"helloworld\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define JOIN(pre,suf) pre ## suf\nJOIN(var, 123)\n",
|
|
"var123\n");
|
|
}
|
|
|
|
static void test_define_nested_macros(void) {
|
|
TEST_CASE("nested macros");
|
|
CHECK_PP_OUTPUT_EXACT(
|
|
"#define MAX 100\n#define TWICE_MAX (MAX * 2)\nTWICE_MAX\n",
|
|
"(100 * 2)\n");
|
|
CHECK_PP_OUTPUT_EXACT(
|
|
"#define A 1\n#define B (A + 1)\n#define C (B + 1)\nC\n",
|
|
"((1 + 1) + 1)\n");
|
|
|
|
CHECK_PP_OUTPUT_EXACT("#define A\n", "");
|
|
CHECK_PP_OUTPUT_EXACT("#undef A\n", "");
|
|
|
|
CHECK_PP_OUTPUT_EXACT(" # define A 1\nA", "1");
|
|
// CHECK_PP_OUTPUT_EXACT(" # define A 1 \nA", "1"); // TODO
|
|
}
|
|
|
|
static void test_undef_macros(void) {
|
|
TEST_CASE("test_undef_macros");
|
|
CHECK_PP_OUTPUT_EXACT("#define x 1\n"
|
|
"x\n"
|
|
"#undef x\n"
|
|
"x\n"
|
|
"#define x 2\n"
|
|
"x\n",
|
|
"1\nx\n2\n");
|
|
}
|
|
|
|
static void hard_test_define_func_macros(void) {
|
|
TEST_CASE("func_macros_hard with pp_01");
|
|
CHECK_PP_OUTPUT_EXACT("#define hash_hash # ## #\n"
|
|
"#define mkstr(a) # a\n"
|
|
"#define in_between(a) mkstr(a)\n"
|
|
"#define join(c, d) in_between(c hash_hash d)\n"
|
|
"char p[] = join(x, y);\n",
|
|
"char p[] = \"x ## y\";\n");
|
|
|
|
TEST_CASE("func_macros_hard with recursive define");
|
|
CHECK_PP_OUTPUT_EXACT("#define M1(x) M2(x + 1)\n"
|
|
"#define M2(x) M1(x * 2)\n"
|
|
"M1(5)\n",
|
|
"M1(5 + 1 * 2)\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define A B\n"
|
|
"#define B C\n"
|
|
"#define C 1\n"
|
|
"A\n",
|
|
"1\n");
|
|
|
|
TEST_CASE("func_macros_hard with self recursive call");
|
|
CHECK_PP_OUTPUT_EXACT("#define M(x) x\n"
|
|
"M(M(10))\n",
|
|
"10\n");
|
|
CHECK_PP_OUTPUT_EXACT("#define M(x) M(x)\n"
|
|
"#define N(x) x\n"
|
|
"N(M(1))\n",
|
|
"M(1)\n");
|
|
|
|
TEST_CASE("func_macros_hard with define by macro");
|
|
CHECK_PP_OUTPUT_EXACT("#define M1(x) M1(x + 1)\n"
|
|
"#define M2 M1\n"
|
|
"#define M3(x) x\n"
|
|
"M3(M3(M2)(0))\n",
|
|
"M1(0 + 1)\n");
|
|
|
|
// TEST_CASE("TODO"); /*FALSE*/
|
|
// CHECK_PP_OUTPUT_EXACT("#define str(x) # x\n"
|
|
// "str()\n",
|
|
// "\"\"\n");
|
|
|
|
TEST_CASE("TODO");
|
|
CHECK_PP_OUTPUT_EXACT("#define x 1\n"
|
|
"#define f(a) f(x * (a))\n"
|
|
"f(0)\n"
|
|
"f(x)",
|
|
"f(1 * (0))\n"
|
|
"f(1 * (1))");
|
|
CHECK_PP_OUTPUT_EXACT("#define x x(0)\n"
|
|
"#define f(a) f(x * (a))\n"
|
|
"f(f(0))\n"
|
|
"f(f(x))\n"
|
|
"f(f(a))\n",
|
|
"f(x(0) * (f(x(0) * (0))))\n"
|
|
"f(x(0) * (f(x(0) * (x(0)))))\n"
|
|
"f(x(0) * (f(x(0) * (a))))\n");
|
|
}
|
|
|
|
static void test_conditional_compilation(void) {
|
|
TEST_CASE("conditional compilation");
|
|
CHECK_PP_OUTPUT_EXACT("#if 1\ntrue\n#endif\n", "true\n");
|
|
CHECK_PP_OUTPUT_EXACT("#if 0\nfalse\n#endif\n", "");
|
|
CHECK_PP_OUTPUT_EXACT("#define FLAG 1\n#if FLAG\ntrue\n#endif\n", "true\n");
|
|
}
|
|
|
|
static void test_error_cases(void) {
|
|
TEST_CASE("macro redefinition");
|
|
// 应检测到警告或错误
|
|
// CHECK_PP_OUTPUT_CONTAIN("#define A 1\n#define A 2\n", "warning");
|
|
|
|
TEST_CASE("undefined macro");
|
|
CHECK_PP_OUTPUT_EXACT("UNDEFINED_MACRO\n", "UNDEFINED_MACRO\n");
|
|
}
|
|
|
|
static void test_edge_cases(void) {
|
|
TEST_CASE("empty macro");
|
|
CHECK_PP_OUTPUT_EXACT("#define EMPTY()\nEMPTY()\n", "\n");
|
|
|
|
TEST_CASE("macro with only spaces");
|
|
CHECK_PP_OUTPUT_EXACT("#define SPACE \nSPACE\n", "\n");
|
|
|
|
TEST_CASE("deep nesting");
|
|
CHECK_PP_OUTPUT_EXACT("#define A B\n#define B C\n#define C 1\nA\n", "1\n");
|
|
}
|
|
|
|
static void test_conditional_ifdef(void) {
|
|
TEST_CASE("ifdef and ifndef");
|
|
|
|
// 基本 ifdef / ifndef
|
|
CHECK_PP_OUTPUT_EXACT("#define FOO\n"
|
|
"#ifdef FOO\n"
|
|
"foo\n"
|
|
"#endif\n",
|
|
"foo\n");
|
|
|
|
CHECK_PP_OUTPUT_EXACT("#define FOO\n"
|
|
"#ifndef FOO\n"
|
|
"foo\n"
|
|
"#endif\n",
|
|
"");
|
|
|
|
CHECK_PP_OUTPUT_EXACT("#undef FOO\n"
|
|
"#ifdef FOO\n"
|
|
"foo\n"
|
|
"#endif\n",
|
|
"");
|
|
|
|
CHECK_PP_OUTPUT_EXACT("#undef FOO\n"
|
|
"#ifndef FOO\n"
|
|
"foo\n"
|
|
"#endif\n",
|
|
"foo\n");
|
|
|
|
// ifdef + else
|
|
CHECK_PP_OUTPUT_EXACT("#define FOO\n"
|
|
"#ifdef FOO\n"
|
|
"foo\n"
|
|
"#else\n"
|
|
"bar\n"
|
|
"#endif\n",
|
|
"foo\n");
|
|
|
|
CHECK_PP_OUTPUT_EXACT("#undef FOO\n"
|
|
"#ifdef FOO\n"
|
|
"foo\n"
|
|
"#else\n"
|
|
"bar\n"
|
|
"#endif\n",
|
|
"bar\n");
|
|
|
|
// ifdef + elifdef (C23)
|
|
CHECK_PP_OUTPUT_EXACT("#define FOO\n"
|
|
"#ifdef FOO\n"
|
|
"foo\n"
|
|
"#elifdef FOO\n"
|
|
"foo2\n"
|
|
"#endif\n",
|
|
"foo\n");
|
|
|
|
CHECK_PP_OUTPUT_EXACT("#undef FOO\n"
|
|
"#define BAR\n"
|
|
"#ifdef FOO\n"
|
|
"foo\n"
|
|
"#elifdef BAR\n"
|
|
"bar\n"
|
|
"#else\n"
|
|
"none\n"
|
|
"#endif\n",
|
|
"bar\n");
|
|
|
|
CHECK_PP_OUTPUT_EXACT("#undef FOO\n"
|
|
"#undef BAR\n"
|
|
"#ifdef FOO\n"
|
|
"foo\n"
|
|
"#elifdef BAR\n"
|
|
"bar\n"
|
|
"#else\n"
|
|
"none\n"
|
|
"#endif\n",
|
|
"none\n");
|
|
|
|
// 嵌套
|
|
CHECK_PP_OUTPUT_EXACT("#define A\n"
|
|
"#ifdef A\n"
|
|
" #ifdef B\n"
|
|
" inner\n"
|
|
" #endif\n"
|
|
" outer\n"
|
|
"#endif\n",
|
|
" outer\n");
|
|
|
|
CHECK_PP_OUTPUT_EXACT("#define B\n"
|
|
"#ifndef A\n"
|
|
" #ifdef B\n"
|
|
" inner\n"
|
|
" #endif\n"
|
|
" outer\n"
|
|
"#endif\n",
|
|
" inner\n outer\n");
|
|
|
|
// 外层假，内层真
|
|
CHECK_PP_OUTPUT_EXACT("#ifdef __NONE\n"
|
|
"#define OUTER\n"
|
|
"#endif\n"
|
|
"#ifdef OUTER\n"
|
|
"should not appear\n"
|
|
"#endif\n",
|
|
""); // 期望为空
|
|
|
|
// 更复杂的嵌套条件
|
|
CHECK_PP_OUTPUT_EXACT("#define X\n"
|
|
"#ifdef X\n"
|
|
"x defined\n"
|
|
"#ifdef Y\n"
|
|
"Y defined\n"
|
|
"#else\n"
|
|
"Y not defined\n"
|
|
"#endif\n"
|
|
"after inner\n"
|
|
"#else\n"
|
|
"X not defined\n"
|
|
"#endif\n",
|
|
"x defined\nY not defined\nafter inner\n");
|
|
}
|
|
|
|
#define TEST_LIST_CASE(func_name) {#func_name, func_name}
|
|
TEST_LIST = {
|
|
TEST_LIST_CASE(test_define_simple_no_macro),
|
|
TEST_LIST_CASE(test_define_simple_object_macro),
|
|
TEST_LIST_CASE(test_define_complex_object_macro),
|
|
TEST_LIST_CASE(test_define_object_macro_backspace),
|
|
TEST_LIST_CASE(test_define_function_macro),
|
|
TEST_LIST_CASE(test_define_stringify_operator),
|
|
TEST_LIST_CASE(test_define_concat_operator),
|
|
TEST_LIST_CASE(test_define_nested_macros),
|
|
TEST_LIST_CASE(test_undef_macros),
|
|
TEST_LIST_CASE(hard_test_define_func_macros),
|
|
TEST_LIST_CASE(test_conditional_ifdef),
|
|
{NULL, NULL},
|
|
}; |