started implementing statement sequences

diff --git a/cerise/inc/cerise.h b/cerise/inc/cerise.h
index 94182e877341d9acca5418f8c55dc4c6278e2185..47b743a5131905360ce4129ea65a7f628825e067 100644 (file)
--- a/cerise/inc/cerise.h
+++ b/cerise/inc/cerise.h
@@ -224,16 +224,16 @@ void symbol_import(Parser* p, char* name, char* alias);
 void symbol_export(Parser* p, char* path);
 
 // src/type_checks.c
-void check_int(Parser* p, AstNode* a);
-void check_ints(Parser* p, AstNode* a, AstNode* b);
-void check_real(Parser* p, AstNode* a);
-void check_reals(Parser* p, AstNode* a, AstNode* b);
-void check_num(Parser* p, AstNode* a);
-void check_nums(Parser* p, AstNode* a, AstNode* b);
-void check_bool(Parser* p, AstNode* a);
-void check_bools(Parser* p, AstNode* a, AstNode* b);
-void check_type(Parser* p, Type* type, AstNode* a);
-void check_types(Parser* p, AstNode* a, AstNode* b);
+void check_int(Parser* p, SsaNode* a);
+void check_ints(Parser* p, SsaNode* a, SsaNode* b);
+void check_real(Parser* p, SsaNode* a);
+void check_reals(Parser* p, SsaNode* a, SsaNode* b);
+void check_num(Parser* p, SsaNode* a);
+void check_nums(Parser* p, SsaNode* a, SsaNode* b);
+void check_bool(Parser* p, SsaNode* a);
+void check_bools(Parser* p, SsaNode* a, SsaNode* b);
+void check_type(Parser* p, Type* type, SsaNode* a);
+void check_types(Parser* p, SsaNode* a, SsaNode* b);
 
 // src/grammar.c
 void compile(char* fname);

diff --git a/cerise/src/grammar.c b/cerise/src/grammar.c
index b737629a337ba6065a805473566f67a976c457ea..2a6671936823016ba6f2744b386d29139ca184ca 100644 (file)
--- a/cerise/src/grammar.c
+++ b/cerise/src/grammar.c
@@ -109,7 +109,7 @@ static SsaNode* designator(Parser* p)
                     error(p, "attempting to index non-array value");
                 }
                 SsaNode* index = expression(p);
-//                check_int(p, index);
+                check_int(p, index);
                 expr = ssa_index(p, expr, index);
                 expect(p, ']');
                 break;
@@ -236,12 +236,12 @@ static SsaNode* term(Parser* p)
             case '*':
             case '/':
             case '%':
-//                check_nums(p, expr, right);
+                check_nums(p, expr, right);
                 expr = ssa_op(p, op, expr, right);
                 break;
 
             case AND:
-//                check_bools(p, expr, right);
+                check_bools(p, expr, right);
                 expr = ssa_op(p, op, expr, right);
                 break;
 
@@ -267,7 +267,7 @@ static SsaNode* simple_expr(Parser* p)
     {
         int op = consume(p);
         SsaNode* operand = term(p);
-//        check_num(p, operand);
+        check_num(p, operand);
         expr = ssa_op(p, op, operand, NULL);
     }
     else
@@ -282,11 +282,11 @@ static SsaNode* simple_expr(Parser* p)
         SsaNode* right = term(p);
         if (op == OR)
         {
-//            check_bools(p, expr, right);
+            check_bools(p, expr, right);
         }
         else
         {
-//            check_nums(p, expr, right);
+            check_nums(p, expr, right);
         }
         expr = ssa_op(p, op, expr, right);
     }
@@ -307,7 +307,7 @@ static SsaNode* expression(Parser* p)
     {
         int op = consume(p);
         SsaNode* right = simple_expr(p);
-//        check_nums(p, expr, right);
+        check_nums(p, expr, right);
         expr = ssa_op(p, op, expr, right);
     }
 
@@ -333,7 +333,7 @@ static Type* type(Parser* p)
         {
             error(p, "non-constant array size");
         }
-//        check_int(p, lnode);
+        check_int(p, lnode);
         long long length = ssa_asint(lnode);
         expect(p, OF);
         Type* base = type(p);
@@ -395,7 +395,7 @@ static Type* type(Parser* p)
 static SsaBlock* statement_seq(Parser* p)
 {
     ENTER_RULE();
-    SsaBlock* block = ssa_block();
+    p->curr_block = ssa_block();
 
     do
     {
@@ -420,17 +420,20 @@ static SsaBlock* statement_seq(Parser* p)
             if (accept(p, '='))
             {
                 SsaNode* right = expression(p);
-//                check_types(p, expr, right);
+                check_types(p, expr, right);
                 expr = ssa_store(p, expr, right);
             }
+            else
+            {
+                ssa_block_add(p->curr_block, expr);
+            }
             expect(p, ';');
-            ssa_block_add(block, expr);
         }
     }
     while (!matches(p, END) && !matches(p, ELSE) && !matches(p, ELSIF) && !matches(p, RETURN));
 
     EXIT_RULE();
-    return block;
+    return p->curr_block;
 }
 
 static void var_decl(Parser* p)
@@ -483,7 +486,10 @@ static void const_decl(Parser* p)
         expect(p, '=');
         sym->value = expression(p);
         sym->type = sym->value->type;
-        ssa_print(p, sym->value);
+        if (sym->value->mode != MODE_CONST)
+        {
+            error(p, "constant defined with non-constant expression");
+        }
     }
     while (matches(p, IDENT));
 
@@ -621,16 +627,11 @@ static void module(Parser* p)
     if (accept(p, BEGIN))
     {
 //        p->curr_join = ast_block();
-//        if (!matches(p, END))
-//        {
-//            AstNode* block = ast_block();
-//            statement_seq(p, block);
-//            ast_print(p, block);
-//        }
         if (!matches(p, END))
         {
+//            p->curr_block = ssa_block();
             SsaBlock* block = statement_seq(p);
-//            ast_print(p, block);
+//            ssa_print_block(block);
             (void)block;
         }
         expect(p, END);

diff --git a/cerise/src/ssa.c b/cerise/src/ssa.c
index 9e3bbfdc4f55b58c94d1316a47439a47d06682c2..1d2421728872f817817dc3871c20d9df70fdf056 100644 (file)
--- a/cerise/src/ssa.c
+++ b/cerise/src/ssa.c
@@ -93,7 +93,12 @@ SsaNode* ssa_store(Parser* p, SsaNode* dest, SsaNode* value)
     assert("!stores are not implemented");
     load(p, value);
     load(p, dest);
-    return NULL;
+    SsaNode* node = ssa_node('=', MODE_VAR);
+    node->type = dest->type;
+    node->dest = dest->left.var;
+    ssa_block_add(p->curr_block, node);
+    node->loaded = 1;
+    return node;
 }
 
 SsaNode* ssa_fieldref(Parser* p, SsaNode* record, char* fname)

diff --git a/cerise/src/type_checks.c b/cerise/src/type_checks.c
index 38c7b63443a8c72a6d6bc466bd2735fe46a1eeec..603ab82951bed1e13053f2903850b790be44654c 100644 (file)
--- a/cerise/src/type_checks.c
+++ b/cerise/src/type_checks.c
@@ -1,40 +1,40 @@
 #include "cerise.h"
 
-void check_int(Parser* p, AstNode* a)
+void check_int(Parser* p, SsaNode* a)
 {
-    if (a->hdr.type->form != FORM_INT)
+    if (a->type->form != FORM_INT)
     {
         error(p, "not an int");
     }
 }
 
-void check_ints(Parser* p, AstNode* a, AstNode* b)
+void check_ints(Parser* p, SsaNode* a, SsaNode* b)
 {
     check_int(p, a);
     check_int(p, b);
 }
 
-void check_real(Parser* p, AstNode* a)
+void check_real(Parser* p, SsaNode* a)
 {
-    if (a->hdr.type->form != FORM_REAL)
+    if (a->type->form != FORM_REAL)
     {
         error(p, "not a real");
     }
 }
 
-void check_reals(Parser* p, AstNode* a, AstNode* b)
+void check_reals(Parser* p, SsaNode* a, SsaNode* b)
 {
     check_real(p, a);
     check_real(p, b);
 }
 
-void check_num(Parser* p, AstNode* a)
+void check_num(Parser* p, SsaNode* a)
 {
-    if (a->hdr.type->form == FORM_REAL)
+    if (a->type->form == FORM_REAL)
     {
         check_real(p, a);
     }
-    else if (a->hdr.type->form == FORM_INT)
+    else if (a->type->form == FORM_INT)
     {
         check_int(p, a);
     }
@@ -44,9 +44,9 @@ void check_num(Parser* p, AstNode* a)
     }
 }
 
-void check_nums(Parser* p, AstNode* a, AstNode* b)
+void check_nums(Parser* p, SsaNode* a, SsaNode* b)
 {
-    if (a->hdr.type->form == FORM_REAL)
+    if (a->type->form == FORM_REAL)
     {
         check_reals(p, a, b);
     }
@@ -56,21 +56,21 @@ void check_nums(Parser* p, AstNode* a, AstNode* b)
     }
 }
 
-void check_bool(Parser* p, AstNode* a)
+void check_bool(Parser* p, SsaNode* a)
 {
-    if (a->hdr.type->form != FORM_BOOL)
+    if (a->type->form != FORM_BOOL)
     {
         error(p, "not an bool");
     }
 }
 
-void check_bools(Parser* p, AstNode* a, AstNode* b)
+void check_bools(Parser* p, SsaNode* a, SsaNode* b)
 {
     check_bool(p, a);
     check_bool(p, b);
 }
 
-void check_type(Parser* p, Type* type, AstNode* a)
+void check_type(Parser* p, Type* type, SsaNode* a)
 {
     if (type->form == FORM_REAL)
     {
@@ -84,7 +84,7 @@ void check_type(Parser* p, Type* type, AstNode* a)
     {
         check_bool(p, a);
     }
-//    else if (a->hdr.type->form == FORM_ARRAY)
+//    else if (a->type->form == FORM_ARRAY)
 //    {
 //    }
     else
@@ -93,22 +93,22 @@ void check_type(Parser* p, Type* type, AstNode* a)
     }
 }
 
-void check_types(Parser* p, AstNode* a, AstNode* b)
+void check_types(Parser* p, SsaNode* a, SsaNode* b)
 {
-//    printf("%d %d\n", a->hdr.type->form, b->hdr.type->form);
-    if (a->hdr.type->form == FORM_REAL)
+//    printf("%d %d\n", a->type->form, b->type->form);
+    if (a->type->form == FORM_REAL)
     {
         check_reals(p, a, b);
     }
-    else if (a->hdr.type->form == FORM_INT)
+    else if (a->type->form == FORM_INT)
     {
         check_ints(p, a, b);
     }
-    else if (a->hdr.type->form == FORM_BOOL)
+    else if (a->type->form == FORM_BOOL)
     {
         check_bools(p, a, b);
     }
-//    else if (a->hdr.type->form == FORM_ARRAY)
+//    else if (a->type->form == FORM_ARRAY)
 //    {
 //    }
     else