zzy/spl
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

stage1 新的ast结构 使用pest描述语法

Browse Source
This commit is contained in:
zzy committed 2026-09-08 13:14:29 +08:00
1 parent 34df303b56
commit 98b35a98e3
12 files changed
+3344 -2168
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

gramma.pest
+384
View File
@@ -0,0 +1,384 @@
// 顶层容器
Root = { SOI ~ ContainerMembers ~ EOI }
ContainerMembers = { ExternalHeaderList ~ (ContainerDeclaration ~ (COMMA | SEMICOLON)*)* }
HeaderItem = { (AT | SHARP) ~ IDENTIFIER ~ (LPAREN ~ ExprList? ~ RPAREN)? }
HeaderList = { HeaderItem* }
DeclHeader = { HeaderList? ~ KEYWORD_pub? }
ExternalHeaderItem = { (AT | SHARP) ~ BANG ~ IDENTIFIER ~ (LPAREN ~ ExprList? ~ RPAREN)? }
ExternalHeaderList = { ExternalHeaderItem* }
BindingIdent = { IDENTIFIER | UNDERSCORE }
ContainerDeclaration = {
FnDecl
| VarDecl
| ConstDecl
| TypeDecl
| MemberDecl
| ComptimeDecl
| HeaderList ~ Block
}
ComptimeDecl = { KEYWORD_comptime ~ (Block | Expr) }
// 函数声明（可带 comptime 前缀，支持修饰符）
FnDecl = {
DeclHeader ~ KEYWORD_comptime? ~ KEYWORD_fn ~ IDENTIFIER ~ LPAREN ~ ParamDeclList ~ RPAREN ~ (COLON ~ TypeExpr)? ~ (SEMICOLON | Block)
}
ParamDeclList = { (ParamDecl ~ COMMA)* ~ (ParamDecl | DOT3)? }
ParamDecl = { HeaderList? ~ BindingIdent ~ COLON ~ TypeExpr }
// 变量声明（支持修饰符、元组解构与类型推导）
VarDecl = { DeclHeader ~ KEYWORD_var ~ VarBody }
ConstDecl = { DeclHeader ~ KEYWORD_const ~ VarBody }
VarBody = { VarPattern ~ (COLON ~ TypeExpr)? ~ (EQUAL ~ Expr)? }
// 类型声明（支持修饰符）
TypeDecl = { DeclHeader ~ KEYWORD_type ~ IDENTIFIER ~ EQUAL ~ TypeExpr }
// 容器成员（支持修饰符）
MemberDecl = { DeclHeader ~ IDENTIFIER ~ (COLON ~ TypeExpr)? ~ (EQUAL ~ Expr)? }
// 变量声明左值模式（允许单独标识符）
VarPattern = { VarPatternAtom ~ (COMMA ~ VarPatternAtom)* }
VarPatternAtom = {
BindingIdent
| DOT ~ IDENTIFIER ~ (LBRACKET ~ VarPattern ~ RBRACKET)?
| LPAREN ~ VarPattern ~ RPAREN
}
// 匹配模式（不允许单独标识符）
MatchPattern = { MatchPatternAtom ~ (COMMA ~ MatchPatternAtom)* }
MatchPatternAtom = {
UNDERSCORE
| Expr
| DOT ~ IDENTIFIER ~ (LBRACKET ~ MatchPattern ~ RBRACKET)?
| LPAREN ~ MatchPattern ~ RPAREN
}
// 块内语句
Block = { LBRACE ~ Statement* ~ Expr? ~ RBRACE }
Statement = {
RetStatement
| BreakStatement
| ContinueStatement
| DeferStatement
| DeclStatement
| ExprStatement
| ComptimeStatement
}
// 声明语句（内部声明已包含 HeaderList）
DeclStatement = { (VarDecl | ConstDecl | TypeDecl) ~ (COMMA | SEMICOLON)? }
ExprStatement = { Expr ~ (COMMA | SEMICOLON)? }
ComptimeStatement = { ComptimeDecl ~ (COMMA | SEMICOLON)? }
RetStatement = { KEYWORD_ret ~ Expr? ~ (COMMA | SEMICOLON)? }
BreakStatement = { KEYWORD_break ~ Label? ~ Expr? ~ (COMMA | SEMICOLON)? }
ContinueStatement = { KEYWORD_continue ~ Label? ~ (COMMA | SEMICOLON)? }
DeferStatement = { KEYWORD_defer ~ (Block | Statement) ~ (COMMA | SEMICOLON)? }
// 标签定义（$ 前缀）
Label = { DOLLAR ~ IDENTIFIER }
// ============ 表达式 ============
Expr = { AssignExpr }
AssignExpr = { BoolOrExpr ~ (AssignOp ~ AssignExpr)? }
BoolOrExpr = { BoolAndExpr ~ (BOOL_OR ~ BoolAndExpr)* }
BoolAndExpr = { BitOrExpr ~ (BOOL_AND ~ BitOrExpr)* }
BitOrExpr = { BitXorExpr ~ (PIPE ~ BitXorExpr)* }
BitXorExpr = { BitAndExpr ~ (CARET ~ BitAndExpr)* }
BitAndExpr = { CmpEqExpr ~ (AMPERSAND ~ CmpEqExpr)* }
CmpEqExpr = { CmpExpr ~ ((EQ_EQ | BANG_EQUAL) ~ CmpExpr)* }
CmpExpr = { ArrowExpr ~ ((L_ARROW_EQ | L_ARROW | R_ARROW_EQ | R_ARROW) ~ ArrowExpr)* }
ArrowExpr = { RangeExpr ~ ((THIN_R_ARROW | THIN_L_ARROW | FAT_D_ARROW | THIN_D_ARROW) ~ RangeExpr)* }
RangeExpr = { ShiftExpr ~ (DOT2 ~ ShiftExpr?)? }
ShiftExpr = { AddExpr ~ ((L_ARROW2_EQ | L_ARROW2 | R_ARROW2_EQ | R_ARROW2) ~ AddExpr)* }
AddExpr = { MulExpr ~ ((PLUS | MINUS) ~ MulExpr)* }
MulExpr = { PrefixExpr ~ ((ASTERISK | SLASH | PERCENT) ~ PrefixExpr)* }
PrefixExpr = { PrefixOp* ~ PostfixExpr }
PrefixOp = { MINUS | BANG | TILDE | AMPERSAND }
PostfixExpr = {
PrimaryExpr ~ (LPAREN ~ ExprList ~ RPAREN | DOT ~ IDENTIFIER | DOT ~ ASTERISK | LBRACKET ~ Expr ~ RBRACKET | LBRACKET ~ Expr ~ DOT2 ~ Expr? ~ RBRACKET | KEYWORD_as ~ TypeExpr)*
}
ExprList = { (Expr ~ COMMA)* ~ Expr? }
PrimaryExpr = {
FLOAT_LITERAL
| INTEGER_LITERAL
| CHAR_LITERAL
| STRING_LITERAL
| KEYWORD_true
| KEYWORD_false
| KEYWORD_null
| TupleLiteral
| AggregateLiteral
| AnonymousAggregateLiteral
| ArrayLiteral
| AnonymousArrayLiteral
| ComptimeCallExpr // @name(args)
| IDENTIFIER
| Block
| IfExpr
| IfVarExpr
| WhileExpr
| LoopExpr
| ForExpr
| MatchExpr
| FnTypeExpr
}
TupleLiteral = { ParenExpr }
// ============ 聚合字面量 ============
AggregateLiteral = { IDENTIFIER ~ LBRACE ~ StructInitList? ~ RBRACE }
AnonymousAggregateLiteral = { DOT ~ LBRACE ~ StructInitList? ~ RBRACE }
StructInitList = { StructInit ~ ((COMMA | SEMICOLON) ~ StructInit)* ~ (COMMA | SEMICOLON)? }
StructInit = { DOT ~ IDENTIFIER ~ (EQUAL ~ Expr)? }
// ============ 数组/切片字面量 ============
ArrayLiteral = {
// 切片字面量: []T[1,2,3]
// 数组字面量: [N]T[1,2,3] 或 [_]T[1,2,3]
LBRACKET ~ (INTEGER_LITERAL | UNDERSCORE)? ~ RBRACKET ~ TypeExpr ~ LBRACKET ~ ExprList? ~ RBRACKET
}
AnonymousArrayLiteral = {
DOT ~ LBRACKET ~ ExprList? ~ RBRACKET
}
// ============ 类型表达式（独立，限制语法） ============
TypeExpr = { HeaderList? ~ TypePrefixExpr }
TypePrefixExpr = { ASTERISK* ~ TypePostfixExpr }
TypePostfixExpr = {
TypePrimary ~ (LPAREN ~ TypeExprList ~ RPAREN | DOT ~ IDENTIFIER | LBRACKET ~ TypeExpr ~ RBRACKET | KEYWORD_as ~ TypeExpr)*
}
TypePrimary = {
IDENTIFIER
| KEYWORD_i8
| KEYWORD_u8
| KEYWORD_i16
| KEYWORD_u16
| KEYWORD_i32
| KEYWORD_u32
| KEYWORD_i64
| KEYWORD_u64
| KEYWORD_f32
| KEYWORD_f64
| KEYWORD_isize
| KEYWORD_usize
| KEYWORD_bool
| KEYWORD_void
| KEYWORD_ptr
| FnTypeExpr
| AggregateTypeExpr
| TypeParenExpr
| ArrayTypeExpr
}
ArrayTypeExpr = {
LBRACKET ~ RBRACKET ~ TypeExpr
| LBRACKET ~ (INTEGER_LITERAL | UNDERSCORE) ~ RBRACKET ~ TypeExpr
}
TypeParenExpr = {
LPAREN ~ RPAREN
| LPAREN ~ TypeExpr ~ COMMA ~ (TypeExpr ~ COMMA)* ~ TypeExpr? ~ RPAREN
| LPAREN ~ TypeExpr ~ RPAREN
}
TypeExprList = { (TypeExpr ~ COMMA)* ~ TypeExpr? }
FnTypeExpr = { KEYWORD_comptime? ~ KEYWORD_fn ~ LPAREN ~ TypeExprList? ~ RPAREN ~ (COLON ~ TypeExpr)? }
AggregateTypeExpr = { (KEYWORD_struct | KEYWORD_union | KEYWORD_enum | KEYWORD_shape) ~ LBRACE ~ ContainerMembers ~ RBRACE }
// ============ 控制流 ============
IfExpr = { KEYWORD_if ~ Expr ~ Block ~ (KEYWORD_else ~ (Block | IfExpr | IfVarExpr))? }
IfVarExpr = { KEYWORD_if ~ VarBody ~ Block ~ (KEYWORD_else ~ (Block | IfExpr | IfVarExpr))? }
WhileExpr = { Label? ~ KEYWORD_while ~ Expr ~ Block ~ (KEYWORD_else ~ (Block | Expr))? }
LoopExpr = { Label? ~ KEYWORD_loop ~ Block }
ForExpr = { Label? ~ KEYWORD_for ~ Expr ~ (COMMA ~ Expr)* ~ KEYWORD_as ~ BindingIdent ~ (COMMA ~ BindingIdent)* ~ Block ~ (KEYWORD_else ~ (Block | Expr))? }
MatchExpr = { KEYWORD_match ~ Expr ~ LBRACE ~ MatchArm* ~ RBRACE }
MatchArm = { MatchPattern ~ (COMMA ~ MatchPattern)* ~ FAT_R_ARROW ~ Block }
// ============ 其他表达式 ============
ComptimeCallExpr = { AT ~ IDENTIFIER ~ LPAREN ~ ExprList? ~ RPAREN }
ParenExpr = {
| LPAREN ~ Expr ~ COMMA ~ (Expr ~ COMMA)* ~ Expr? ~ RPAREN
| LPAREN ~ Expr ~ RPAREN
}
// ============ Token 定义 ============
AssignOp = { EQUAL | PLUS_EQ | MINUS_EQ | ASTERISK_EQ | SLASH_EQ | PERCENT_EQ | AMPERSAND_EQ | PIPE_EQ | CARET_EQ | L_ARROW2_EQ | R_ARROW2_EQ }
BOOL_OR = { PIPE ~ PIPE }
BOOL_AND = { AMPERSAND ~ AMPERSAND }
EQ_EQ = { EQUAL ~ EQUAL }
BANG_EQUAL = { BANG ~ EQUAL }
keyword_suffix = _{ !(ASCII_ALPHANUMERIC | "_") }
KEYWORD_fn = @{ "fn" ~ keyword_suffix }
KEYWORD_type = @{ "type" ~ keyword_suffix }
KEYWORD_pub = @{ "pub" ~ keyword_suffix }
KEYWORD_var = @{ "var" ~ keyword_suffix }
KEYWORD_const = @{ "const" ~ keyword_suffix }
KEYWORD_if = @{ "if" ~ keyword_suffix }
KEYWORD_else = @{ "else" ~ keyword_suffix }
KEYWORD_while = @{ "while" ~ keyword_suffix }
KEYWORD_loop = @{ "loop" ~ keyword_suffix }
KEYWORD_for = @{ "for" ~ keyword_suffix }
KEYWORD_as = @{ "as" ~ keyword_suffix }
KEYWORD_match = @{ "match" ~ keyword_suffix }
KEYWORD_ret = @{ "ret" ~ keyword_suffix }
KEYWORD_break = @{ "break" ~ keyword_suffix }
KEYWORD_continue = @{ "continue" ~ keyword_suffix }
KEYWORD_defer = @{ "defer" ~ keyword_suffix }
KEYWORD_shape = @{ "shape" ~ keyword_suffix }
KEYWORD_struct = @{ "struct" ~ keyword_suffix }
KEYWORD_union = @{ "union" ~ keyword_suffix }
KEYWORD_enum = @{ "enum" ~ keyword_suffix }
KEYWORD_comptime = @{ "comptime" ~ keyword_suffix }
KEYWORD_void = @{ "void" ~ keyword_suffix }
KEYWORD_bool = @{ "bool" ~ keyword_suffix }
KEYWORD_isize = @{ "isize" ~ keyword_suffix }
KEYWORD_usize = @{ "usize" ~ keyword_suffix }
KEYWORD_ptr = @{ "ptr" ~ keyword_suffix }
KEYWORD_true = @{ "true" ~ keyword_suffix }
KEYWORD_false = @{ "false" ~ keyword_suffix }
KEYWORD_null = @{ "null" ~ keyword_suffix }
KEYWORD_undefined = @{ "undefined" ~ keyword_suffix }
KEYWORD_i8 = @{ "i8" ~ keyword_suffix }
KEYWORD_u8 = @{ "u8" ~ keyword_suffix }
KEYWORD_i16 = @{ "i16" ~ keyword_suffix }
KEYWORD_u16 = @{ "u16" ~ keyword_suffix }
KEYWORD_i32 = @{ "i32" ~ keyword_suffix }
KEYWORD_u32 = @{ "u32" ~ keyword_suffix }
KEYWORD_i64 = @{ "i64" ~ keyword_suffix }
KEYWORD_u64 = @{ "u64" ~ keyword_suffix }
KEYWORD_f32 = @{ "f32" ~ keyword_suffix }
KEYWORD_f64 = @{ "f64" ~ keyword_suffix }
FAT_D_ARROW = { "<=>" }
THIN_D_ARROW = { "<->" }
L_ARROW2_EQ = { "<<=" }
R_ARROW2_EQ = { ">>=" }
DOT3 = { "..." }
THIN_R_ARROW = { "<-" }
THIN_L_ARROW = { "->" }
L_ARROW_EQ = { "<=" }
R_ARROW_EQ = { ">=" }
L_ARROW2 = { "<<" }
R_ARROW2 = { ">>" }
FAT_R_ARROW = { "=>" }
PLUS_EQ = { "+=" }
MINUS_EQ = { "-=" }
ASTERISK_EQ = { "*=" }
SLASH_EQ = { "/=" }
PERCENT_EQ = { "%=" }
AMPERSAND_EQ = { "&=" }
PIPE_EQ = { "|=" }
CARET_EQ = { "^=" }
DOT2 = { ".." }
LPAREN = { "(" }
RPAREN = { ")" }
LBRACKET = { "[" }
RBRACKET = { "]" }
LBRACE = { "{" }
RBRACE = { "}" }
COMMA = { "," }
SEMICOLON = { ";" }
COLON = { ":" }
DOT = { "." }
AT = { "@" }
SHARP = { "#" }
DOLLAR = { "$" }
EQUAL = { "=" }
PLUS = { "+" }
MINUS = { "-" }
ASTERISK = { "*" }
SLASH = { "/" }
PERCENT = { "%" }
AMPERSAND = { "&" }
PIPE = { "|" }
CARET = { "^" }
TILDE = { "~" }
BANG = { "!" }
L_ARROW = { "<" }
R_ARROW = { ">" }
UNDERSCORE = { "_" }
keyword = _{
KEYWORD_fn
| KEYWORD_type
| KEYWORD_var
| KEYWORD_const
| KEYWORD_if
| KEYWORD_else
| KEYWORD_while
| KEYWORD_loop
| KEYWORD_for
| KEYWORD_as
| KEYWORD_match
| KEYWORD_ret
| KEYWORD_break
| KEYWORD_continue
| KEYWORD_defer
| KEYWORD_shape
| KEYWORD_struct
| KEYWORD_union
| KEYWORD_enum
| KEYWORD_comptime
| KEYWORD_void
| KEYWORD_bool
| KEYWORD_true
| KEYWORD_false
| KEYWORD_null
| KEYWORD_undefined
| KEYWORD_i8
| KEYWORD_u8
| KEYWORD_i16
| KEYWORD_u16
| KEYWORD_i32
| KEYWORD_u32
| KEYWORD_i64
| KEYWORD_u64
| KEYWORD_f32
| KEYWORD_f64
| KEYWORD_isize
| KEYWORD_usize
| KEYWORD_ptr
}
IDENTIFIER = @{
!(keyword ~ !(ASCII_ALPHANUMERIC | "_")) ~ (ASCII_ALPHA | "_" ~ (ASCII_ALPHANUMERIC | "_")) ~ (ASCII_ALPHANUMERIC | "_")*
}
INTEGER_LITERAL = { DECIMAL | HEX | BINARY | OCTAL | "0" }
DECIMAL = { ASCII_NONZERO_DIGIT ~ (ASCII_DIGIT | "_")* }
HEX = { "0" ~ ("x" | "X") ~ ASCII_HEX_DIGIT ~ (ASCII_HEX_DIGIT | "_")* }
BINARY = { "0" ~ ("b" | "B") ~ ASCII_BIN_DIGIT ~ (ASCII_BIN_DIGIT | "_")* }
OCTAL = { "0" ~ ("o" | "O") ~ ASCII_OCT_DIGIT ~ (ASCII_OCT_DIGIT | "_")* }
FLOAT_LITERAL = { ASCII_DIGIT ~ "." ~ ASCII_DIGIT ~ (ASCII_DIGIT | "_")* }
CHAR_LITERAL = { "'" ~ (!"'" ~ ANY) ~ "'" }
STRING_LITERAL = { "\"" ~ ANY* ~ "\"" }
COMMENT = _{ LINE_COMMENT | BLOCK_COMMENT }
LINE_COMMENT = { "//" ~ (!"\n" ~ ANY)* }
BLOCK_COMMENT = { "/*" ~ ANY* ~ "*/" }
WHITESPACE = _{ " " | "\t" | "\r" | "\n" }
nob.c
+177 -17
View File
@@ -1,9 +1,11 @@
#undef UNICODE
#define NOB_IMPLEMENTATION
#define SPL_CFLAGS "-Wall", "-Wextra", "-O0", "-g", "-D_CRT_SECURE_NO_WARNINGS"
#define nob_cc_flags(cmd) nob_cmd_append(cmd, SPL_CFLAGS)
#undef UNICODE
#define NOB_IMPLEMENTATION
#include "nob.h"
#undef NOB_IMPLEMENTATION
#include "nob_popen.h"
#ifdef _WIN32
#include <consoleapi2.h>
#endif
@@ -15,28 +17,38 @@
// object files get rebuilt.
static const char *CFLAGS_STAMP = BUILD_FOLDER ".cflags";
/* clang-format off */
#define VM_SRCS "stage0/spl_mcode.c", "stage0/spl_syscall.c", "stage0/spl_vm.c"
static const char *spl_cli_srcs[] = {"stage0/spl_cli.c", VM_SRCS};
static const char *test_srcs[] = {"stage0/test_spl_vm.c", VM_SRCS};
static const char *splc0_srcs[] = {
"stage1/splc0.c", "stage0/spl_mcode.c", "stage1/spl_ast.c", "stage1/spl_lexer.c",
"stage1/spl_dumptree.c", "stage1/spl_type.c", "stage1/spl_sema.c", "stage1/spl_ir.c",
"stage1/spl_ast2ir.c", "stage1/spl_ir2vm.c",
"stage1/splc0.c",
"stage1/spl_lexer.c",
"stage1/spl_ast.c",
"stage1/spl_dumptree.c",
"stage1/spl_type.c",
"stage1/spl_sema.c",
// "stage1/spl_ir.c",
// "stage1/spl_ast2ir.c",
// "stage1/spl_ir2vm.c",
// "stage0/spl_mcode.c",
};
/* clang-format on */
typedef struct {
const char *name;
const char **srcs;
size_t srcs_count;
} Exe_Target;
} target_t;
static Exe_Target exe_targets[] = {
static target_t exe_targets[] = {
{"spl_cli", spl_cli_srcs, NOB_ARRAY_LEN(spl_cli_srcs)},
{"test", test_srcs, NOB_ARRAY_LEN(test_srcs)},
{"splc0", splc0_srcs, NOB_ARRAY_LEN(splc0_srcs)},
};
static const Exe_Target *find_exe_target(const char *name) {
static const target_t *find_exe_target(const char *name) {
for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
if (strcmp(exe_targets[i].name, name) == 0) {
return &exe_targets[i];
@@ -105,7 +117,7 @@ static bool build_object(const char *src) {
return nob_cmd_run(&cmd);
}
static bool link_exe(const Exe_Target *target) {
static bool link_exe(const target_t *target) {
const char *exe = nob_temp_sprintf(BUILD_FOLDER "%s", target->name);
const char **objs = (const char **)nob_temp_alloc(sizeof(const char *) * target->srcs_count);
for (size_t i = 0; i < target->srcs_count; ++i) {
@@ -129,7 +141,7 @@ static bool link_exe(const Exe_Target *target) {
}
static bool build_target(const char *name) {
const Exe_Target *target = find_exe_target(name);
const target_t *target = find_exe_target(name);
if (target == NULL) {
nob_log(NOB_ERROR, "unknown target `%s`", name);
return false;
@@ -152,6 +164,143 @@ static bool build_all(void) {
return true;
}
static void parse_expect(const char *name, Nob_Cmd_Result *expect) {
Nob_String_Builder sb = {0};
nob_read_entire_file(name, &sb);
Nob_String_View sv = nob_sb_to_sv(sb);
while (sv.count > 0) {
Nob_String_View line = nob_sv_chop_by_delim(&sv, '\n');
line = nob_sv_trim_left(line); // 去掉前导空格
if (!nob_sv_starts_with(line, nob_sv_from_cstr("//"))) {
break;
}
Nob_String_View rest = nob_sv_from_parts(line.data + 2, line.count - 2);
rest = nob_sv_trim_left(rest);
if (rest.count == 0)
continue;
if (nob_sv_starts_with(rest, nob_sv_from_cstr("Expect"))) {
break;
}
rest = nob_sv_from_parts(rest.data + 6, rest.count - 6);
rest = nob_sv_trim_left(rest);
// 按 '=' 分割
Nob_String_View key = nob_sv_chop_by_delim(&rest, '=');
key = nob_sv_trim(key);
Nob_String_View value = nob_sv_trim(rest);
if (nob_sv_eq(key, nob_sv_from_cstr("retcode"))) {
int val = 0;
for (size_t i = 0; i < value.count && isdigit(value.data[i]); ++i) {
val = val * 10 + (value.data[i] - '0');
}
expect->exit_code = val;
} else if (nob_sv_eq(key, nob_sv_from_cstr("stdout"))) {
}
}
}
static bool test_once(const char *fname) {
const char *compiler_path = "splc0";
const char *cli_path = "spl_cli";
const char *target_sir = BUILD_FOLDER "test.sir";
Nob_Cmd cmd = {0};
if (!build_target(compiler_path)) {
return 1;
}
cmd.count = 0;
nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", compiler_path));
nob_cmd_append(&cmd, fname, target_sir);
if (!nob_cmd_run(&cmd)) {
return false;
}
if (!build_target(cli_path)) {
return 1;
}
cmd.count = 0;
nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", cli_path));
nob_cmd_append(&cmd, target_sir);
nob_cmd_run(&cmd);
Nob_Cmd_Result result = {0};
Nob_String_Builder cmd_str = {0};
nob_cmd_render(cmd, &cmd_str);
nob_sb_append_null(&cmd_str);
nob_cmd_capture_popen(cmd_str.items, &result);
// Expect retcode = number
Nob_Cmd_Result expect = {0};
parse_expect(fname, &expect);
if (expect.exit_code != result.exit_code) {
nob_log(NOB_ERROR, "Expect code `%d`, Result code `%d`\n", expect.exit_code,
result.exit_code);
return false;
}
nob_cmd_result_free(result);
return true;
}
static bool test_once_ast(const char *fname) {
const char *target_name = "splc0";
if (!prepare_build())
return 1;
if (!build_target(target_name))
return 1;
Nob_Cmd cmd = {0};
nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", target_name));
nob_cmd_append(&cmd, "--dump", "ast", fname, BUILD_FOLDER "t.sir");
return nob_cmd_run(&cmd);
}
static bool test_once_sema(const char *fname) {
const char *target_name = "splc0";
if (!prepare_build())
return 1;
if (!build_target(target_name))
return 1;
Nob_Cmd cmd = {0};
nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", target_name));
nob_cmd_append(&cmd, "--dump", "sema", fname, BUILD_FOLDER "t.sir");
return nob_cmd_run(&cmd);
}
typedef bool (*test_fn_t)(const char *fname);
static bool run_test(Nob_Files *files, test_fn_t test_once) {
const char *test_folder = "./tests/stage1/";
Nob_File_Paths paths = {0};
nob_read_entire_dir(test_folder, &paths);
for (int i = 0; i < files->count; i += 1) {
for (int j = 0; j < paths.count; j += 1) {
String_View sv = sv_from_cstr(paths.items[j]);
// printf("--- test " SV_Fmt " ---\n", SV_Arg(sv));
if (!strstr(paths.items[j], files->items[i])) {
continue;
}
const char *tname = nob_temp_sprintf("%s%s", test_folder, paths.items[j]);
printf("--- test %s ---\n", tname);
if (test_once(tname) == false)
return false;
}
}
if (!prepare_build()) {
return 1;
}
return true;
}
static bool delete_walk_entry(Nob_Walk_Entry entry) { return nob_delete_file(entry.path); }
static bool delete_directory_recursively(const char *dir_path) {
@@ -225,13 +374,24 @@ int main(int argc, char **argv) {
}
if (strcmp(command_name, "test") == 0) {
if (!prepare_build())
return 1;
if (!build_target("test"))
return 1;
Nob_Cmd cmd = {0};
nob_cmd_append(&cmd, BUILD_FOLDER "test");
return nob_cmd_run(&cmd) ? 0 : 1;
Nob_Files files = {0};
test_fn_t tfn = test_once;
if (argc > 0) {
const char *mode_name = nob_shift(argv, argc);
if (strcmp(mode_name, "ast") == 0) {
tfn = test_once_ast;
} else if (strcmp(mode_name, "sema") == 0) {
tfn = test_once_sema;
} else {
da_append(&files, mode_name);
}
}
while (argc > 0) {
da_append(&files, nob_shift(argv, argc));
}
return run_test(&files, tfn) ? 0 : 1;
}
if (strcmp(command_name, "clean") == 0) {
nob.h
+1
View File
@@ -1,3 +1,4 @@
// clang-format off
/* nob - v3.10.0 - Public Domain - https://github.com/tsoding/nob.h
This library is the next generation of the [NoBuild](https://github.com/tsoding/nobuild) idea.
nob_popen.h
+54
View File
@@ -0,0 +1,54 @@
#ifndef __NOB_POPEN_H__
#define __NOB_POPEN_H__
#include "nob.h"
typedef struct {
Nob_String_Builder out; // stdout 内容
int exit_code; // 实际退出码
bool ok; // 是否成功启动
} Nob_Cmd_Result;
typedef struct {
const char **items;
int capacity;
int count;
} Nob_Files;
// 运行命令，捕获 stdout 和退出码（不支持 stdin 和 stderr）
bool nob_cmd_capture_popen(const char *tname, Nob_Cmd_Result *res) {
memset(res, 0, sizeof(*res));
#ifdef _WIN32
FILE *fp = _popen(tname, "r");
#else
FILE *fp = popen(tname, "r");
#endif
if (!fp) {
nob_log(NOB_ERROR, "popen failed");
return false;
}
// 读取输出到 String_Builder
char buffer[4096];
while (fgets(buffer, sizeof(buffer), fp)) {
nob_sb_append_cstr(&res->out, buffer);
}
// 获取退出码
#ifdef _WIN32
res->exit_code = _pclose(fp);
#else
res->exit_code = pclose(fp);
if (WIFEXITED(res->exit_code))
res->exit_code = WEXITSTATUS(res->exit_code);
#endif
res->ok = true;
return true;
}
#define nob_cmd_result_free(res) nob_sb_free((res).out)
#endif /* __NOB_POPEN_H__ */
stage1/spl_ast.c
+1994 -1566
View File
File diff suppressed because it is too large. Load diff
stage1/spl_ast.h
+424 -241
View File
@@ -7,134 +7,147 @@
#include "spl_tok.h"
/* clang-format off */
#define SPL_AST_KIND_TABLE \
X(SPL_AST_NONE, V0, none) \
X(SPL_AST_CONTAINER_MEMBERS, V0, container_members) \
X(SPL_AST_FN_DECL, V0, fn_decl) \
X(SPL_AST_FN_DEFINE, V0, fn_define) \
X(SPL_AST_TYPE_DECL, V0, type_decl) \
X(SPL_AST_VAR_DECL, V0, var_decl) \
X(SPL_AST_CONST_DECL, V0, const_decl) \
X(SPL_AST_MEMBER_DECL, V0, member_decl) \
X(SPL_AST__COMPTIME_STMT, V0, comptime_stmt) \
X(SPL_AST__DIRECTIVE_BLOCK, V0, directive_block) \
X(SPL_AST_PARAM_DECL, V0, param_decl) \
X(SPL_AST_ATTR_ITEM, V0, attr_item) \
X(SPL_AST_ARGG_INIT_ITEM, V0, argg_init_item) \
X(SPL_AST_IF_STATEMENT, V0, if_statement) \
X(SPL_AST_IFVAR_STATEMENT, V0, ifvar_statement) \
X(SPL_AST_WHILE_STATEMENT, V0, while_statement) \
X(SPL_AST_LOOP_STATEMENT, V0, loop_statement) \
X(SPL_AST_FOR_STATEMENT, V0, for_statement) \
X(SPL_AST_MATCH_STATEMENT, V0, match_statement) \
X(SPL_AST_RET_STATEMENT, V0, ret_statement) \
X(SPL_AST_BREAK_STATEMENT, V0, break_statement) \
X(SPL_AST_CONTINUE_STATEMENT, V0, continue_statement) \
X(SPL_AST_DEFER_STATEMENT, V0, defer_statement) \
X(SPL_AST_TRY_STATEMENT, V0, try_statement) \
X(SPL_AST_CATCH_STATEMENT, V0, catch_statement) \
X(SPL_AST_ERRDEFER_STATEMEMT, V0, errdefer_statement) \
X(SPL_AST_EXPR_STATEMENT, V0, expr_statement) \
X(SPL_AST_PACKED_EXPR, V0, packed_expr) \
X(SPL_AST_ASSIGN_EXPR, V0, assign_expr) \
X(SPL_AST_ASSIGN_ADD_EXPR, V0, assign_add_expr) \
X(SPL_AST_ASSIGN_SUB_EXPR, V0, assign_sub_expr) \
X(SPL_AST_ASSIGN_MUL_EXPR, V0, assign_mul_expr) \
X(SPL_AST_ASSIGN_DIV_EXPR, V0, assign_div_expr) \
X(SPL_AST_ASSIGN_MOD_EXPR, V0, assign_mod_expr) \
X(SPL_AST_ASSIGN_AND_EXPR, V0, assign_and_expr) \
X(SPL_AST_ASSIGN_OR_EXPR, V0, assign_or_expr) \
X(SPL_AST_ASSIGN_XOR_EXPR, V0, assign_xor_expr) \
X(SPL_AST_ASSIGN_LSHIFT_EXPR, V0, assign_lshift_expr) \
X(SPL_AST_ASSIGN_RSHIFT_EXPR, V0, assign_rshift_expr) \
X(SPL_AST_BOOL_OR_EXPR, V0, bool_or_expr) \
X(SPL_AST_BOOL_AND_EXPR, V0, bool_and_expr) \
X(SPL_AST_BIT_OR_EXPR, V0, bit_or_expr) \
X(SPL_AST_BIT_XOR_EXPR, V0, bit_xor_expr) \
X(SPL_AST_BIT_AND_EXPR, V0, bit_and_expr) \
X(SPL_AST_CMP_EQ_EXPR, V0, cmp_eq_expr) \
X(SPL_AST_CMP_NE_EXPR, V0, cmp_ne_expr) \
X(SPL_AST_CMP_LE_EXPR, V0, cmp_le_expr) \
X(SPL_AST_CMP_GE_EXPR, V0, cmp_ge_expr) \
X(SPL_AST_CMP_LT_EXPR, V0, cmp_lt_expr) \
X(SPL_AST_CMP_GT_EXPR, V0, cmp_gt_expr) \
X(SPL_AST_RANGE_EXPR, V0, range_expr) \
X(SPL_AST_LSHIFT_EXPR, V0, lshift_expr) \
X(SPL_AST_RSHIFT_EXPR, V0, rshift_expr) \
X(SPL_AST_ADD_EXPR, V0, add_expr) \
X(SPL_AST_SUB_EXPR, V0, sub_expr) \
X(SPL_AST_MUL_EXPR, V0, mul_expr) \
X(SPL_AST_DIV_EXPR, V0, div_expr) \
X(SPL_AST_MOD_EXPR, V0, mod_expr) \
X(SPL_AST_MINUS_EXPR, V0, minus_expr) \
X(SPL_AST_NOT_EXPR, V0, not_expr) \
X(SPL_AST_BIT_NOT_EXPR, V0, bit_not_expr) \
X(SPL_AST_ADDRESS_EXPR, V0, address_expr) \
X(SPL_AST_CALL_EXPR, V0, call_expr) \
X(SPL_AST_FIELD_EXPR, V0, field_expr) \
X(SPL_AST_DEREF_EXPR, V0, deref_expr) \
X(SPL_AST_INDEX_EXPR, V0, index_expr) \
X(SPL_AST_SLICE_EXPR, V0, slice_expr) \
X(SPL_AST_AS_EXPR, V0, as_expr) \
X(SPL_AST_EXPR_INTEGER_LIT, V0, integer_lit) \
X(SPL_AST_EXPR_FLOAT_LIT, V0, float_lit) \
X(SPL_AST_EXPR_CHAR_LIT, V0, char_lit) \
X(SPL_AST_EXPR_STRING_LIT, V0, string_lit) \
X(SPL_AST_EXPR_TRUE, V0, true_lit) \
X(SPL_AST_EXPR_FALSE, V0, false_lit) \
X(SPL_AST_EXPR_NULL, V0, null_lit) \
X(SPL_AST_EXPR_UNDEFINED, V0, undefined_lit) \
X(SPL_AST_EXPR_IDENT, V0, ident_expr) \
X(SPL_AST_ARGGREGATE_INIT, V0, aggregate_init) \
X(SPL_AST_EXPR_EXPR, V0, expr_expr) \
X(SPL_AST_ARRAY_LIT, V0, array_lit) \
X(SPL_AST_BUILTIN_EXPR, V0, builtin_expr) \
X(SPL_AST_BLOCK_EXPR, V0, block_expr) \
X(SPL_AST_BASE_TYPE_FN, V0, base_type_fn) \
X(SPL_AST_BASE_TYPE_PATH, V0, base_type_path) \
X(SPL_AST_TYPE_POINTER, V0, type_pointer) \
X(SPL_AST_TYPE_ARRAY, V0, type_array) \
X(SPL_AST_TYPE_SLICE, V0, type_slice) \
X(SPL_AST_TYPE_STRUCT, V0, type_struct) \
X(SPL_AST_TYPE_UNION, V0, type_union) \
X(SPL_AST_TYPE_SHAPE, V0, type_shape) \
X(SPL_AST_TYPE_ENUM, V0, type_enum) \
X(SPL_AST_TYPE_VOID, V0, type_void) \
X(SPL_AST_TYPE_BOOL, V0, type_bool) \
X(SPL_AST_TYPE_OPAQUE, V0, type_opaque) \
X(SPL_AST_TYPE_I8, V0, type_i8) \
X(SPL_AST_TYPE_U8, V0, type_u8) \
X(SPL_AST_TYPE_I16, V0, type_i16) \
X(SPL_AST_TYPE_U16, V0, type_u16) \
X(SPL_AST_TYPE_I32, V0, type_i32) \
X(SPL_AST_TYPE_U32, V0, type_u32) \
X(SPL_AST_TYPE_I64, V0, type_i64) \
X(SPL_AST_TYPE_U64, V0, type_u64) \
X(SPL_AST_TYPE_ISIZE, V0, type_isize) \
X(SPL_AST_TYPE_USIZE, V0, type_usize) \
X(SPL_AST_TYPE__F32, V0, type_f32) \
X(SPL_AST_TYPE__F64, V0, type_f64) \
X(SPL_AST_TYPE_ANY, V0, type_any) \
X(SPL_AST_TYPE_IDENT, V0, type_ident) \
/* clang-format on*/
#define SPL_AST_KIND_TABLE \
X(SPL_AST_NONE, V0, none) \
X(SPL_AST_ROOT, V0, root) \
X(SPL_AST_CONTAINER_MEMBERS, V0, container_members) \
X(SPL_AST_EXTERNAL_TAG_ITEM, V0, external_tag_item) \
X(SPL_AST_TAG_ITEM, V0, tag_item) \
X(SPL_AST_COMPTIME_DECL, V0, comptime_decl) \
X(SPL_AST_TOP_LEVEL_BLOCK, V0, top_level_block) \
X(SPL_AST_FN_DECL, V0, fn_decl) \
X(SPL_AST_VAR_DECL, V0, var_decl) \
X(SPL_AST_CONST_DECL, V0, const_decl) \
X(SPL_AST_TYPE_DECL, V0, type_decl) \
X(SPL_AST_MEMBER_DECL, V0, member_decl) \
X(SPL_AST_PARAM_DECL, V0, param_decl) \
X(SPL_AST_STATEMENT_RET, V0, statement_ret) \
X(SPL_AST_STATEMENT_BREAK, V0, statement_break) \
X(SPL_AST_STATEMENT_CONTINUE, V0, statement_continue) \
X(SPL_AST_STATEMENT_DEFER, V0, statement_defer) \
X(SPL_AST_STATEMENT_COMPTIME, V0, statement_comptime) \
X(SPL_AST_STATEMENT_DECL, V0, statement_decl) \
X(SPL_AST_STATEMENT_EXPR, V0, statement_expr) \
X(SPL_AST_AGGREGATE_MEMBER, V0, aggregate_member) \
X(SPL_AST_STRUCT_INIT_ITEM, V0, struct_init_item) \
X(SPL_AST_MATCH_ARM, V0, match_arm) \
X(SPL_AST_LABEL, V0, label) \
X(SPL_AST_EXPR_INT_LIT, V0, int_lit) \
X(SPL_AST_EXPR_FLOAT_LIT, V0, float_lit) \
X(SPL_AST_EXPR_CHAR_LIT, V0, char_lit) \
X(SPL_AST_EXPR_STRING_LIT, V0, string_lit) \
X(SPL_AST_EXPR_BOOL_LIT, V0, bool_lit) \
X(SPL_AST_EXPR_NULL_LIT, V0, null_lit) \
X(SPL_AST_EXPR_UNDEFINED_LIT, V0, undefined_lit) \
X(SPL_AST_EXPR_IDENT, V0, ident) \
X(SPL_AST_EXPR_UNARY, V0, unary) \
X(SPL_AST_EXPR_BINARY, V0, binary) \
X(SPL_AST_EXPR_CALL, V0, call) \
X(SPL_AST_EXPR_FIELD, V0, field) \
X(SPL_AST_EXPR_INDEX, V0, index) \
X(SPL_AST_EXPR_SLICE, V0, slice) \
X(SPL_AST_EXPR_CAST, V0, cast) \
X(SPL_AST_EXPR_TUPLE, V0, tuple) \
X(SPL_AST_EXPR_ARRAY_LIT, V0, array_literal) \
X(SPL_AST_EXPR_ANON_ARRAY_LIT, V0, anon_array_literal) \
X(SPL_AST_EXPR_AGGREGATE_LIT, V0, aggregate_literal) \
X(SPL_AST_EXPR_COMPTIME_CALL, V0, comptime_call) \
X(SPL_AST_EXPR_BLOCK, V0, block) \
X(SPL_AST_EXPR_IF, V0, if_expr) \
X(SPL_AST_EXPR_IFVAR, V0, ifvar_expr) \
X(SPL_AST_EXPR_WHILE, V0, while_expr) \
X(SPL_AST_EXPR_LOOP, V0, loop_expr) \
X(SPL_AST_EXPR_FOR, V0, for_expr) \
X(SPL_AST_EXPR_MATCH, V0, match_expr) \
X(SPL_AST_EXPR_FN_TYPE, V0, fn_type) \
X(SPL_AST_TYPE_PATH, V0, type_path) \
X(SPL_AST_TYPE_POINTER, V0, type_pointer) \
X(SPL_AST_TYPE_ARRAY, V0, type_array) \
X(SPL_AST_TYPE_SLICE, V0, type_slice) \
X(SPL_AST_TYPE_FN, V0, type_fn) \
X(SPL_AST_TYPE_PAREN, V0, type_paren) \
X(SPL_AST_TYPE_AGGREGATE, V0, type_aggregate) \
X(SPL_AST_TYPE_COMPTIME_CALL, V0, type_comptime_call) \
X(SPL_AST_PATTERN_IDENT, V0, pattern_ident) \
X(SPL_AST_PATTERN_UNDERSCORE, V0, pattern_underscore) \
X(SPL_AST_PATTERN_DOT, V0, pattern_dot) \
X(SPL_AST_PATTERN_TUPLE, V0, pattern_tuple) \
X(SPL_AST_PATTERN_LIST, V0, pattern_list)
/* clang-format on */
typedef enum {
#ifdef X
#undef X
#endif
#define X(name, ...) name,
#define X(name, ...) name,
SPL_AST_KIND_TABLE
#undef X
SPL_AST_COUNT,
SPL_AST_COUNT,
} spl_ast_node_kind_t;
const char *spl_ast_kind_name(spl_ast_node_kind_t kind);
/* clang-format off */
#define SPL_BINARY_OP_TABLE \
X(SPL_OP_ASSIGN, 1, 'R', =) \
X(SPL_OP_ASSIGN_ADD, 1, 'R', +=) \
X(SPL_OP_ASSIGN_SUB, 1, 'R', -=) \
X(SPL_OP_ASSIGN_MUL, 1, 'R', *=) \
X(SPL_OP_ASSIGN_DIV, 1, 'R', /=) \
X(SPL_OP_ASSIGN_MOD, 1, 'R', %=) \
X(SPL_OP_ASSIGN_AND, 1, 'R', &=) \
X(SPL_OP_ASSIGN_OR, 1, 'R', |=) \
X(SPL_OP_ASSIGN_XOR, 1, 'R', ^=) \
X(SPL_OP_ASSIGN_LSHIFT, 1, 'R', <<=) \
X(SPL_OP_ASSIGN_RSHIFT, 1, 'R', >>=) \
X(SPL_OP_BOOL_OR, 2, 'L', ||) \
X(SPL_OP_BOOL_AND, 3, 'L', &&) \
X(SPL_OP_BIT_OR, 4, 'L', |) \
X(SPL_OP_BIT_XOR, 5, 'L', ^) \
X(SPL_OP_BIT_AND, 6, 'L', &) \
X(SPL_OP_CMP_EQ, 7, 'L', ==) \
X(SPL_OP_CMP_NE, 7, 'L', !=) \
X(SPL_OP_CMP_LE, 8, 'L', <=) \
X(SPL_OP_CMP_GE, 8, 'L', >=) \
X(SPL_OP_CMP_LT, 8, 'L', <) \
X(SPL_OP_CMP_GT, 8, 'L', >) \
X(SPL_OP_ARROW_LEFT, 9, 'L', <-) \
X(SPL_OP_ARROW_RIGHT, 9, 'L', ->) \
X(SPL_OP_ARROW_FAT_BOTH, 9, 'L', <=>) \
X(SPL_OP_ARROW_THIN_BOTH, 9, 'L', <->) \
X(SPL_OP_ARROW_FAT_RIGHT, 9, 'L', =>) \
X(SPL_OP_RANGE, 10, 'L', ..) \
X(SPL_OP_LSHIFT, 11, 'L', <<) \
X(SPL_OP_RSHIFT, 11, 'L', >>) \
X(SPL_OP_ADD, 12, 'L', +) \
X(SPL_OP_SUB, 12, 'L', -) \
X(SPL_OP_MUL, 13, 'L', *) \
X(SPL_OP_DIV, 13, 'L', /) \
X(SPL_OP_MOD, 13, 'L', %)
/* clang-format on */
typedef enum {
#ifdef X
#undef X
#endif
#define X(name, ...) name,
SPL_BINARY_OP_TABLE
#undef X
} spl_binary_op_t;
typedef enum {
SPL_UNARY_OP_MINUS,
SPL_UNARY_OP_NOT,
SPL_UNARY_OP_BIT_NOT,
SPL_UNARY_OP_ADDRESS,
} spl_unary_op_t;
const char *spl_binary_op_name(spl_binary_op_t op);
const char *spl_unary_op_name(spl_unary_op_t op);
struct spl_ast_node;
typedef struct spl_ast_node spl_ast_node_t;
typedef usize spl_ast_node_ref_t;
typedef VEC(spl_ast_node_ref_t) spl_ast_node_ref_vec_t;
struct spl_ast_node {
spl_ast_node_kind_t kind;
spl_dbg_node_t dbg;
@@ -143,168 +156,337 @@ struct spl_ast_node {
usize resolved_def_id;
usize resolved_type_id;
};
union {
spl_ast_node_ref_vec_t container_members; /* container_decl */
/* SPL_AST_ROOT */
struct {
const char *ident;
spl_ast_node_ref_vec_t expr_list;
} attr_item;
spl_ast_node_ref_t members; /* container_members 节点 */
} root;
/* SPL_AST_CONTAINER_MEMBERS */
struct {
spl_ast_node_ref_vec_t attr_list; /* attr_item */
spl_ast_node_ref_vec_t external_tags; /* external_tag_item 节点列表 */
spl_ast_node_ref_vec_t declarations;
} container_members;
/* SPL_AST_FN_DECL */
struct {
spl_ast_node_ref_vec_t tag_list; /* tag_item 节点 */
bool is_comptime;
const char *name;
spl_ast_node_ref_vec_t param_list; /* param_decl */
spl_ast_node_ref_t type_expr; /* ret type expr */
spl_ast_node_ref_t block; /* block_expr */
spl_ast_node_ref_vec_t params; /* param_decl 节点 */
spl_ast_node_ref_t ret_type; /* 类型节点，可空 */
spl_ast_node_ref_t body; /* 表达式节点，可空表示仅声明 */
} fn_decl;
/* SPL_AST_VAR_DECL / SPL_AST_CONST_DECL */
struct {
spl_ast_node_ref_vec_t attr_list; /* attr_item */
spl_ast_node_ref_vec_t attr_list;
spl_ast_node_ref_t pattern; /* 模式节点 */
spl_ast_node_ref_t type; /* 类型节点，可空 */
spl_ast_node_ref_t init_expr; /* 表达式节点，可空 */
} var_const_decl;
/* SPL_AST_TYPE_DECL */
struct {
spl_ast_node_ref_vec_t attr_list;
const char *name;
spl_ast_node_ref_t type_expr; /* 类型节点 */
} type_decl;
/* SPL_AST_MEMBER_DECL */
struct {
spl_ast_node_ref_vec_t attr_list;
const char *name;
spl_ast_node_ref_t type_expr; /* 可空 */
spl_ast_node_ref_t init_expr; /* 可空 */
} member_decl;
/* SPL_AST_PARAM_DECL */
struct {
spl_ast_node_ref_vec_t attr_list;
const char *name;
spl_ast_node_ref_t type_expr;
} param_decl;
/* SPL_AST_TAG_ITEM / SPL_AST_EXTERNAL_TAG_ITEM */
struct {
bool is_at; /* true: @, false: # */
bool is_external; /* true: @!或#! */
const char *name;
spl_ast_node_ref_vec_t args;
} tag_item;
/* SPL_AST_COMPTIME_DECL */
struct {
spl_ast_node_ref_t body; /* block 或 expr 节点 */
} comptime_decl;
/* SPL_AST_TOP_LEVEL_BLOCK */
struct {
spl_ast_node_ref_vec_t tag_list; /* tag_item 节点列表 */
spl_ast_node_ref_t block; /* 表达式节点block */
} top_level_block;
/* SPL_AST_STATEMENT_RET */
struct {
spl_ast_node_ref_t expr; /* 可空 */
} statement_ret;
/* SPL_AST_STATEMENT_BREAK */
struct {
spl_ast_node_ref_t label; /* 可空 */
spl_ast_node_ref_t expr; /* 可空 */
} statement_break;
/* SPL_AST_STATEMENT_CONTINUE */
struct {
spl_ast_node_ref_t label; /* 可空 */
} statement_continue;
/* SPL_AST_STATEMENT_DEFER */
struct {
spl_ast_node_ref_t body; /* block 或 statement 节点 */
} statement_defer;
/* SPL_AST_STATEMENT_COMPTIME */
struct {
spl_ast_node_ref_t body; /* block 或 expr 节点 */
} statement_comptime;
/* SPL_AST_STATEMENT_DECL */
struct {
spl_ast_node_ref_t decl; /* var/const/type 声明节点 */
} statement_decl;
/* SPL_AST_STATEMENT_EXPR */
struct {
spl_ast_node_ref_t expr;
} statement_expr;
/* SPL_AST_AGGREGATE_MEMBER */
struct {
spl_ast_node_ref_vec_t attr_list;
const char *name;
spl_ast_node_ref_t type_expr; /* 可空 */
spl_ast_node_ref_t init_expr; /* 可空 */
} aggregate_member;
/* SPL_AST_STRUCT_INIT_ITEM */
struct {
const char *name;
spl_ast_node_ref_t type_expr;
} type_decl;
spl_ast_node_ref_t expr; /* 可空 */
} struct_init_item;
/* SPL_AST_MATCH_ARM */
struct {
spl_ast_node_ref_t pattern; /* 模式节点 */
spl_ast_node_ref_t body; /* block 或 expr 节点 */
} match_arm;
/* SPL_AST_LABEL */
struct {
spl_ast_node_ref_vec_t attr_list; /* attr_item */
const char *name;
spl_ast_node_ref_t type_expr;
} member_decl;
} label;
/* ---- 表达式子类型 ---- */
struct {
isize val;
} int_lit;
struct {
double val;
} float_lit;
struct {
char val;
} char_lit;
struct {
const char *data;
} string_lit;
struct {
bool val;
} bool_lit;
/* null_lit, undefined_lit 无数据 */
struct {
spl_ast_node_ref_vec_t attr_list; /* attr_item */
const char *name;
spl_ast_node_ref_t type_expr;
spl_ast_node_ref_t expr;
} var_const_decl;
/* statement */
} ident;
struct {
spl_ast_node_ref_t expr;
spl_ast_node_ref_t if_block; /* block_expr */
spl_ast_node_ref_t else_block; /* block_expr */
} if_statement;
struct {
spl_ast_node_ref_t packed_expr;
spl_ast_node_ref_t if_block; /* block_expr */
spl_ast_node_ref_t else_block; /* block_expr */
} ifvar_statement;
struct {
spl_ast_node_ref_t expr;
spl_ast_node_ref_t while_block; /* block_expr */
} while_statement;
struct {
spl_ast_node_ref_t loop_block; /* block_expr */
} loop_statement;
struct {
spl_ast_node_ref_vec_t expr_vec;
VEC(char *) ident_vec;
spl_ast_node_ref_t block; /* block_expr */
} for_statement;
struct {
spl_ast_node_ref_t expr;
spl_ast_node_ref_vec_t paced_exprs; /* packed_expr */
spl_ast_node_ref_t match_block; /* block_expr */
} match_statement;
struct {
spl_ast_node_ref_t expr;
} ret_statement;
struct {
} break_statement;
struct {
} continue_statement;
struct {
spl_ast_node_ref_vec_t block_or_statement; /* 语句 */
} defer_statement;
spl_unary_op_t op;
spl_ast_node_ref_t operand;
} unary;
struct {
const char *ident;
const char *bind_ident;
spl_ast_node_ref_t expr;
} packed_expr;
struct {
spl_binary_op_t op;
spl_ast_node_ref_t left;
spl_ast_node_ref_t right;
} op_expr;
struct {
spl_ast_node_ref_t postfix_expr;
} prefix_expr;
struct {
spl_ast_node_ref_t primary_expr;
union {
spl_ast_node_ref_vec_t call_expr;
const char *field_expr; /* field/method */
spl_ast_node_ref_t index_expr;
struct {
spl_ast_node_ref_t begin;
spl_ast_node_ref_t end;
} slice_expr;
spl_ast_node_ref_t type_expr;
};
} postfix_expr;
} binary;
struct {
isize integer_expr;
double float_expr;
char char_lit_expr;
const char *string_lit_expr; /* parsed c string */
const char *ident;
spl_ast_node_ref_t callee;
spl_ast_node_ref_vec_t args;
} call;
struct {
const char *name;
spl_ast_node_ref_vec_t expr; /* aggregate_init_item */
} aggregate_init;
struct {
spl_ast_node_ref_t obj;
const char *field;
} field;
struct {
spl_ast_node_ref_t obj;
spl_ast_node_ref_t index;
} index;
struct {
spl_ast_node_ref_t obj;
spl_ast_node_ref_t begin;
spl_ast_node_ref_t end;
} slice;
struct {
spl_ast_node_ref_t expr;
struct {
isize integer;
spl_ast_node_ref_t type_expr;
spl_ast_node_ref_vec_t expr_list;
} array_lit_expr;
struct {
const char *ident;
spl_ast_node_ref_vec_t expr_list;
} builtin_expr;
spl_ast_node_ref_vec_t block_expr; /* 语句 */
} primary_expr;
spl_ast_node_ref_t type;
} cast;
struct {
const char *ident;
spl_ast_node_ref_t expr;
} aggregate_init_item;
spl_ast_node_ref_vec_t elems;
} tuple;
struct {
spl_ast_node_ref_vec_t attr_list; /* attr_item */
union {
struct {
VEC(const char *) ident_vec;
} type_path;
struct {
spl_ast_node_ref_t element;
spl_ast_node_ref_t size;
} array_type;
struct {
spl_ast_node_ref_t element;
} slice_type;
struct {
spl_ast_node_ref_t pointee;
} pointer_type;
struct {
spl_ast_node_ref_vec_t param_list; /* param_decl */
spl_ast_node_ref_t type_expr;
} fn_type;
spl_ast_node_ref_vec_t aggregate_list; /* container_decl */
};
} type_expr;
bool has_len;
isize len;
bool is_underscore_len;
spl_ast_node_ref_t elem_type;
spl_ast_node_ref_vec_t elems;
} array_literal;
struct {
spl_ast_node_ref_vec_t elems;
} anon_array_literal;
struct {
const char *name; /* 可空，匿名时为 NULL */
spl_ast_node_ref_vec_t fields; /* struct_init_item 节点列表 */
} aggregate_literal;
struct {
const char *name;
spl_ast_node_ref_vec_t args;
} comptime_call;
struct {
spl_ast_node_ref_vec_t stmts;
spl_ast_node_ref_t tail_expr;
} block;
struct {
spl_ast_node_ref_t cond;
spl_ast_node_ref_t then_block;
spl_ast_node_ref_t else_branch;
} if_expr;
struct {
spl_ast_node_ref_t var_decl;
spl_ast_node_ref_t then_block;
spl_ast_node_ref_t else_branch;
} ifvar_expr;
struct {
spl_ast_node_ref_t label;
spl_ast_node_ref_t cond;
spl_ast_node_ref_t body;
spl_ast_node_ref_t else_branch;
} while_expr;
struct {
spl_ast_node_ref_t label;
spl_ast_node_ref_t body;
} loop_expr;
struct {
spl_ast_node_ref_t label;
spl_ast_node_ref_vec_t iter_exprs;
spl_ast_node_ref_vec_t idents;
spl_ast_node_ref_t body;
spl_ast_node_ref_t else_branch;
} for_expr;
struct {
spl_ast_node_ref_t matched_expr;
spl_ast_node_ref_vec_t arms; /* match_arm 节点 */
} match_expr;
struct {
bool is_comptime;
spl_ast_node_ref_vec_t params;
spl_ast_node_ref_t ret_type;
} fn_type;
/* ---- 类型子类型 ---- */
struct {
const char *name;
spl_ast_node_ref_vec_t generic_args;
} type_path;
struct {
spl_ast_node_ref_t pointee;
} type_pointer;
struct {
bool has_len;
isize len;
bool is_underscore_len;
spl_ast_node_ref_t elem_type;
} type_array;
struct {
spl_ast_node_ref_t elem_type;
} type_slice;
struct {
bool is_comptime;
spl_ast_node_ref_vec_t params;
spl_ast_node_ref_t ret_type;
} type_fn;
struct {
spl_ast_node_ref_vec_t types;
} type_paren;
struct {
const char *kind_name;
spl_ast_node_ref_vec_t members; /* aggregate_member 节点 */
} type_aggregate;
struct {
const char *name;
spl_ast_node_ref_vec_t args;
} type_comptime_call;
/* ---- 模式子类型 ---- */
struct {
const char *name;
} pattern_ident;
/* pattern_underscore 无数据 */
struct {
const char *name;
spl_ast_node_ref_t sub_pattern;
} pattern_dot;
struct {
spl_ast_node_ref_vec_t patterns;
} pattern_tuple;
struct {
spl_ast_node_ref_vec_t patterns;
} pattern_list;
};
};
typedef VEC(spl_ast_node_t) spl_ast_node_vec_t;
typedef VEC(char*)spl_ast_cstr_ref_vec_t;
typedef VEC(char *) spl_ast_cstr_ref_vec_t;
typedef struct {
int parsed;
spl_tok_vec_t input;
@@ -316,9 +498,10 @@ typedef struct {
void spl_ast_init(spl_ast_t *ast, const spl_tok_vec_t *tok_vec /*move*/);
void spl_ast_drop(spl_ast_t *ast);
spl_ast_node_t* spl_ast_node(spl_ast_t *ast, spl_ast_node_ref_t node);
spl_ast_node_t *spl_ast_node(spl_ast_t *ast, spl_ast_node_ref_t node);
const char *spl_ast_node_name(spl_ast_node_t *node);
void spl_ast_prase(spl_ast_t *ast);
void spl_ast_parse(spl_ast_t *ast);
void spl_ast_valid(spl_ast_t *ast);
void spl_ast_dump(spl_ast_t *ast, spl_ast_node_ref_t node);
stage1/spl_dbg.h
+3 -3
View File
@@ -11,15 +11,15 @@ typedef struct {
} spl_dbg_node_t;
#define SPL_FATAL(dbg, fmt, ...) \
LOG_FATAL("fatal at %s:%zd:%zd " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"), \
LOG_FATAL("fatal at %s:%d:%d " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"), \
((dbg) ? (dbg)->line : 0), ((dbg) ? (dbg)->col : 0), ##__VA_ARGS__)
#define SPL_ERROR(dbg, fmt, ...) \
LOG_ERROR("error at %s:%zd:%zd " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"), \
LOG_ERROR("error at %s:%d:%d " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"), \
((dbg) ? (dbg)->line : 0), ((dbg) ? (dbg)->col : 0), ##__VA_ARGS__)
#define SPL_WARN(dbg, fmt, ...) \
LOG_ERROR("warn at %s:%zd:%zd " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"), \
LOG_ERROR("warn at %s:%d:%d " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"), \
((dbg) ? (dbg)->line : 0), ((dbg) ? (dbg)->col : 0), ##__VA_ARGS__)
#endif /* __SPL_DBG_H__ */
stage1/spl_lexer.c
+62 -101
View File
@@ -349,6 +349,22 @@ spl_tok_vec_t spl_lex(const char *source, const char *fname) {
}
/* Multi-character operators (longest match) */
#define TRY_OP1(c1, tok1) \
if (c == (c1)) { \
spl_tok_t tok; \
memset(&tok, 0, sizeof(tok)); \
tok.type = (tok1); \
tok.lexeme = start; \
tok.len = 1; \
tok.fname = fname; \
tok.offset = offset; \
tok.line = line; \
tok.col = col; \
vec_push(toks, tok); \
offset++; \
col++; \
continue; \
}
/* Helper: try to match a two-char operator */
#define TRY_OP2(c1, c2, tok2, tok1) \
@@ -394,13 +410,15 @@ spl_tok_vec_t spl_lex(const char *source, const char *fname) {
}
/* Three-char operators first */
TRY_OP3('<', '-', '>', TOK_ARROW_BOTH, TOK_RIGHT_ARROW, TOK_LT)
TRY_OP3('<', '=', '>', TOK_FAT_ARROW_BOTH, TOK_RIGHT_FAT_ARROW, TOK_LT)
TRY_OP3('<', '<', '=', TOK_ASSIGN_L_SH, TOK_L_SH, TOK_LT)
TRY_OP3('>', '>', '=', TOK_ASSIGN_R_SH, TOK_R_SH, TOK_GT)
TRY_OP3('.', '.', '.', TOK_ELLIPSIS, TOK_RANGE, TOK_DOT)
/* Two-char operators */
TRY_OP2('=', '=', TOK_EQ, TOK_ASSIGN)
TRY_OP2('=', '>', TOK_FAT_ARROW, TOK_ASSIGN)
TRY_OP2('=', '>', TOK_RIGHT_FAT_ARROW, TOK_ASSIGN)
TRY_OP2('!', '=', TOK_NEQ, TOK_NOT)
TRY_OP2('<', '=', TOK_LE, TOK_LT)
TRY_OP2('>', '=', TOK_GE, TOK_GT)
@@ -414,110 +432,53 @@ spl_tok_vec_t spl_lex(const char *source, const char *fname) {
TRY_OP2('&', '=', TOK_ASSIGN_AND, TOK_AND)
TRY_OP2('|', '=', TOK_ASSIGN_OR, TOK_OR)
TRY_OP2('^', '=', TOK_ASSIGN_XOR, TOK_XOR)
TRY_OP2('<', '-', TOK_LEFT_ARRAY, TOK_LT)
TRY_OP2('-', '>', TOK_RIGHT_ARRAY, TOK_SUB)
TRY_OP2('<', '-', TOK_LEFT_ARROW, TOK_LT)
TRY_OP2('-', '>', TOK_RIGHT_ARROW, TOK_SUB)
TRY_OP2(':', '=', TOK_COLON_ASSIGN, TOK_COLON)
/* Single-character operators */
{
spl_tok_type_t tt = TOK_UNKNOWN;
switch (c) {
case '+':
tt = TOK_ADD;
break;
case '-':
tt = TOK_SUB;
break;
case '*':
tt = TOK_MUL;
break;
case '/':
tt = TOK_DIV;
break;
case '%':
tt = TOK_MOD;
break;
case '&':
tt = TOK_AND;
break;
case '|':
tt = TOK_OR;
break;
case '^':
tt = TOK_XOR;
break;
case '~':
tt = TOK_BIT_NOT;
break;
case '!':
tt = TOK_NOT;
break;
case '<':
tt = TOK_LT;
break;
case '>':
tt = TOK_GT;
break;
case '=':
tt = TOK_ASSIGN;
break;
case '.':
tt = TOK_DOT;
break;
case ',':
tt = TOK_COMMA;
break;
case ';':
tt = TOK_SEMICOLON;
break;
case ':':
tt = TOK_COLON;
break;
case '(':
tt = TOK_L_PAREN;
break;
case ')':
tt = TOK_R_PAREN;
break;
case '[':
tt = TOK_L_BRACKET;
break;
case ']':
tt = TOK_R_BRACKET;
break;
case '{':
tt = TOK_L_BRACE;
break;
case '}':
tt = TOK_R_BRACE;
break;
case '#':
tt = TOK_SHARP;
break;
case '@':
tt = TOK_AT;
break;
case '?':
tt = TOK_COND;
break;
default:
tt = TOK_UNKNOWN;
break;
}
TRY_OP1('+', TOK_ADD);
TRY_OP1('-', TOK_SUB);
TRY_OP1('*', TOK_MUL);
TRY_OP1('/', TOK_DIV);
TRY_OP1('%', TOK_MOD);
TRY_OP1('&', TOK_AND);
TRY_OP1('|', TOK_OR);
TRY_OP1('^', TOK_XOR);
TRY_OP1('~', TOK_BIT_NOT);
TRY_OP1('!', TOK_NOT);
TRY_OP1('<', TOK_LT);
TRY_OP1('>', TOK_GT);
TRY_OP1('=', TOK_ASSIGN);
TRY_OP1('.', TOK_DOT);
TRY_OP1(',', TOK_COMMA);
TRY_OP1(';', TOK_SEMICOLON);
TRY_OP1(':', TOK_COLON);
TRY_OP1('(', TOK_L_PAREN);
TRY_OP1(')', TOK_R_PAREN);
TRY_OP1('[', TOK_L_BRACKET);
TRY_OP1(']', TOK_R_BRACKET);
TRY_OP1('{', TOK_L_BRACE);
TRY_OP1('}', TOK_R_BRACE);
TRY_OP1('#', TOK_SHARP);
TRY_OP1('@', TOK_AT);
TRY_OP1('$', TOK_DOLLAR);
TRY_OP1('?', TOK_COND);
spl_tok_t tok;
memset(&tok, 0, sizeof(tok));
tok.type = tt;
tok.lexeme = start;
tok.len = 1;
tok.fname = fname;
tok.offset = offset;
tok.line = line;
tok.col = col;
vec_push(toks, tok);
offset++;
col++;
}
// TODO
spl_tok_t tok;
memset(&tok, 0, sizeof(tok));
tok.type = TOK_UNKNOWN;
tok.lexeme = start;
tok.len = 1;
tok.fname = fname;
tok.offset = offset;
tok.line = line;
tok.col = col;
vec_push(toks, tok);
offset++;
col++;
continue;
}
/* EOF token */
stage1/spl_tok.h
+9 -6
View File
@@ -25,17 +25,17 @@
X(match , KW_MATCH , SPL_V0) \
X(null , KW_NULL , SPL_V0) \
X(ret , KW_RET , SPL_V0) \
X(shape , WK_SHAPE , SPL_V0) \
X(shape , KW_SHAPE , SPL_V0) \
X(struct , KW_STRUCT , SPL_V0) \
X(true , KW_TRUE , SPL_V0) \
X(try , KW_TRY , SPL_V0) \
X(type , KW_TYPE , SPL_V0) \
X(undefined , KW_UNDEFINDED , SPL_V0) \
X(undefined , KW_UNDEFINED , SPL_V0) \
X(union , KW_UNION , SPL_V0) \
X(var , KW_VAR , SPL_V0) \
X(void , KW_VOID , SPL_V0) \
X(while , KW_WHILE , SPL_V0) \
X(_ , KW_ANY , SPL_V0) \
X(_ , KW_UNDERSCORE , SPL_V0) \
// KEYWORD_TABLE
#define TOKEN_TABLE \
@@ -45,13 +45,17 @@
X(endline , TOK_ENDLINE , SPL_V0 ) \
X("#" , TOK_SHARP , SPL_V0 ) \
X("@" , TOK_AT , SPL_V0 ) \
X("$" , TOK_DOLLAR , SPL_V0 ) \
X("==" , TOK_EQ , SPL_V0 ) \
X("=" , TOK_ASSIGN , SPL_V0 ) \
X("+=" , TOK_ASSIGN_ADD , SPL_V0 ) \
X("+" , TOK_ADD , SPL_V0 ) \
X("-=" , TOK_ASSIGN_SUB , SPL_V0 ) \
X("->" , TOK_RIGHT_ARRAY , SPL_V0 ) \
X("<-" , TOK_LEFT_ARRAY , SPL_V0 ) \
X("->" , TOK_RIGHT_ARROW , SPL_V0 ) \
X("<-" , TOK_LEFT_ARROW , SPL_V0 ) \
X("<->" , TOK_ARROW_BOTH , SPL_V0 ) \
X("<=>" , TOK_FAT_ARROW_BOTH , SPL_V0 ) \
X("=>" , TOK_RIGHT_FAT_ARROW , SPL_V0 ) \
X("-" , TOK_SUB , SPL_V0 ) \
X("*=" , TOK_ASSIGN_MUL , SPL_V0 ) \
X("*" , TOK_MUL , SPL_V0 ) \
@@ -93,7 +97,6 @@
X("." , TOK_DOT , SPL_V0 ) \
X(".." , TOK_RANGE , SPL_V0 ) \
X("..." , TOK_ELLIPSIS , SPL_V0 ) \
X("=>" , TOK_FAT_ARROW , SPL_V0 ) \
X("?" , TOK_COND , SPL_V0 ) \
X(ident , TOK_IDENT , SPL_V0 ) \
X(int , TOK_INT_LITERAL , SPL_V0 ) \
stage1/spl_type.c
+151 -161
View File
@@ -6,9 +6,6 @@ static usize spl_type_hash(spl_type_node_t n) {
case SPL_TYPE_ERROR:
case SPL_TYPE_VOID:
case SPL_TYPE_BOOL:
case SPL_TYPE_UNDEFINED:
case SPL_TYPE_NULL:
break;
case SPL_TYPE_INT:
hash += n.int_type.bits + n.int_type.is_signed;
break;
@@ -16,41 +13,28 @@ static usize spl_type_hash(spl_type_node_t n) {
hash += n.float_type.bits;
break;
case SPL_TYPE_PTR:
hash += n.ptr_pointee;
break;
case SPL_TYPE_SLICE:
hash += n.slice_element;
break;
case SPL_TYPE_RANGE:
hash += n.range_element;
hash += n.ptr_type.pointee;
break;
case SPL_TYPE_ARRAY:
hash += n.array_type.element + n.array_type.len;
break;
case SPL_TYPE_STRUCT:
case SPL_TYPE_UNION:
hash += n.layout.mode * 31 + n.layout.fixed_align_bits;
vec_for(n.agg_members, i) {
hash += (n.agg_members.data[i].name ? map_hash_str(n.agg_members.data[i].name) : 0) +
n.agg_members.data[i].type_id;
}
break;
case SPL_TYPE_ENUM:
case SPL_TYPE_SHAPE:
hash += n.layout.mode * 31 + n.layout.fixed_align_bits;
hash += n.adt_type.tag_type;
vec_for(n.adt_type.variants, i) {
hash += n.agg_type.tag_type;
vec_for(n.agg_type.variants, i) {
hash +=
(n.adt_type.variants.data[i].name ? map_hash_str(n.adt_type.variants.data[i].name)
(n.agg_type.variants.data[i].name ? map_hash_str(n.agg_type.variants.data[i].name)
: 0) +
n.adt_type.variants.data[i].type_id;
n.agg_type.variants.data[i].type_id;
}
break;
case SPL_TYPE_FN:
hash += n.fn_type.ret;
vec_for(n.fn_type.params, i) { hash += vec_at(n.fn_type.params, i); }
break;
default: // TODO
break;
}
return hash;
}
@@ -62,9 +46,6 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
case SPL_TYPE_ERROR:
case SPL_TYPE_VOID:
case SPL_TYPE_BOOL:
case SPL_TYPE_UNDEFINED:
case SPL_TYPE_NULL:
break;
case SPL_TYPE_INT:
if (n1.int_type.bits != n2.int_type.bits)
return 1;
@@ -76,15 +57,7 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
return 1;
break;
case SPL_TYPE_PTR:
if (n1.ptr_pointee != n2.ptr_pointee)
return 1;
break;
case SPL_TYPE_SLICE:
if (n1.slice_element != n2.slice_element)
return 1;
break;
case SPL_TYPE_RANGE:
if (n1.range_element != n2.range_element)
if (n1.ptr_type.pointee != n2.ptr_type.pointee)
return 1;
break;
case SPL_TYPE_ARRAY:
@@ -95,34 +68,21 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
break;
case SPL_TYPE_STRUCT:
case SPL_TYPE_UNION:
if (n1.layout.mode != n2.layout.mode ||
n1.layout.fixed_align_bits != n2.layout.fixed_align_bits)
return 1;
if (vec_size(n1.agg_members) != vec_size(n2.agg_members))
return 1;
vec_for(n1.agg_members, i) {
const char *na = n1.agg_members.data[i].name;
const char *nb = n2.agg_members.data[i].name;
if (strcmp(na ? na : "", nb ? nb : "") != 0)
return 1;
if (n1.agg_members.data[i].type_id != n2.agg_members.data[i].type_id)
return 1;
}
break;
case SPL_TYPE_ENUM:
case SPL_TYPE_SHAPE:
if (n1.layout.mode != n2.layout.mode ||
n1.layout.fixed_align_bits != n2.layout.fixed_align_bits)
return 1;
if (n1.adt_type.tag_type != n2.adt_type.tag_type)
if (n1.agg_type.tag_type != n2.agg_type.tag_type)
return 1;
if (vec_size(n1.adt_type.variants) != vec_size(n2.adt_type.variants))
if (vec_size(n1.agg_type.variants) != vec_size(n2.agg_type.variants))
return 1;
vec_for(n1.adt_type.variants, i) {
const char *na = n1.adt_type.variants.data[i].name;
const char *nb = n2.adt_type.variants.data[i].name;
vec_for(n1.agg_type.variants, i) {
const char *na = n1.agg_type.variants.data[i].name;
const char *nb = n2.agg_type.variants.data[i].name;
if (strcmp(na ? na : "", nb ? nb : "") != 0)
return 1;
if (n1.adt_type.variants.data[i].type_id != n2.adt_type.variants.data[i].type_id)
if (n1.agg_type.variants.data[i].type_id != n2.agg_type.variants.data[i].type_id)
return 1;
}
break;
@@ -136,8 +96,6 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
return 1;
}
break;
default: // TODO
return 1;
}
return 0;
}
@@ -150,10 +108,9 @@ static void spl_type_node_free_vecs(spl_type_node_t *tn) {
switch (tn->kind) {
case SPL_TYPE_STRUCT:
case SPL_TYPE_UNION:
vec_free(tn->agg_members);
break;
case SPL_TYPE_ENUM:
vec_free(tn->adt_type.variants);
case SPL_TYPE_SHAPE:
vec_free(tn->agg_type.variants);
break;
case SPL_TYPE_FN:
vec_free(tn->fn_type.params);
@@ -187,24 +144,15 @@ static const spl_type_member_t *spl_type_agg_member_find(spl_type_t *type, spl_t
if (!n || !name) {
return NULL;
}
if (n->kind == SPL_TYPE_STRUCT || n->kind == SPL_TYPE_UNION) {
vec_for(n->agg_members, i) {
const char *mn = n->agg_members.data[i].name;
if (n->kind == SPL_TYPE_STRUCT || n->kind == SPL_TYPE_UNION || n->kind == SPL_TYPE_ENUM ||
n->kind == SPL_TYPE_SHAPE) {
vec_for(n->agg_type.variants, i) {
const char *mn = vec_at(n->agg_type.variants, i).name;
if (strcmp(mn ? mn : "", name) == 0) {
if (out_idx) {
*out_idx = i;
}
return &n->agg_members.data[i];
}
}
} else if (n->kind == SPL_TYPE_ENUM) {
vec_for(n->adt_type.variants, i) {
const char *mn = n->adt_type.variants.data[i].name;
if (strcmp(mn ? mn : "", name) == 0) {
if (out_idx) {
*out_idx = i;
}
return &n->adt_type.variants.data[i];
return &n->agg_type.variants.data[i];
}
}
}
@@ -245,21 +193,7 @@ spl_type_id_t spl_type_builder_float(spl_type_t *type, usize bits) {
spl_type_id_t spl_type_builder_ptr(spl_type_t *type, spl_type_id_t pointee) {
spl_type_node_t tn = {0};
tn.kind = SPL_TYPE_PTR;
tn.ptr_pointee = pointee;
return spl_type_node_push(type, &tn);
}
spl_type_id_t spl_type_builder_slice(spl_type_t *type, spl_type_id_t element) {
spl_type_node_t tn = {0};
tn.kind = SPL_TYPE_SLICE;
tn.slice_element = element;
return spl_type_node_push(type, &tn);
}
spl_type_id_t spl_type_builder_range(spl_type_t *type, spl_type_id_t element) {
spl_type_node_t tn = {0};
tn.kind = SPL_TYPE_RANGE;
tn.range_element = element;
tn.ptr_type.pointee = pointee;
return spl_type_node_push(type, &tn);
}
@@ -284,24 +218,96 @@ spl_type_id_t spl_type_builder_fn(spl_type_t *type, spl_type_id_t ret, const spl
}
spl_type_id_t spl_type_builder_agg(spl_type_t *type, spl_type_node_kind_t tk,
const spl_type_member_t *members, usize nmembers,
spl_type_id_t tag_type, spl_type_layout_t layout) {
spl_type_member_vec_t *variants, spl_type_id_t tag_type,
spl_type_layout_t layout) {
spl_type_node_t tn = {0};
tn.kind = tk;
tn.layout = layout;
tn.agg_type.variants = *variants;
if (tk == SPL_TYPE_ENUM) {
vec_init(tn.adt_type.variants);
for (usize i = 0; i < nmembers; i++) {
vec_push(tn.adt_type.variants, members[i]);
}
tn.adt_type.tag_type = tag_type;
tn.agg_type.tag_type = tag_type;
} else {
vec_init(tn.agg_members);
for (usize i = 0; i < nmembers; i++) {
vec_push(tn.agg_members, members[i]);
tn.agg_type.tag_type = 0;
}
vec_init(*variants);
return spl_type_node_push(type, &tn);
}
spl_type_id_t spl_type_lookup_builtin(spl_type_t *type, const char *name) {
if (!name || !*name)
return 0;
// 固定名称类型
if (strcmp(name, "bool") == 0)
return spl_type_builder_simple(type, SPL_TYPE_BOOL);
if (strcmp(name, "void") == 0)
return spl_type_builder_simple(type, SPL_TYPE_VOID);
if (strcmp(name, "isize") == 0)
return spl_type_builder_int(type, sizeof(void *) * 8, true);
if (strcmp(name, "usize") == 0)
return spl_type_builder_int(type, sizeof(void *) * 8, false);
// 动态模式：iN / uN / fN，N 为正整数
char prefix = name[0];
if (prefix == 'i' || prefix == 'u' || prefix == 'f') {
const char *rest = name + 1;
if (*rest == '\0')
return 0;
char *end;
long bits = strtol(rest, &end, 10);
if (end != rest && *end == '\0' && bits > 0) {
if (prefix == 'i')
return spl_type_builder_int(type, (int)bits, true);
if (prefix == 'u')
return spl_type_builder_int(type, (int)bits, false);
if (prefix == 'f')
return spl_type_builder_float(type, (int)bits);
}
}
return spl_type_node_push(type, &tn);
return 0;
}
spl_type_id_t spl_def_get_type_id(spl_type_t *type, spl_def_id_t def_id) {
spl_def_node_t *def_node = spl_def_node(type, def_id);
Assert(def_node != NULL);
return def_node->type_id;
}
spl_def_id_t spl_def_builder_void(spl_type_t *type) {
TODO();
return 0;
}
spl_def_id_t spl_def_builder_bool(spl_type_t *type) {
TODO();
return 0;
}
spl_def_id_t spl_def_builder_int(spl_type_t *type, usize bits, int is_signed) {
TODO();
return 0;
}
spl_def_id_t spl_def_builder_float(spl_type_t *type, usize bits) {
TODO();
return 0;
}
spl_def_id_t spl_def_builder_ptr(spl_type_t *type, spl_def_id_t pointee) {
TODO();
return 0;
}
spl_def_id_t spl_def_builder_array(spl_type_t *type, spl_def_id_t element, usize len) {
TODO();
return 0;
}
spl_def_id_t spl_def_builder_slice(spl_type_t *type, spl_type_id_t element) {
TODO();
return 0;
}
spl_def_id_t spl_def_builder_range(spl_type_t *type) {
TODO();
return 0;
}
spl_def_id_t spl_def_builder_fn(spl_type_t *type) {
TODO();
return 0;
}
spl_def_id_t spl_def_alloc(spl_type_t *type, spl_def_node_kind_t kind, const char *name,
@@ -337,20 +343,18 @@ void spl_type_init(spl_type_t *type) {
vec_init(type->def_table);
vec_push(type->def_table, (spl_def_node_t){0});
spl_type_builder_simple(type, SPL_TYPE_VOID);
spl_type_builder_simple(type, SPL_TYPE_BOOL);
spl_type_builder_simple(type, SPL_TYPE_UNDEFINED);
spl_type_builder_simple(type, SPL_TYPE_NULL);
spl_type_builder_int(type, 8, false);
spl_type_builder_int(type, 16, false);
spl_type_builder_int(type, 32, false);
spl_type_builder_int(type, 64, false);
spl_type_builder_int(type, 8, true);
spl_type_builder_int(type, 16, true);
spl_type_builder_int(type, 32, true);
spl_type_builder_int(type, 64, true);
spl_type_builder_float(type, 32);
spl_type_builder_float(type, 64);
// spl_type_builder_simple(type, SPL_TYPE_VOID);
// spl_type_builder_simple(type, SPL_TYPE_BOOL);
// spl_type_builder_int(type, 8, false);
// spl_type_builder_int(type, 16, false);
// spl_type_builder_int(type, 32, false);
// spl_type_builder_int(type, 64, false);
// spl_type_builder_int(type, 8, true);
// spl_type_builder_int(type, 16, true);
// spl_type_builder_int(type, 32, true);
// spl_type_builder_int(type, 64, true);
// spl_type_builder_float(type, 32);
// spl_type_builder_float(type, 64);
}
void spl_type_drop(spl_type_t *type) {
@@ -359,10 +363,9 @@ void spl_type_drop(spl_type_t *type) {
switch (n->kind) {
case SPL_TYPE_STRUCT:
case SPL_TYPE_UNION:
vec_free(n->agg_members);
break;
case SPL_TYPE_ENUM:
vec_free(n->adt_type.variants);
case SPL_TYPE_SHAPE:
vec_free(n->agg_type.variants);
break;
case SPL_TYPE_FN:
vec_free(n->fn_type.params);
@@ -405,12 +408,6 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
case SPL_TYPE_BOOL:
printf("bool");
break;
case SPL_TYPE_UNDEFINED:
printf("undefined");
break;
case SPL_TYPE_NULL:
printf("null");
break;
case SPL_TYPE_INT:
if (n->int_type.bits == 0) {
printf("comptime_int");
@@ -427,52 +424,35 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
break;
case SPL_TYPE_PTR:
printf("*");
spl_type_pure_dump(type, n->ptr_pointee);
break;
case SPL_TYPE_SLICE:
printf("[]");
spl_type_pure_dump(type, n->slice_element);
break;
case SPL_TYPE_RANGE:
printf("range[");
spl_type_pure_dump(type, n->range_element);
printf("]");
spl_type_pure_dump(type, n->ptr_type.pointee);
break;
case SPL_TYPE_ARRAY:
printf("[%zu]", n->array_type.len);
spl_type_pure_dump(type, n->array_type.element);
break;
case SPL_TYPE_STRUCT:
printf("struct{");
vec_for(n->agg_members, i) {
if (i) {
printf(", ");
}
spl_type_member_t *member = &vec_at(n->agg_members, i);
printf("%s:", member->name ? member->name : "?");
spl_type_pure_dump(type, member->type_id);
}
printf("}");
break;
case SPL_TYPE_UNION:
printf("union{");
vec_for(n->agg_members, i) {
if (i) {
printf(", ");
}
spl_type_member_t *member = &vec_at(n->agg_members, i);
printf("%s:", member->name ? member->name : "?");
spl_type_pure_dump(type, member->type_id);
}
printf("}");
break;
case SPL_TYPE_ENUM:
printf("enum{"); // TODO tag_type
vec_for(n->adt_type.variants, i) {
case SPL_TYPE_SHAPE:
switch (n->kind) {
case SPL_TYPE_STRUCT:
printf("struct{\n");
case SPL_TYPE_UNION:
printf("union{\n");
case SPL_TYPE_ENUM:
printf("enum{\n");
case SPL_TYPE_SHAPE:
printf("shape{\n");
break;
default:
UNREACHABLE();
break;
}
vec_for(n->agg_type.variants, i) {
if (i) {
printf(", ");
}
spl_type_member_t *member = &vec_at(n->adt_type.variants, i);
spl_type_member_t *member = &vec_at(n->agg_type.variants, i);
printf("%s:", member->name ? member->name : "?");
spl_type_pure_dump(type, member->type_id);
}
@@ -486,13 +466,10 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
}
spl_type_pure_dump(type, vec_at(n->fn_type.params, i));
}
printf(") -> ");
printf(")");
spl_type_pure_dump(type, n->fn_type.ret);
break;
}
case SPL_TYPE_ID:
printf("id#%zu", n->type_id);
break;
}
}
@@ -523,6 +500,19 @@ void spl_type_def_dump(spl_type_t *type, spl_def_id_t id) {
case SPL_DEF_AGG:
def_kind_name = "agg";
break;
case SPL_DEF_BUILTIN:
switch (node->builtin_kind) {
case SPL_BUILTIN_RANGE:
def_kind_name = "builtin.range";
break;
case SPL_BUILTIN_SLICE:
def_kind_name = "builtin.slice";
break;
default:
def_kind_name = "builtin";
break;
}
break;
case SPL_DEF_DISTINCT:
def_kind_name = "newtype";
break;
stage1/spl_type.h
+31 -19
View File
@@ -15,17 +15,13 @@ typedef enum {
SPL_TYPE_BOOL,
SPL_TYPE_INT,
SPL_TYPE_FLOAT,
SPL_TYPE_UNDEFINED, // 自动配对任意类型的字面量，值为 undefined
SPL_TYPE_NULL, // 自动配对指针/切片的字面量，值为 0
SPL_TYPE_PTR,
SPL_TYPE_SLICE, // 未来拥有泛型后删除
SPL_TYPE_RANGE, // 未来拥有泛型后删除
SPL_TYPE_ARRAY,
SPL_TYPE_STRUCT,
SPL_TYPE_UNION,
SPL_TYPE_ENUM,
SPL_TYPE_SHAPE,
SPL_TYPE_FN,
SPL_TYPE_ID,
} spl_type_node_kind_t;
typedef enum {
@@ -48,7 +44,7 @@ typedef VEC(spl_type_member_t) spl_type_member_vec_t;
typedef struct {
spl_type_node_kind_t kind;
spl_type_layout_t layout;
spl_type_layout_t layout; // attribute
union {
struct {
usize bits;
@@ -57,23 +53,21 @@ typedef struct {
struct {
usize bits;
} float_type;
spl_type_id_t ptr_pointee;
spl_type_id_t slice_element;
spl_type_id_t range_element;
struct {
spl_type_id_t pointee;
} ptr_type;
struct {
spl_type_id_t element;
usize len;
} array_type;
spl_type_member_vec_t agg_members;
struct {
spl_type_member_vec_t variants;
spl_type_id_t tag_type;
} adt_type; // ADT
} agg_type; // adt record aggregate
struct {
spl_type_id_vec_t params;
spl_type_id_t ret;
} fn_type;
spl_type_id_t type_id;
};
} spl_type_node_t;
typedef VEC(spl_type_node_t) spl_type_node_vec_t;
@@ -84,13 +78,19 @@ typedef enum {
SPL_DEF_MEMBER,
SPL_DEF_VAR,
SPL_DEF_FN,
SPL_DEF_AGG, // include enum variants
SPL_DEF_DISTINCT, // newtype
SPL_DEF_ALIAS, // sametypes
SPL_DEF_AGG,
SPL_DEF_DISTINCT,
SPL_DEF_ALIAS,
SPL_DEF_BUILTIN,
} spl_def_node_kind_t;
typedef struct {
spl_def_node_kind_t kind;
enum {
SPL_BUILTIN_NONE,
SPL_BUILTIN_SLICE,
SPL_BUILTIN_RANGE,
} builtin_kind;
const char *name;
spl_dbg_node_t dbg_node;
spl_type_id_t type_id;
@@ -127,12 +127,24 @@ spl_type_id_t spl_type_builder_simple(spl_type_t *type, spl_type_node_kind_t kin
spl_type_id_t spl_type_builder_int(spl_type_t *type, usize bits, int is_signed);
spl_type_id_t spl_type_builder_float(spl_type_t *type, usize bits);
spl_type_id_t spl_type_builder_ptr(spl_type_t *type, spl_type_id_t pointee);
spl_type_id_t spl_type_builder_slice(spl_type_t *type, spl_type_id_t element);
spl_type_id_t spl_type_builder_range(spl_type_t *type, spl_type_id_t element);
spl_type_id_t spl_type_builder_array(spl_type_t *type, spl_type_id_t element, usize len);
spl_type_id_t spl_type_builder_fn(spl_type_t *type, spl_type_id_t ret, const spl_type_id_t *params,
usize nparams);
spl_type_id_t spl_type_builder_agg(spl_type_t *type, spl_type_node_kind_t tk,
const spl_type_member_t *members, usize nmembers,
spl_type_id_t tag_type, spl_type_layout_t layout);
spl_type_member_vec_t *variants, spl_type_id_t tag_type,
spl_type_layout_t layout);
spl_type_id_t spl_type_lookup_builtin(spl_type_t *type, const char *name);
spl_type_id_t spl_def_get_type_id(spl_type_t *type, spl_def_id_t def_id);
spl_def_id_t spl_def_builder_void(spl_type_t *type);
spl_def_id_t spl_def_builder_bool(spl_type_t *type);
spl_def_id_t spl_def_builder_int(spl_type_t *type, usize bits, int is_signed);
spl_def_id_t spl_def_builder_float(spl_type_t *type, usize bits);
spl_def_id_t spl_def_builder_ptr(spl_type_t *type, spl_def_id_t pointee);
spl_def_id_t spl_def_builder_array(spl_type_t *type, spl_def_id_t element, usize len);
spl_def_id_t spl_def_builder_slice(spl_type_t *type, spl_type_id_t element);
spl_def_id_t spl_def_builder_range(spl_type_t *type);
spl_def_id_t spl_def_builder_fn(spl_type_t *type);
#endif /* __SPL_TYPE_H__ */
stage1/splc0.c
+54 -54
View File
@@ -79,7 +79,7 @@ static int compile_spl(const char *src, const char *fname, const char *outpath,
}
spl_ast_t ast;
spl_ast_init(&ast, &toks);
spl_ast_prase(&ast);
spl_ast_parse(&ast);
if (ast.parsed < 0) {
printf("parse failed, no output\n");
// memory leak
@@ -91,63 +91,63 @@ static int compile_spl(const char *src, const char *fname, const char *outpath,
// memory leak
return 0;
}
spl_sema_t sema;
spl_type_t type;
spl_scope_t scope;
spl_type_init(&type);
spl_scope_init(&scope);
spl_sema_init(&sema, &ast, &type, &scope);
sema.ast = &ast;
spl_sema_run(&sema);
if (sema.error_count) {
printf("sema errors=%d, no output\n", sema.error_count);
// memory leak
return 1;
}
if (dump == DUMP_SEMA) {
spl_sema_dump(&sema);
spl_ast_dump(&ast, ast.root);
// memory leak
return 0;
}
// spl_sema_t sema;
// spl_type_t type;
// spl_scope_t scope;
// spl_type_init(&type);
// spl_scope_init(&scope);
// spl_sema_init(&sema, &ast, &type, &scope);
// sema.ast = &ast;
// spl_sema_run(&sema);
// if (sema.error_count) {
// printf("sema errors=%d, no output\n", sema.error_count);
// // memory leak
// return 1;
// }
// if (dump == DUMP_SEMA) {
// spl_sema_dump(&sema);
// spl_ast_dump(&ast, ast.root);
// // memory leak
// return 0;
// }
spl_ast2ir_t a2ir;
spl_ir_builder_t ir_builder;
spl_ir_builder_init(&ir_builder);
spl_ast2ir_init(&a2ir, &ir_builder, &sema);
spl_ast2ir_run(&a2ir);
if (a2ir.err_count) {
printf("ast2ir errors=%d, no output\n", a2ir.err_count);
spl_ast2ir_drop(&a2ir);
spl_sema_drop(&sema);
spl_ast_drop(&ast);
return 1;
}
if (dump == DUMP_IR) {
spl_ir_dump(&ir_builder.ir, &type);
// memory leak
return 0;
}
// spl_ast2ir_t a2ir;
// spl_ir_builder_t ir_builder;
// spl_ir_builder_init(&ir_builder);
// spl_ast2ir_init(&a2ir, &ir_builder, &sema);
// spl_ast2ir_run(&a2ir);
// if (a2ir.err_count) {
// printf("ast2ir errors=%d, no output\n", a2ir.err_count);
// spl_ast2ir_drop(&a2ir);
// spl_sema_drop(&sema);
// spl_ast_drop(&ast);
// return 1;
// }
// if (dump == DUMP_IR) {
// spl_ir_dump(&ir_builder.ir, &type);
// // memory leak
// return 0;
// }
spl_ir2vm_t ir2vm;
spl_ir2vm_init(&ir2vm, &a2ir.ir->ir, sema.type);
int rc = spl_ir2vm_run(&ir2vm);
if (rc != 0) {
printf("ir2vm error %d", rc);
return rc;
}
if (dump == DUMP_VM) {
spl_prog_dump(&ir2vm.prog);
// memory leak
return 0;
}
// spl_ir2vm_t ir2vm;
// spl_ir2vm_init(&ir2vm, &a2ir.ir->ir, sema.type);
// int rc = spl_ir2vm_run(&ir2vm);
// if (rc != 0) {
// printf("ir2vm error %d", rc);
// return rc;
// }
// if (dump == DUMP_VM) {
// spl_prog_dump(&ir2vm.prog);
// // memory leak
// return 0;
// }
spl_prog_store_to_file(outpath, &ir2vm.prog);
// spl_prog_store_to_file(outpath, &ir2vm.prog);
spl_ir2vm_drop(&ir2vm);
spl_ast2ir_drop(&a2ir);
spl_sema_drop(&sema);
spl_ast_drop(&ast);
// spl_ir2vm_drop(&ir2vm);
// spl_ast2ir_drop(&a2ir);
// spl_sema_drop(&sema);
// spl_ast_drop(&ast);
return 0;
}