aboutsummaryrefslogtreecommitdiff
path: root/src/parser.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/parser.c')
-rw-r--r--src/parser.c165
1 files changed, 113 insertions, 52 deletions
diff --git a/src/parser.c b/src/parser.c
index 5ccc0df8a..b620e911b 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -72,12 +72,17 @@ typedef enum ProcTag {
ProcTag_no_inline = GB_BIT(14),
ProcTag_dll_import = GB_BIT(15),
// ProcTag_dll_export = GB_BIT(16),
-
- ProcTag_stdcall = GB_BIT(20),
- ProcTag_fastcall = GB_BIT(21),
- // ProcTag_cdecl = GB_BIT(22),
} ProcTag;
+typedef enum ProcCallingConvention {
+ ProcCC_Odin = 0,
+ ProcCC_C,
+ ProcCC_Std,
+ ProcCC_Fast,
+
+ ProcCC_Invalid,
+} ProcCallingConvention;
+
typedef enum VarDeclTag {
VarDeclTag_thread_local = GB_BIT(0),
} VarDeclTag;
@@ -286,6 +291,7 @@ AST_NODE_KIND(_TypeBegin, "", i32) \
AstNodeArray params; \
AstNodeArray results; \
u64 tags; \
+ ProcCallingConvention calling_convention; \
}) \
AST_NODE_KIND(PointerType, "pointer type", struct { \
Token token; \
@@ -911,12 +917,13 @@ AstNode *make_field(AstFile *f, AstNodeArray names, AstNode *type, bool is_using
return result;
}
-AstNode *make_proc_type(AstFile *f, Token token, AstNodeArray params, AstNodeArray results, u64 tags) {
+AstNode *make_proc_type(AstFile *f, Token token, AstNodeArray params, AstNodeArray results, u64 tags, ProcCallingConvention calling_convention) {
AstNode *result = make_node(f, AstNode_ProcType);
result->ProcType.token = token;
result->ProcType.params = params;
result->ProcType.results = results;
result->ProcType.tags = tags;
+ result->ProcType.calling_convention = calling_convention;
return result;
}
@@ -1157,6 +1164,8 @@ void fix_advance_to_next_stmt(AstFile *f) {
case Token_const:
case Token_type:
case Token_proc:
+ case Token_import:
+ case Token_include:
case Token_if:
case Token_when:
@@ -1220,7 +1229,7 @@ void expect_semicolon(AstFile *f, AstNode *s) {
case AstNode_ProcDecl:
return;
case AstNode_GenericDecl:
- if (s->GenericDecl.close.kind == Token_CloseParen) {
+ if (s->GenericDecl.close.kind == Token_CloseBrace) {
return;
} else if (s->GenericDecl.token.kind == Token_type) {
if (f->prev_token.kind == Token_CloseBrace) {
@@ -1246,10 +1255,15 @@ void expect_semicolon(AstFile *f, AstNode *s) {
AstNode * parse_expr(AstFile *f, bool lhs);
-AstNode * parse_proc_type(AstFile *f);
+AstNode * parse_proc_type(AstFile *f, String *foreign_name_, String *link_name_);
AstNodeArray parse_stmt_list(AstFile *f);
AstNode * parse_stmt(AstFile *f);
AstNode * parse_body(AstFile *f);
+AstNode * parse_proc_decl(AstFile *f);
+void parse_proc_signature(AstFile *f, AstNodeArray *params, AstNodeArray *results);
+
+
+
AstNode *parse_identifier(AstFile *f) {
Token token = f->curr_token;
@@ -1270,8 +1284,12 @@ AstNode *parse_tag_expr(AstFile *f, AstNode *expression) {
AstNode *unparen_expr(AstNode *node) {
for (;;) {
- if (node->kind != AstNode_ParenExpr)
+ if (node == NULL) {
+ return NULL;
+ }
+ if (node->kind != AstNode_ParenExpr) {
return node;
+ }
node = node->ParenExpr.expr;
}
}
@@ -1380,10 +1398,13 @@ bool is_foreign_name_valid(String name) {
return true;
}
-void parse_proc_tags(AstFile *f, u64 *tags, String *foreign_name, String *link_name) {
+void parse_proc_tags(AstFile *f, u64 *tags, String *foreign_name, String *link_name, ProcCallingConvention *calling_convention) {
// TODO(bill): Add this to procedure literals too
- GB_ASSERT(foreign_name != NULL);
+ GB_ASSERT(tags != NULL);
GB_ASSERT(link_name != NULL);
+ GB_ASSERT(link_name != NULL);
+
+ ProcCallingConvention cc = ProcCC_Invalid;
while (f->curr_token.kind == Token_Hash) {
AstNode *tag_expr = parse_tag_expr(f, NULL);
@@ -1427,16 +1448,49 @@ void parse_proc_tags(AstFile *f, u64 *tags, String *foreign_name, String *link_n
ELSE_IF_ADD_TAG(no_inline)
ELSE_IF_ADD_TAG(dll_import)
// ELSE_IF_ADD_TAG(dll_export)
- ELSE_IF_ADD_TAG(stdcall)
- ELSE_IF_ADD_TAG(fastcall)
- // ELSE_IF_ADD_TAG(cdecl)
- else {
+ else if (str_eq(tag_name, str_lit("cc_odin"))) {
+ if (cc == ProcCC_Invalid) {
+ cc = ProcCC_Odin;
+ } else {
+ syntax_error_node(tag_expr, "Multiple calling conventions for procedure type");
+ }
+ } else if (str_eq(tag_name, str_lit("cc_c"))) {
+ if (cc == ProcCC_Invalid) {
+ cc = ProcCC_C;
+ } else {
+ syntax_error_node(tag_expr, "Multiple calling conventions for procedure type");
+ }
+ } else if (str_eq(tag_name, str_lit("cc_std"))) {
+ if (cc == ProcCC_Invalid) {
+ cc = ProcCC_Std;
+ } else {
+ syntax_error_node(tag_expr, "Multiple calling conventions for procedure type");
+ }
+ } else if (str_eq(tag_name, str_lit("cc_fast"))) {
+ if (cc == ProcCC_Invalid) {
+ cc = ProcCC_Fast;
+ } else {
+ syntax_error_node(tag_expr, "Multiple calling conventions for procedure type");
+ }
+ } else {
syntax_error_node(tag_expr, "Unknown procedure tag");
}
#undef ELSE_IF_ADD_TAG
}
+ if (cc == ProcCC_Invalid) {
+ if ((*tags) & ProcTag_foreign) {
+ cc = ProcCC_C;
+ } else {
+ cc = ProcCC_Odin;
+ }
+ }
+
+ if (calling_convention) {
+ *calling_convention = cc;
+ }
+
if ((*tags & ProcTag_foreign) && (*tags & ProcTag_export)) {
syntax_error(f->curr_token, "You cannot apply both #foreign and #export to a procedure");
}
@@ -1452,10 +1506,6 @@ void parse_proc_tags(AstFile *f, u64 *tags, String *foreign_name, String *link_n
if (((*tags & ProcTag_bounds_check) || (*tags & ProcTag_no_bounds_check)) && (*tags & ProcTag_foreign)) {
syntax_error(f->curr_token, "You cannot apply both #bounds_check or #no_bounds_check to a procedure without a body");
}
-
- if ((*tags & ProcTag_stdcall) && (*tags & ProcTag_fastcall)) {
- syntax_error(f->curr_token, "You cannot apply one calling convention to a procedure");
- }
}
AstNode *parse_operand(AstFile *f, bool lhs) {
@@ -1545,32 +1595,28 @@ AstNode *parse_operand(AstFile *f, bool lhs) {
// Parse Procedure Type or Literal
case Token_proc: {
+ String foreign_name = {0};
+ String link_name = {0};
AstNode *curr_proc = f->curr_proc;
- AstNode *type = parse_proc_type(f);
+ AstNode *type = parse_proc_type(f, &foreign_name, &link_name);
f->curr_proc = type;
- u64 tags = 0;
- String foreign_name = {0};
- String link_name = {0};
- parse_proc_tags(f, &tags, &foreign_name, &link_name);
- if (tags & ProcTag_foreign) {
+ if (type->ProcType.tags & ProcTag_foreign) {
syntax_error(f->curr_token, "#foreign cannot be applied to procedure literals");
}
- if (tags & ProcTag_export) {
+ if (type->ProcType.tags & ProcTag_export) {
syntax_error(f->curr_token, "#export cannot be applied to procedure literals");
}
if (f->curr_token.kind == Token_OpenBrace) {
AstNode *body;
- if ((tags & ProcTag_foreign) != 0) {
+ if ((type->ProcType.tags & ProcTag_foreign) != 0) {
syntax_error(f->curr_token, "A procedure tagged as `#foreign` cannot have a body");
}
body = parse_body(f);
- type = make_proc_lit(f, type, body, tags, foreign_name, link_name);
- } else if (type != NULL && type->kind == AstNode_ProcType) {
- type->ProcType.tags = tags;
+ type = make_proc_lit(f, type, body, type->ProcType.tags, foreign_name, link_name);
}
f->curr_proc = curr_proc;
@@ -1920,13 +1966,13 @@ AstNode *parse_generic_decl(AstFile *f, TokenKind keyword, ParserSpecProc spec_p
Token token = expect_token(f, keyword);
Token open = {0}, close = {0};
AstNodeArray specs = {0};
- if (f->curr_token.kind == Token_OpenParen) {
- open = expect_token(f, Token_OpenParen);
+ if (f->curr_token.kind == Token_OpenBrace) {
+ open = expect_token(f, Token_OpenBrace);
array_init(&specs, heap_allocator());
for (isize index = 0;
- f->curr_token.kind != Token_CloseParen &&
+ f->curr_token.kind != Token_CloseBrace &&
f->curr_token.kind != Token_EOF;
index++) {
AstNode *spec = spec_proc(f, keyword, index);
@@ -1934,7 +1980,7 @@ AstNode *parse_generic_decl(AstFile *f, TokenKind keyword, ParserSpecProc spec_p
expect_semicolon(f, spec);
}
- close = expect_token(f, Token_CloseParen);
+ close = expect_token(f, Token_CloseBrace);
} else {
array_init_reserve(&specs, heap_allocator(), 1);
array_add(&specs, spec_proc(f, keyword, 0));
@@ -2042,8 +2088,6 @@ PARSE_SPEC_PROC(parse_include_spec) {
return spec;
}
-AstNode *parse_proc_decl(AstFile *f);
-
AstNode *parse_decl(AstFile *f) {
switch (f->curr_token.kind) {
case Token_var:
@@ -2055,6 +2099,7 @@ AstNode *parse_decl(AstFile *f) {
return parse_generic_decl(f, f->curr_token.kind, parse_type_spec);
case Token_proc:
+ // TODO(bill): Should I allow procedures to use the generic declaration syntax?
return parse_proc_decl(f);
case Token_import:
@@ -2158,20 +2203,29 @@ AstNode *convert_stmt_to_expr(AstFile *f, AstNode *statement, String kind) {
-void parse_proc_signature(AstFile *f, AstNodeArray *params, AstNodeArray *results);
-AstNode *parse_proc_type(AstFile *f) {
+AstNode *parse_proc_type(AstFile *f, String *foreign_name_, String *link_name_) {
AstNodeArray params = {0};
AstNodeArray results = {0};
Token proc_token = expect_token(f, Token_proc);
parse_proc_signature(f, &params, &results);
- return make_proc_type(f, proc_token, params, results, 0);
-}
+ u64 tags = 0;
+ String foreign_name = {0};
+ String link_name = {0};
+ ProcCallingConvention cc = ProcCC_Odin;
+
+ parse_proc_tags(f, &tags, &foreign_name, &link_name, &cc);
+ if (foreign_name_) *foreign_name_ = foreign_name;
+ if (link_name_) *link_name_ = link_name;
-AstNodeArray parse_field_list(AstFile *f, isize *name_count_, bool allow_using, TokenKind separator, TokenKind follow) {
+ return make_proc_type(f, proc_token, params, results, tags, cc);
+}
+
+AstNodeArray parse_field_list(AstFile *f, isize *name_count_, bool allow_using, bool ellipsis_ok,
+ TokenKind separator, TokenKind follow) {
AstNodeArray params = make_ast_node_array(f);
isize name_count = 0;
@@ -2203,7 +2257,7 @@ AstNodeArray parse_field_list(AstFile *f, isize *name_count_, bool allow_using,
// expect_token_after(f, Token_Colon, "parameter list");
AstNode *type = NULL;
- if (f->curr_token.kind == Token_Ellipsis) {
+ if (ellipsis_ok && f->curr_token.kind == Token_Ellipsis) {
Token ellipsis = f->curr_token;
next_token(f);
type = parse_type_attempt(f);
@@ -2245,7 +2299,7 @@ AstNodeArray parse_field_list(AstFile *f, isize *name_count_, bool allow_using,
AstNodeArray parse_record_fields(AstFile *f, isize *field_count_, bool allow_using, String context) {
- return parse_field_list(f, field_count_, allow_using, Token_Semicolon, Token_CloseBrace);
+ return parse_field_list(f, field_count_, allow_using, false, Token_Semicolon, Token_CloseBrace);
}
AstNode *parse_identifier_or_type(AstFile *f) {
@@ -2358,8 +2412,14 @@ AstNode *parse_identifier_or_type(AstFile *f) {
return make_raw_union_type(f, token, decls, decl_count);
}
- case Token_proc:
- return parse_proc_type(f);
+ case Token_proc: {
+ Token token = f->curr_token;
+ AstNode *pt = parse_proc_type(f, NULL, NULL);
+ if (pt->ProcType.tags != 0) {
+ syntax_error(token, "A procedure type cannot have tags");
+ }
+ return pt;
+ }
case Token_OpenParen: {
// NOTE(bill): Skip the paren expression
@@ -2406,7 +2466,7 @@ void parse_proc_signature(AstFile *f,
AstNodeArray *params,
AstNodeArray *results) {
expect_token(f, Token_OpenParen);
- *params = parse_field_list(f, NULL, true, Token_Comma, Token_CloseParen);
+ *params = parse_field_list(f, NULL, true, true, Token_Comma, Token_CloseParen);
expect_token_after(f, Token_CloseParen, "parameter list");
*results = parse_results(f);
}
@@ -2431,21 +2491,22 @@ AstNode *parse_proc_decl(AstFile *f) {
return make_expr_stmt(f, parse_expr(f, true));
}
- Token proc_token = expect_token(f, Token_proc);
- AstNode *name = parse_identifier(f);
-
AstNodeArray params = {0};
AstNodeArray results = {0};
- parse_proc_signature(f, &params, &results);
- AstNode *proc_type = make_proc_type(f, proc_token, params, results, 0);
+ Token proc_token = expect_token(f, Token_proc);
+ AstNode *name = parse_identifier(f);
+ parse_proc_signature(f, &params, &results);
- AstNode *body = NULL;
u64 tags = 0;
String foreign_name = {0};
String link_name = {0};
+ ProcCallingConvention cc = ProcCC_Odin;
+
+ parse_proc_tags(f, &tags, &foreign_name, &link_name, &cc);
- parse_proc_tags(f, &tags, &foreign_name, &link_name);
+ AstNode *proc_type = make_proc_type(f, proc_token, params, results, tags, cc);
+ AstNode *body = NULL;
if (f->curr_token.kind == Token_OpenBrace) {
if ((tags & ProcTag_foreign) != 0) {
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-15 09:00:47 +0000