aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorBad Diode <bd@badd10de.dev>2022-04-18 12:30:42 -0300
committerBad Diode <bd@badd10de.dev>2022-04-18 12:30:42 -0300
commit891ea6836072a1201083669a8a212b03af0c2d5c (patch)
treefdd6d8b274ccdb396bd5ad28006ce88eb894ed37 /src
parent140cd959daabf5c18b9cccc210a58ab50351e884 (diff)
downloadbdl-891ea6836072a1201083669a8a212b03af0c2d5c.tar.gz
bdl-891ea6836072a1201083669a8a212b03af0c2d5c.zip
Refactor to remove redundant symbol_check function
Diffstat (limited to 'src')
-rw-r--r--src/errors.c1
-rw-r--r--src/errors.h1
-rw-r--r--src/parser.c309
3 files changed, 99 insertions, 212 deletions
diff --git a/src/errors.c b/src/errors.c
index 3974281..e2dee00 100644
--- a/src/errors.c
+++ b/src/errors.c
@@ -24,6 +24,7 @@ static const char* error_msgs[] = {
24 [ERR_WRONG_TYPE_T_F] = "error: unmatched types between true and false expression", 24 [ERR_WRONG_TYPE_T_F] = "error: unmatched types between true and false expression",
25 [ERR_WRONG_TYPE_NUM] = "error: non numeric argument types", 25 [ERR_WRONG_TYPE_NUM] = "error: non numeric argument types",
26 [ERR_WRONG_TYPE_BOOL] = "error: non bool argument types", 26 [ERR_WRONG_TYPE_BOOL] = "error: non bool argument types",
27 [ERR_TYPE_MISMATCH] = "error: type mismatch",
27}; 28};
28 29
29static Error current_error = {.value = ERR_OK}; 30static Error current_error = {.value = ERR_OK};
diff --git a/src/errors.h b/src/errors.h
index 3c85307..a814549 100644
--- a/src/errors.h
+++ b/src/errors.h
@@ -32,6 +32,7 @@ typedef enum ErrorValue {
32 ERR_WRONG_TYPE_T_F, 32 ERR_WRONG_TYPE_T_F,
33 ERR_WRONG_TYPE_NUM, 33 ERR_WRONG_TYPE_NUM,
34 ERR_WRONG_TYPE_BOOL, 34 ERR_WRONG_TYPE_BOOL,
35 ERR_TYPE_MISMATCH,
35 ERR_OK, 36 ERR_OK,
36} ErrorValue; 37} ErrorValue;
37 38
diff --git a/src/parser.c b/src/parser.c
index 92f7654..10d82d1 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -559,16 +559,10 @@ parse_roots(Parser *parser) {
559} 559}
560 560
561Type * 561Type *
562find_type(Parser *parser, Node *type) { 562find_type(Scope *scope, Node *type) {
563 // Normally default types will be used more often. Since we don't 563 // TODO: Normally default types will be used more often. Since we don't
564 // allow type shadowing, we search first on the global scope. 564 // allow type shadowing, we should search first on the global scope.
565 Scope *scope = parser->parse_tree->global_scope; 565 while (scope != NULL) {
566 Type *ret = ht_lookup(scope->types, &type->string);
567 if (ret != NULL) {
568 return ret;
569 }
570 scope = parser->parse_tree->current_scope;
571 while (scope->parent != NULL) {
572 Type *ret = ht_lookup(scope->types, &type->string); 566 Type *ret = ht_lookup(scope->types, &type->string);
573 if (ret != NULL) { 567 if (ret != NULL) {
574 return ret; 568 return ret;
@@ -579,22 +573,8 @@ find_type(Parser *parser, Node *type) {
579 return NULL; 573 return NULL;
580} 574}
581 575
582// TODO: Review this function when needed
583// bool
584// insert_type(Parser *parser, Node *type, size_t size) {
585// HashTable *types = parser->parse_tree->current_scope->types;
586// if (ht_lookup(types, type) != NULL) {
587// push_error(ERR_TYPE_PARSER, ERR_TYPE_REDEF, type->line, type->col);
588// return false;
589// }
590// // TODO: alloc_type.
591// ht_insert(types, &type->string, type);
592// return true;
593// }
594
595Type * 576Type *
596find_symbol(Parser *parser, Node *node) { 577find_symbol(Scope *scope, Node *node) {
597 Scope *scope = parser->parse_tree->current_scope;
598 while (scope != NULL) { 578 while (scope != NULL) {
599 Type *type = ht_lookup(scope->symbols, node); 579 Type *type = ht_lookup(scope->symbols, node);
600 if (type != NULL) { 580 if (type != NULL) {
@@ -606,118 +586,19 @@ find_symbol(Parser *parser, Node *node) {
606 return NULL; 586 return NULL;
607} 587}
608 588
609bool 589Type *
610insert_symbol(Parser *parser, Node *symbol, Node *type) { 590insert_symbol(Scope *scope, Node *symbol, Node *type) {
611 HashTable *symbols = parser->parse_tree->current_scope->symbols; 591 HashTable *symbols = scope->symbols;
612 if (ht_lookup(symbols, symbol) != NULL) { 592 if (ht_lookup(symbols, symbol) != NULL) {
613 push_error(ERR_TYPE_PARSER, ERR_SYMBOL_REDEF, symbol->line, symbol->col); 593 push_error(ERR_TYPE_PARSER, ERR_SYMBOL_REDEF, symbol->line, symbol->col);
614 return false; 594 return NULL;
615 } 595 }
616 Type *t = find_type(parser, type); 596 Type *t = find_type(scope, type);
617 if (t == NULL) { 597 if (t == NULL) {
618 return NULL; 598 return NULL;
619 } 599 }
620 ht_insert(symbols, symbol, t); 600 ht_insert(symbols, symbol, t);
621 return true; 601 return t;
622}
623
624bool
625symbol_check(Parser *parser, Node *node) {
626 switch (node->type) {
627 case NODE_BUILTIN: {
628 for (size_t i = 0; i < array_size(node->builtin.args); ++i) {
629 Node *arg = node->builtin.args[i];
630 if (!symbol_check(parser, arg)) {
631 return false;
632 }
633 }
634 } break;
635 case NODE_SYMBOL: {
636 if (find_symbol(parser, node) == NULL) {
637 return false;
638 }
639 } break;
640 case NODE_SET: {
641 Node *symbol = node->set.symbol;
642 if (find_symbol(parser, symbol) == NULL) {
643 return false;
644 }
645 if (!symbol_check(parser, node->set.value)) {
646 return false;
647 }
648 } break;
649 case NODE_FUN: {
650 Scope *prev_scope = parser->parse_tree->current_scope;
651 parser->parse_tree->current_scope = alloc_scope(prev_scope);
652 node->scope = parser->parse_tree->current_scope;
653
654 // Parameters.
655 for (size_t i = 0; i < array_size(node->fun.param_names); ++i) {
656 Node *param = node->fun.param_names[i];
657 Node *type = node->fun.param_types[i];
658 if (!insert_symbol(parser, param, type)) {
659 return false;
660 }
661 }
662
663 // Body.
664 Node *body = node->fun.body;
665 if (body->type == NODE_BLOCK) {
666 body->scope = parser->parse_tree->current_scope;
667 for (size_t i = 0; i < array_size(body->block.expr); ++i) {
668 Node *expr = body->block.expr[i];
669 if (!symbol_check(parser, expr)) {
670 return false;
671 }
672 }
673 } else {
674 if (!symbol_check(parser, body)) {
675 return false;
676 }
677 }
678 parser->parse_tree->current_scope = prev_scope;
679 } break;
680 case NODE_BLOCK: {
681 Scope *prev_scope = parser->parse_tree->current_scope;
682 parser->parse_tree->current_scope = alloc_scope(prev_scope);
683 node->scope = parser->parse_tree->current_scope;
684 for (size_t i = 0; i < array_size(node->block.expr); ++i) {
685 Node *expr = node->block.expr[i];
686 if (!symbol_check(parser, expr)) {
687 return false;
688 }
689 }
690 parser->parse_tree->current_scope = prev_scope;
691 } break;
692 case NODE_IF: {
693 if (!symbol_check(parser, node->ifexpr.cond)) {
694 return false;
695 }
696 if (!symbol_check(parser, node->ifexpr.expr_true)) {
697 return false;
698 }
699 if (node->ifexpr.expr_false != NULL) {
700 if (!symbol_check(parser, node->ifexpr.expr_false)) {
701 return false;
702 }
703 }
704 } break;
705 case NODE_DEF: {
706 if (!symbol_check(parser, node->def.value)) {
707 return false;
708 }
709 if (!insert_symbol(parser, node->def.symbol, node->def.type)) {
710 return false;
711 }
712 } break;
713 case NODE_FUNCALL: {
714 if (!symbol_check(parser, node->funcall.name)) {
715 return false;
716 }
717 } break;
718 default: break;
719 }
720 return true;
721} 602}
722 603
723Type * 604Type *
@@ -725,75 +606,31 @@ coerce_numeric_types(Type *a, Type *b) {
725 if (a == &default_types[TYPE_U8]) { 606 if (a == &default_types[TYPE_U8]) {
726 if (b == &default_types[TYPE_U16] || 607 if (b == &default_types[TYPE_U16] ||
727 b == &default_types[TYPE_U32] || 608 b == &default_types[TYPE_U32] ||
728 b == &default_types[TYPE_U64] || 609 b == &default_types[TYPE_U64]) {
729 b == &default_types[TYPE_S8] ||
730 b == &default_types[TYPE_S16] ||
731 b == &default_types[TYPE_S32] ||
732 b == &default_types[TYPE_S64] ||
733 b == &default_types[TYPE_F32] ||
734 b == &default_types[TYPE_F64]) {
735 return b; 610 return b;
736 } 611 }
737 } else if (a == &default_types[TYPE_U16]) { 612 } else if (a == &default_types[TYPE_U16]) {
738 if (b == &default_types[TYPE_U32] || 613 if (b == &default_types[TYPE_U32] ||
739 b == &default_types[TYPE_S16] || 614 b == &default_types[TYPE_U64]) {
740 b == &default_types[TYPE_S32] ||
741 b == &default_types[TYPE_S64] ||
742 b == &default_types[TYPE_U64] ||
743 b == &default_types[TYPE_F32] ||
744 b == &default_types[TYPE_F64]) {
745 return b; 615 return b;
746 } 616 }
747 if (b == &default_types[TYPE_S8]) {
748 return &default_types[TYPE_S16];
749 }
750 } else if (a == &default_types[TYPE_U32]) { 617 } else if (a == &default_types[TYPE_U32]) {
751 if (b == &default_types[TYPE_U64] || 618 if (b == &default_types[TYPE_U64]) {
752 b == &default_types[TYPE_S32] ||
753 b == &default_types[TYPE_S64] ||
754 b == &default_types[TYPE_F32] ||
755 b == &default_types[TYPE_F64]) {
756 return b;
757 }
758 if (b == &default_types[TYPE_S8] ||
759 b == &default_types[TYPE_S16]) {
760 return &default_types[TYPE_S32];
761 }
762 } else if (a == &default_types[TYPE_U64]) {
763 if (b == &default_types[TYPE_S64] ||
764 b == &default_types[TYPE_F32] ||
765 b == &default_types[TYPE_F64]) {
766 return b; 619 return b;
767 } 620 }
768 if (b == &default_types[TYPE_S8] ||
769 b == &default_types[TYPE_S16] ||
770 b == &default_types[TYPE_S32]) {
771 return &default_types[TYPE_S64];
772 }
773 } else if (a == &default_types[TYPE_S8]) { 621 } else if (a == &default_types[TYPE_S8]) {
774 if (b == &default_types[TYPE_S16] || 622 if (b == &default_types[TYPE_S16] ||
775 b == &default_types[TYPE_S32] || 623 b == &default_types[TYPE_S32] ||
776 b == &default_types[TYPE_S64] || 624 b == &default_types[TYPE_S64]) {
777 b == &default_types[TYPE_F32] ||
778 b == &default_types[TYPE_F64]) {
779 return b; 625 return b;
780 } 626 }
781 } else if (a == &default_types[TYPE_S16]) { 627 } else if (a == &default_types[TYPE_S16]) {
782 if (b == &default_types[TYPE_S32] || 628 if (b == &default_types[TYPE_S32] ||
783 b == &default_types[TYPE_S64] || 629 b == &default_types[TYPE_S64]) {
784 b == &default_types[TYPE_F32] ||
785 b == &default_types[TYPE_F64]) {
786 return b; 630 return b;
787 } 631 }
788 } else if (a == &default_types[TYPE_S32]) { 632 } else if (a == &default_types[TYPE_S32]) {
789 if (b == &default_types[TYPE_S64] || 633 if (b == &default_types[TYPE_S64]) {
790 b == &default_types[TYPE_F32] ||
791 b == &default_types[TYPE_F64]) {
792 return b;
793 }
794 } else if (a == &default_types[TYPE_S64]) {
795 if (b == &default_types[TYPE_F32] ||
796 b == &default_types[TYPE_F64]) {
797 return b; 634 return b;
798 } 635 }
799 } else if (a == &default_types[TYPE_F32]) { 636 } else if (a == &default_types[TYPE_F32]) {
@@ -822,20 +659,15 @@ type_is_numeric(Type *t) {
822} 659}
823 660
824bool 661bool
825resolve_type(Parser *parser, Node *node) { 662resolve_type(Scope *scope, Node *node) {
826 if (node->expr_type != NULL) { 663 if (node->expr_type != NULL) {
827 return true; 664 return true;
828 } 665 }
829 Scope *prev_scope = NULL;
830 if (node->scope != NULL) {
831 prev_scope = parser->parse_tree->current_scope;
832 parser->parse_tree->current_scope = node->scope;
833 }
834 switch (node->type) { 666 switch (node->type) {
835 case NODE_BUILTIN: { 667 case NODE_BUILTIN: {
836 for (size_t i = 0; i < array_size(node->builtin.args); ++i) { 668 for (size_t i = 0; i < array_size(node->builtin.args); ++i) {
837 Node *arg = node->builtin.args[i]; 669 Node *arg = node->builtin.args[i];
838 if (!resolve_type(parser, arg)) { 670 if (!resolve_type(scope, arg)) {
839 return false; 671 return false;
840 } 672 }
841 } 673 }
@@ -850,7 +682,7 @@ resolve_type(Parser *parser, Node *node) {
850 for (size_t i = 0; i < array_size(node->builtin.args); ++i) { 682 for (size_t i = 0; i < array_size(node->builtin.args); ++i) {
851 Node *arg = node->builtin.args[i]; 683 Node *arg = node->builtin.args[i];
852 684
853 // Check that all arguments are nums. 685 // Check that all arguments are numbers.
854 if (!type_is_numeric(arg->expr_type)) { 686 if (!type_is_numeric(arg->expr_type)) {
855 push_error(ERR_TYPE_PARSER, ERR_WRONG_TYPE_NUM, 687 push_error(ERR_TYPE_PARSER, ERR_WRONG_TYPE_NUM,
856 arg->line, arg->col); 688 arg->line, arg->col);
@@ -900,12 +732,43 @@ resolve_type(Parser *parser, Node *node) {
900 } 732 }
901 } break; 733 } break;
902 case NODE_SYMBOL: { 734 case NODE_SYMBOL: {
903 node->expr_type = find_symbol(parser, node); 735 Type *type = find_symbol(scope, node);
736 if (type == NULL) {
737 return false;
738 }
739 node->expr_type = type;
904 } break; 740 } break;
905 case NODE_FUN: { 741 case NODE_FUN: {
906 if (!resolve_type(parser, node->fun.body)) { 742 // Fill up new scope with parameters
907 return false; 743 scope = alloc_scope(scope);
744
745 // Parameters.
746 for (size_t i = 0; i < array_size(node->fun.param_names); ++i) {
747 Node *param = node->fun.param_names[i];
748 Node *type = node->fun.param_types[i];
749 if (insert_symbol(scope, param, type) == NULL) {
750 return false;
751 }
908 } 752 }
753
754 // Body.
755 Node *body = node->fun.body;
756 if (body->type == NODE_BLOCK) {
757 body->scope = scope;
758 for (size_t i = 0; i < array_size(body->block.expr); ++i) {
759 Node *expr = body->block.expr[i];
760 if (!resolve_type(scope, expr)) {
761 return false;
762 }
763 }
764 Node *last_expr = body->block.expr[array_size(body->block.expr) - 1];
765 node->expr_type = last_expr->expr_type;
766 } else {
767 if (!resolve_type(scope, body)) {
768 return false;
769 }
770 }
771
909 // Check that the type of body matches the return type. 772 // Check that the type of body matches the return type.
910 StringView *type_body = &node->fun.body->expr_type->name; 773 StringView *type_body = &node->fun.body->expr_type->name;
911 StringView *return_type = &node->fun.return_type->string; 774 StringView *return_type = &node->fun.return_type->string;
@@ -915,9 +778,10 @@ resolve_type(Parser *parser, Node *node) {
915 } 778 }
916 } break; 779 } break;
917 case NODE_BLOCK: { 780 case NODE_BLOCK: {
781 scope = alloc_scope(scope);
918 for (size_t i = 0; i < array_size(node->block.expr); ++i) { 782 for (size_t i = 0; i < array_size(node->block.expr); ++i) {
919 Node *expr = node->block.expr[i]; 783 Node *expr = node->block.expr[i];
920 if (!resolve_type(parser, expr)) { 784 if (!resolve_type(scope, expr)) {
921 return false; 785 return false;
922 } 786 }
923 } 787 }
@@ -925,16 +789,16 @@ resolve_type(Parser *parser, Node *node) {
925 node->expr_type = last_expr->expr_type; 789 node->expr_type = last_expr->expr_type;
926 } break; 790 } break;
927 case NODE_IF: { 791 case NODE_IF: {
928 if (!resolve_type(parser, node->ifexpr.cond)) { 792 if (!resolve_type(scope, node->ifexpr.cond)) {
929 return false; 793 return false;
930 } 794 }
931 if (!resolve_type(parser, node->ifexpr.expr_true)) { 795 if (!resolve_type(scope, node->ifexpr.expr_true)) {
932 return false; 796 return false;
933 } 797 }
934 Type *type_true = node->ifexpr.expr_true->expr_type; 798 Type *type_true = node->ifexpr.expr_true->expr_type;
935 node->expr_type = type_true; 799 node->expr_type = type_true;
936 if (node->ifexpr.expr_false != NULL) { 800 if (node->ifexpr.expr_false != NULL) {
937 if (!resolve_type(parser, node->ifexpr.expr_false)) { 801 if (!resolve_type(scope, node->ifexpr.expr_false)) {
938 return false; 802 return false;
939 } 803 }
940 } 804 }
@@ -961,23 +825,48 @@ resolve_type(Parser *parser, Node *node) {
961 } break; 825 } break;
962 case NODE_SET: { 826 case NODE_SET: {
963 node->expr_type = &default_types[TYPE_VOID]; 827 node->expr_type = &default_types[TYPE_VOID];
964 if (!resolve_type(parser, node->set.value)) { 828 if (!resolve_type(scope, node->set.symbol)) {
829 return false;
830 }
831 if (!resolve_type(scope, node->set.value)) {
832 return false;
833 }
834 Node *symbol = node->set.symbol;
835 Node *value = node->set.value;
836 if (!sv_equal(&symbol->expr_type->name, &value->expr_type->name)) {
837 push_error(ERR_TYPE_PARSER, ERR_TYPE_MISMATCH,
838 node->line, node->col);
965 return false; 839 return false;
966 } 840 }
967 } break; 841 } break;
968 case NODE_DEF: { 842 case NODE_DEF: {
843 Type *type = insert_symbol(scope, node->def.symbol, node->def.type);
844 if (type == NULL) {
845 return false;
846 }
847 node->def.symbol->expr_type = type;
848
969 node->expr_type = &default_types[TYPE_VOID]; 849 node->expr_type = &default_types[TYPE_VOID];
970 if (!resolve_type(parser, node->def.value)) { 850 // TODO: type inference from right side when not annotated?
851 if (!resolve_type(scope, node->def.value)) {
852 return false;
853 }
854 Node *symbol = node->def.symbol;
855 Node *value = node->def.value;
856 if (!sv_equal(&symbol->expr_type->name, &value->expr_type->name)) {
857 push_error(ERR_TYPE_PARSER, ERR_TYPE_MISMATCH,
858 node->line, node->col);
971 return false; 859 return false;
972 } 860 }
973 } break; 861 } break;
974 case NODE_NUMBER: { 862 case NODE_NUMBER: {
863 // TODO: Numbers are f64/s64 unless explicitely annotated. Annotated
864 // numbers must fit in the given range (e.g. no negative constants
865 // inside a U64, no numbers bigger than 255 in a u8, etc.).
975 if (node->number.fractional != 0) { 866 if (node->number.fractional != 0) {
976 node->expr_type = &default_types[TYPE_F64]; 867 node->expr_type = &default_types[TYPE_F64];
977 } else if (node->number.negative) {
978 node->expr_type = &default_types[TYPE_S64];
979 } else { 868 } else {
980 node->expr_type = &default_types[TYPE_U64]; 869 node->expr_type = &default_types[TYPE_S64];
981 } 870 }
982 } break; 871 } break;
983 case NODE_BOOL: { 872 case NODE_BOOL: {
@@ -987,28 +876,27 @@ resolve_type(Parser *parser, Node *node) {
987 node->expr_type = &default_types[TYPE_STR]; 876 node->expr_type = &default_types[TYPE_STR];
988 } break; 877 } break;
989 case NODE_FUNCALL: { 878 case NODE_FUNCALL: {
990 if (!resolve_type(parser, node->funcall.name)) { 879 // TODO: Check that arguments type check with expectations.
880 if (!resolve_type(scope, node->funcall.name)) {
991 return false; 881 return false;
992 } 882 }
993 node->expr_type = node->funcall.name->expr_type; 883 node->expr_type = node->funcall.name->expr_type;
994 for (size_t i = 0; i < array_size(node->funcall.args); ++i) { 884 for (size_t i = 0; i < array_size(node->funcall.args); ++i) {
995 Node *arg = node->funcall.args[i]; 885 Node *arg = node->funcall.args[i];
996 if (!resolve_type(parser, arg)) { 886 if (!resolve_type(scope, arg)) {
997 return false; 887 return false;
998 } 888 }
999 } 889 }
1000 } break; 890 } break;
1001 default: break; 891 default: break;
1002 } 892 }
1003 if (node->scope != NULL) {
1004 parser->parse_tree->current_scope = prev_scope;
1005 }
1006 return true; 893 return true;
1007} 894}
1008 895
1009bool 896bool
1010semantic_analysis(Parser *parser) { 897semantic_analysis(Parser *parser) {
1011 // Fill up global function symbols. 898 // Fill up global function symbols.
899 Scope *scope = parser->parse_tree->global_scope;
1012 for (size_t i = 0; i < array_size(parser->parse_tree->roots); ++i) { 900 for (size_t i = 0; i < array_size(parser->parse_tree->roots); ++i) {
1013 Node *root = parser->parse_tree->roots[i]; 901 Node *root = parser->parse_tree->roots[i];
1014 if (root->type == NODE_FUN) { 902 if (root->type == NODE_FUN) {
@@ -1016,19 +904,16 @@ semantic_analysis(Parser *parser) {
1016 // TODO: make sure we store information in the symbol table that 904 // TODO: make sure we store information in the symbol table that
1017 // this is actually a function, not just a variable with 905 // this is actually a function, not just a variable with
1018 // return_type. 906 // return_type.
1019 if (!insert_symbol(parser, name, root->fun.return_type)) { 907 if (insert_symbol(scope, name, root->fun.return_type) == NULL) {
1020 return false; 908 return false;
1021 } 909 }
1022 } 910 }
1023 } 911 }
1024 912
1025 for (size_t i = 0; i < array_size(parser->parse_tree->roots); ++i) { 913 for (size_t i = 0; i < array_size(parser->parse_tree->roots); ++i) {
1026 // Fill up symbol tables in proper scope and check existance. 914 // Fill up symbol tables in proper scope and resolve type of expression
1027 if (!symbol_check(parser, parser->parse_tree->roots[i])) { 915 // for all elements.
1028 return false; 916 if (!resolve_type(scope, parser->parse_tree->roots[i])) {
1029 }
1030 // Resolve type of expression for all elements.
1031 if (!resolve_type(parser, parser->parse_tree->roots[i])) {
1032 return false; 917 return false;
1033 } 918 }
1034 } 919 }
generated by cgit v1.2.1 (git 2.18.0) at 2024-05-02 05:16:50 +0000