| author | |
| committer | |
| log | f4721857ed140add1f57badd1dc284fb24021ae0 |
| tree | 5536ef9af371ce17bf7a32f58836256273fa9413 |
| parent | 63d4e3ce1eefa8fe150c1cfddbac3cd6bd361862 |
3 files changed, 75 insertions(+), 149 deletions(-)
src/codegen.cpp+34-67| ... | @@ -308,10 +308,12 @@ static void find_declarations(CodeGen *g, AstNode *node) { | ... | @@ -308,10 +308,12 @@ static void find_declarations(CodeGen *g, AstNode *node) { |
| 308 | case NodeTypeBinOpExpr: | 308 | case NodeTypeBinOpExpr: |
| 309 | case NodeTypeFnCallExpr: | 309 | case NodeTypeFnCallExpr: |
| 310 | case NodeTypeRootExportDecl: | 310 | case NodeTypeRootExportDecl: |
| 311 | case NodeTypeNumberLiteral: | ||
| 312 | case NodeTypeStringLiteral: | ||
| 313 | case NodeTypeUnreachable: | ||
| 314 | case NodeTypeSymbol: | ||
| 311 | case NodeTypeCastExpr: | 315 | case NodeTypeCastExpr: |
| 312 | case NodeTypePrefixOpExpr: | 316 | case NodeTypePrefixOpExpr: |
| 313 | case NodeTypePrimaryExpr: | ||
| 314 | case NodeTypeGroupedExpr: | ||
| 315 | zig_unreachable(); | 317 | zig_unreachable(); |
| 316 | } | 318 | } |
| 317 | } | 319 | } |
| ... | @@ -373,9 +375,8 @@ static void check_fn_def_control_flow(CodeGen *g, AstNode *node) { | ... | @@ -373,9 +375,8 @@ static void check_fn_def_control_flow(CodeGen *g, AstNode *node) { |
| 373 | static Buf *hack_get_fn_call_name(CodeGen *g, AstNode *node) { | 375 | static Buf *hack_get_fn_call_name(CodeGen *g, AstNode *node) { |
| 374 | // Assume that the expression evaluates to a simple name and return the buf | 376 | // Assume that the expression evaluates to a simple name and return the buf |
| 375 | // TODO after type checking works we should be able to remove this hack | 377 | // TODO after type checking works we should be able to remove this hack |
| 376 | assert(node->type == NodeTypePrimaryExpr); | 378 | assert(node->type == NodeTypeSymbol); |
| 377 | assert(node->data.primary_expr.type == PrimaryExprTypeSymbol); | 379 | return &node->data.symbol; |
| 378 | return &node->data.primary_expr.data.symbol; | ||
| 379 | } | 380 | } |
| 380 | 381 | ||
| 381 | static void analyze_node(CodeGen *g, AstNode *node) { | 382 | static void analyze_node(CodeGen *g, AstNode *node) { |
| ... | @@ -521,24 +522,11 @@ static void analyze_node(CodeGen *g, AstNode *node) { | ... | @@ -521,24 +522,11 @@ static void analyze_node(CodeGen *g, AstNode *node) { |
| 521 | case NodeTypePrefixOpExpr: | 522 | case NodeTypePrefixOpExpr: |
| 522 | zig_panic("TODO"); | 523 | zig_panic("TODO"); |
| 523 | break; | 524 | break; |
| 524 | case NodeTypePrimaryExpr: | 525 | case NodeTypeNumberLiteral: |
| 525 | switch (node->data.primary_expr.type) { | 526 | case NodeTypeStringLiteral: |
| 526 | case PrimaryExprTypeNumber: | 527 | case NodeTypeUnreachable: |
| 527 | case PrimaryExprTypeString: | 528 | case NodeTypeSymbol: |
| 528 | case PrimaryExprTypeUnreachable: | 529 | // nothing to do |
| 529 | case PrimaryExprTypeSymbol: | ||
| 530 | // nothing to do | ||
| 531 | break; | ||
| 532 | case PrimaryExprTypeGroupedExpr: | ||
| 533 | analyze_node(g, node->data.primary_expr.data.grouped_expr); | ||
| 534 | break; | ||
| 535 | case PrimaryExprTypeBlock: | ||
| 536 | analyze_node(g, node->data.primary_expr.data.block); | ||
| 537 | break; | ||
| 538 | } | ||
| 539 | break; | ||
| 540 | case NodeTypeGroupedExpr: | ||
| 541 | zig_panic("TODO"); | ||
| 542 | break; | 530 | break; |
| 543 | } | 531 | } |
| 544 | } | 532 | } |
| ... | @@ -651,47 +639,6 @@ static LLVMValueRef find_or_create_string(CodeGen *g, Buf *str) { | ... | @@ -651,47 +639,6 @@ static LLVMValueRef find_or_create_string(CodeGen *g, Buf *str) { |
| 651 | return global_value; | 639 | return global_value; |
| 652 | } | 640 | } |
| 653 | 641 | ||
| 654 | static LLVMValueRef gen_primary_expr(CodeGen *g, AstNode *node) { | ||
| 655 | assert(node->type == NodeTypePrimaryExpr); | ||
| 656 | |||
| 657 | AstNodePrimaryExpr *prim_expr = &node->data.primary_expr; | ||
| 658 | |||
| 659 | switch (node->data.primary_expr.type) { | ||
| 660 | case PrimaryExprTypeNumber: | ||
| 661 | { | ||
| 662 | Buf *number_str = &prim_expr->data.number; | ||
| 663 | LLVMTypeRef number_type = LLVMInt32Type(); | ||
| 664 | LLVMValueRef number_val = LLVMConstIntOfStringAndSize(number_type, | ||
| 665 | buf_ptr(number_str), buf_len(number_str), 10); | ||
| 666 | return number_val; | ||
| 667 | } | ||
| 668 | case PrimaryExprTypeString: | ||
| 669 | { | ||
| 670 | Buf *str = &prim_expr->data.string; | ||
| 671 | LLVMValueRef str_val = find_or_create_string(g, str); | ||
| 672 | LLVMValueRef indices[] = { | ||
| 673 | LLVMConstInt(LLVMInt32Type(), 0, false), | ||
| 674 | LLVMConstInt(LLVMInt32Type(), 0, false) | ||
| 675 | }; | ||
| 676 | LLVMValueRef ptr_val = LLVMBuildInBoundsGEP(g->builder, str_val, indices, 2, ""); | ||
| 677 | return ptr_val; | ||
| 678 | } | ||
| 679 | case PrimaryExprTypeUnreachable: | ||
| 680 | add_debug_source_node(g, node); | ||
| 681 | return LLVMBuildUnreachable(g->builder); | ||
| 682 | case PrimaryExprTypeGroupedExpr: | ||
| 683 | return gen_expr(g, prim_expr->data.grouped_expr); | ||
| 684 | case PrimaryExprTypeBlock: | ||
| 685 | zig_panic("TODO block in expression"); | ||
| 686 | break; | ||
| 687 | case PrimaryExprTypeSymbol: | ||
| 688 | zig_panic("TODO variable reference"); | ||
| 689 | break; | ||
| 690 | } | ||
| 691 | |||
| 692 | zig_unreachable(); | ||
| 693 | } | ||
| 694 | |||
| 695 | static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) { | 642 | static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) { |
| 696 | assert(node->type == NodeTypeFnCallExpr); | 643 | assert(node->type == NodeTypeFnCallExpr); |
| 697 | 644 | ||
| ... | @@ -964,8 +911,28 @@ static LLVMValueRef gen_expr(CodeGen *g, AstNode *node) { | ... | @@ -964,8 +911,28 @@ static LLVMValueRef gen_expr(CodeGen *g, AstNode *node) { |
| 964 | return gen_prefix_op_expr(g, node); | 911 | return gen_prefix_op_expr(g, node); |
| 965 | case NodeTypeFnCallExpr: | 912 | case NodeTypeFnCallExpr: |
| 966 | return gen_fn_call_expr(g, node); | 913 | return gen_fn_call_expr(g, node); |
| 967 | case NodeTypePrimaryExpr: | 914 | case NodeTypeUnreachable: |
| 968 | return gen_primary_expr(g, node); | 915 | add_debug_source_node(g, node); |
| 916 | return LLVMBuildUnreachable(g->builder); | ||
| 917 | case NodeTypeNumberLiteral: | ||
| 918 | { | ||
| 919 | Buf *number_str = &node->data.number; | ||
| 920 | LLVMTypeRef number_type = LLVMInt32Type(); | ||
| 921 | LLVMValueRef number_val = LLVMConstIntOfStringAndSize(number_type, | ||
| 922 | buf_ptr(number_str), buf_len(number_str), 10); | ||
| 923 | return number_val; | ||
| 924 | } | ||
| 925 | case NodeTypeStringLiteral: | ||
| 926 | { | ||
| 927 | Buf *str = &node->data.string; | ||
| 928 | LLVMValueRef str_val = find_or_create_string(g, str); | ||
| 929 | LLVMValueRef indices[] = { | ||
| 930 | LLVMConstInt(LLVMInt32Type(), 0, false), | ||
| 931 | LLVMConstInt(LLVMInt32Type(), 0, false) | ||
| 932 | }; | ||
| 933 | LLVMValueRef ptr_val = LLVMBuildInBoundsGEP(g->builder, str_val, indices, 2, ""); | ||
| 934 | return ptr_val; | ||
| 935 | } | ||
| 969 | case NodeTypeRoot: | 936 | case NodeTypeRoot: |
| 970 | case NodeTypeRootExportDecl: | 937 | case NodeTypeRootExportDecl: |
| 971 | case NodeTypeFnProto: | 938 | case NodeTypeFnProto: |
| ... | @@ -976,7 +943,7 @@ static LLVMValueRef gen_expr(CodeGen *g, AstNode *node) { | ... | @@ -976,7 +943,7 @@ static LLVMValueRef gen_expr(CodeGen *g, AstNode *node) { |
| 976 | case NodeTypeBlock: | 943 | case NodeTypeBlock: |
| 977 | case NodeTypeExternBlock: | 944 | case NodeTypeExternBlock: |
| 978 | case NodeTypeDirective: | 945 | case NodeTypeDirective: |
| 979 | case NodeTypeGroupedExpr: | 946 | case NodeTypeSymbol: |
| 980 | zig_unreachable(); | 947 | zig_unreachable(); |
| 981 | } | 948 | } |
| 982 | zig_unreachable(); | 949 | zig_unreachable(); |
src/parser.cpp+34-54| ... | @@ -90,10 +90,14 @@ const char *node_type_str(NodeType node_type) { | ... | @@ -90,10 +90,14 @@ const char *node_type_str(NodeType node_type) { |
| 90 | return "ReturnExpr"; | 90 | return "ReturnExpr"; |
| 91 | case NodeTypeCastExpr: | 91 | case NodeTypeCastExpr: |
| 92 | return "CastExpr"; | 92 | return "CastExpr"; |
| 93 | case NodeTypePrimaryExpr: | 93 | case NodeTypeNumberLiteral: |
| 94 | return "PrimaryExpr"; | 94 | return "NumberLiteral"; |
| 95 | case NodeTypeGroupedExpr: | 95 | case NodeTypeStringLiteral: |
| 96 | return "GroupedExpr"; | 96 | return "StringLiteral"; |
| 97 | case NodeTypeUnreachable: | ||
| 98 | return "Unreachable"; | ||
| 99 | case NodeTypeSymbol: | ||
| 100 | return "Symbol"; | ||
| 97 | case NodeTypePrefixOpExpr: | 101 | case NodeTypePrefixOpExpr: |
| 98 | return "PrefixOpExpr"; | 102 | return "PrefixOpExpr"; |
| 99 | } | 103 | } |
| ... | @@ -222,36 +226,20 @@ void ast_print(AstNode *node, int indent) { | ... | @@ -222,36 +226,20 @@ void ast_print(AstNode *node, int indent) { |
| 222 | prefix_op_str(node->data.prefix_op_expr.prefix_op)); | 226 | prefix_op_str(node->data.prefix_op_expr.prefix_op)); |
| 223 | ast_print(node->data.prefix_op_expr.primary_expr, indent + 2); | 227 | ast_print(node->data.prefix_op_expr.primary_expr, indent + 2); |
| 224 | break; | 228 | break; |
| 225 | case NodeTypePrimaryExpr: | 229 | case NodeTypeNumberLiteral: |
| 226 | switch (node->data.primary_expr.type) { | 230 | fprintf(stderr, "PrimaryExpr Number %s\n", |
| 227 | case PrimaryExprTypeNumber: | 231 | buf_ptr(&node->data.number)); |
| 228 | fprintf(stderr, "PrimaryExpr Number %s\n", | ||
| 229 | buf_ptr(&node->data.primary_expr.data.number)); | ||
| 230 | break; | ||
| 231 | case PrimaryExprTypeString: | ||
| 232 | fprintf(stderr, "PrimaryExpr String '%s'\n", | ||
| 233 | buf_ptr(&node->data.primary_expr.data.string)); | ||
| 234 | break; | ||
| 235 | case PrimaryExprTypeUnreachable: | ||
| 236 | fprintf(stderr, "PrimaryExpr Unreachable\n"); | ||
| 237 | break; | ||
| 238 | case PrimaryExprTypeGroupedExpr: | ||
| 239 | fprintf(stderr, "PrimaryExpr GroupedExpr\n"); | ||
| 240 | ast_print(node->data.primary_expr.data.grouped_expr, indent + 2); | ||
| 241 | break; | ||
| 242 | case PrimaryExprTypeBlock: | ||
| 243 | fprintf(stderr, "PrimaryExpr Block\n"); | ||
| 244 | ast_print(node->data.primary_expr.data.block, indent + 2); | ||
| 245 | break; | ||
| 246 | case PrimaryExprTypeSymbol: | ||
| 247 | fprintf(stderr, "PrimaryExpr Symbol %s\n", | ||
| 248 | buf_ptr(&node->data.primary_expr.data.symbol)); | ||
| 249 | break; | ||
| 250 | } | ||
| 251 | break; | 232 | break; |
| 252 | case NodeTypeGroupedExpr: | 233 | case NodeTypeStringLiteral: |
| 253 | fprintf(stderr, "%s\n", node_type_str(node->type)); | 234 | fprintf(stderr, "PrimaryExpr String '%s'\n", |
| 254 | ast_print(node->data.grouped_expr.expr, indent + 2); | 235 | buf_ptr(&node->data.string)); |
| 236 | break; | ||
| 237 | case NodeTypeUnreachable: | ||
| 238 | fprintf(stderr, "PrimaryExpr Unreachable\n"); | ||
| 239 | break; | ||
| 240 | case NodeTypeSymbol: | ||
| 241 | fprintf(stderr, "PrimaryExpr Symbol %s\n", | ||
| 242 | buf_ptr(&node->data.symbol)); | ||
| 255 | break; | 243 | break; |
| 256 | } | 244 | } |
| 257 | } | 245 | } |
| ... | @@ -535,9 +523,11 @@ static AstNode *ast_parse_grouped_expr(ParseContext *pc, int *token_index, bool | ... | @@ -535,9 +523,11 @@ static AstNode *ast_parse_grouped_expr(ParseContext *pc, int *token_index, bool |
| 535 | 523 | ||
| 536 | *token_index += 1; | 524 | *token_index += 1; |
| 537 | 525 | ||
| 538 | AstNode *node = ast_create_node(NodeTypeGroupedExpr, l_paren); | 526 | AstNode *node = ast_parse_expression(pc, token_index, true); |
| 539 | 527 | ||
| 540 | node->data.grouped_expr.expr = ast_parse_expression(pc, token_index, true); | 528 | Token *r_paren = &pc->tokens->at(*token_index); |
| 529 | *token_index += 1; | ||
| 530 | ast_expect_token(pc, r_paren, TokenIdRParen); | ||
| 541 | 531 | ||
| 542 | return node; | 532 | return node; |
| 543 | } | 533 | } |
| ... | @@ -549,44 +539,34 @@ static AstNode *ast_parse_primary_expr(ParseContext *pc, int *token_index, bool | ... | @@ -549,44 +539,34 @@ static AstNode *ast_parse_primary_expr(ParseContext *pc, int *token_index, bool |
| 549 | Token *token = &pc->tokens->at(*token_index); | 539 | Token *token = &pc->tokens->at(*token_index); |
| 550 | 540 | ||
| 551 | if (token->id == TokenIdNumberLiteral) { | 541 | if (token->id == TokenIdNumberLiteral) { |
| 552 | AstNode *node = ast_create_node(NodeTypePrimaryExpr, token); | 542 | AstNode *node = ast_create_node(NodeTypeNumberLiteral, token); |
| 553 | node->data.primary_expr.type = PrimaryExprTypeNumber; | 543 | ast_buf_from_token(pc, token, &node->data.number); |
| 554 | ast_buf_from_token(pc, token, &node->data.primary_expr.data.number); | ||
| 555 | *token_index += 1; | 544 | *token_index += 1; |
| 556 | return node; | 545 | return node; |
| 557 | } else if (token->id == TokenIdStringLiteral) { | 546 | } else if (token->id == TokenIdStringLiteral) { |
| 558 | AstNode *node = ast_create_node(NodeTypePrimaryExpr, token); | 547 | AstNode *node = ast_create_node(NodeTypeStringLiteral, token); |
| 559 | node->data.primary_expr.type = PrimaryExprTypeString; | 548 | parse_string_literal(pc, token, &node->data.string); |
| 560 | parse_string_literal(pc, token, &node->data.primary_expr.data.string); | ||
| 561 | *token_index += 1; | 549 | *token_index += 1; |
| 562 | return node; | 550 | return node; |
| 563 | } else if (token->id == TokenIdKeywordUnreachable) { | 551 | } else if (token->id == TokenIdKeywordUnreachable) { |
| 564 | AstNode *node = ast_create_node(NodeTypePrimaryExpr, token); | 552 | AstNode *node = ast_create_node(NodeTypeUnreachable, token); |
| 565 | node->data.primary_expr.type = PrimaryExprTypeUnreachable; | ||
| 566 | *token_index += 1; | 553 | *token_index += 1; |
| 567 | return node; | 554 | return node; |
| 568 | } else if (token->id == TokenIdSymbol) { | 555 | } else if (token->id == TokenIdSymbol) { |
| 569 | AstNode *node = ast_create_node(NodeTypePrimaryExpr, token); | 556 | AstNode *node = ast_create_node(NodeTypeSymbol, token); |
| 570 | node->data.primary_expr.type = PrimaryExprTypeSymbol; | 557 | ast_buf_from_token(pc, token, &node->data.symbol); |
| 571 | ast_buf_from_token(pc, token, &node->data.primary_expr.data.symbol); | ||
| 572 | *token_index += 1; | 558 | *token_index += 1; |
| 573 | return node; | 559 | return node; |
| 574 | } | 560 | } |
| 575 | 561 | ||
| 576 | AstNode *block_node = ast_parse_block(pc, token_index, false); | 562 | AstNode *block_node = ast_parse_block(pc, token_index, false); |
| 577 | if (block_node) { | 563 | if (block_node) { |
| 578 | AstNode *node = ast_create_node(NodeTypePrimaryExpr, token); | 564 | return block_node; |
| 579 | node->data.primary_expr.type = PrimaryExprTypeBlock; | ||
| 580 | node->data.primary_expr.data.block = block_node; | ||
| 581 | return node; | ||
| 582 | } | 565 | } |
| 583 | 566 | ||
| 584 | AstNode *grouped_expr_node = ast_parse_grouped_expr(pc, token_index, false); | 567 | AstNode *grouped_expr_node = ast_parse_grouped_expr(pc, token_index, false); |
| 585 | if (grouped_expr_node) { | 568 | if (grouped_expr_node) { |
| 586 | AstNode *node = ast_create_node(NodeTypePrimaryExpr, token); | 569 | return grouped_expr_node; |
| 587 | node->data.primary_expr.type = PrimaryExprTypeGroupedExpr; | ||
| 588 | node->data.primary_expr.data.grouped_expr = grouped_expr_node; | ||
| 589 | return node; | ||
| 590 | } | 570 | } |
| 591 | 571 | ||
| 592 | if (!mandatory) | 572 | if (!mandatory) |
src/parser.hpp+7-28| ... | @@ -29,8 +29,10 @@ enum NodeType { | ... | @@ -29,8 +29,10 @@ enum NodeType { |
| 29 | NodeTypeReturnExpr, | 29 | NodeTypeReturnExpr, |
| 30 | NodeTypeBinOpExpr, | 30 | NodeTypeBinOpExpr, |
| 31 | NodeTypeCastExpr, | 31 | NodeTypeCastExpr, |
| 32 | NodeTypePrimaryExpr, | 32 | NodeTypeNumberLiteral, |
| 33 | NodeTypeGroupedExpr, | 33 | NodeTypeStringLiteral, |
| 34 | NodeTypeUnreachable, | ||
| 35 | NodeTypeSymbol, | ||
| 34 | NodeTypePrefixOpExpr, | 36 | NodeTypePrefixOpExpr, |
| 35 | NodeTypeFnCallExpr, | 37 | NodeTypeFnCallExpr, |
| 36 | }; | 38 | }; |
| ... | @@ -144,30 +146,6 @@ struct AstNodeCastExpr { | ... | @@ -144,30 +146,6 @@ struct AstNodeCastExpr { |
| 144 | AstNode *type; | 146 | AstNode *type; |
| 145 | }; | 147 | }; |
| 146 | 148 | ||
| 147 | enum PrimaryExprType { | ||
| 148 | PrimaryExprTypeNumber, | ||
| 149 | PrimaryExprTypeString, | ||
| 150 | PrimaryExprTypeUnreachable, | ||
| 151 | PrimaryExprTypeGroupedExpr, | ||
| 152 | PrimaryExprTypeBlock, | ||
| 153 | PrimaryExprTypeSymbol, | ||
| 154 | }; | ||
| 155 | |||
| 156 | struct AstNodePrimaryExpr { | ||
| 157 | PrimaryExprType type; | ||
| 158 | union { | ||
| 159 | Buf number; | ||
| 160 | Buf string; | ||
| 161 | Buf symbol; | ||
| 162 | AstNode *grouped_expr; | ||
| 163 | AstNode *block; | ||
| 164 | } data; | ||
| 165 | }; | ||
| 166 | |||
| 167 | struct AstNodeGroupedExpr { | ||
| 168 | AstNode *expr; | ||
| 169 | }; | ||
| 170 | |||
| 171 | enum PrefixOp { | 149 | enum PrefixOp { |
| 172 | PrefixOpInvalid, | 150 | PrefixOpInvalid, |
| 173 | PrefixOpBoolNot, | 151 | PrefixOpBoolNot, |
| ... | @@ -200,10 +178,11 @@ struct AstNode { | ... | @@ -200,10 +178,11 @@ struct AstNode { |
| 200 | AstNodeExternBlock extern_block; | 178 | AstNodeExternBlock extern_block; |
| 201 | AstNodeDirective directive; | 179 | AstNodeDirective directive; |
| 202 | AstNodeCastExpr cast_expr; | 180 | AstNodeCastExpr cast_expr; |
| 203 | AstNodePrimaryExpr primary_expr; | ||
| 204 | AstNodeGroupedExpr grouped_expr; | ||
| 205 | AstNodePrefixOpExpr prefix_op_expr; | 181 | AstNodePrefixOpExpr prefix_op_expr; |
| 206 | AstNodeFnCallExpr fn_call_expr; | 182 | AstNodeFnCallExpr fn_call_expr; |
| 183 | Buf number; | ||
| 184 | Buf string; | ||
| 185 | Buf symbol; | ||
| 207 | } data; | 186 | } data; |
| 208 | }; | 187 | }; |
| 209 | 188 |