oceani: add tracking of rval vs lval

We need to know when a value is an rval or an lval.
So add an 'Erval' flag.  If not an rval, it must be an lval.

Also fix tracking of whether the lval is for a constant.

Signed-off-by: NeilBrown <neil@brown.name>

diff --git a/csrc/oceani-tests.mdc b/csrc/oceani-tests.mdc
index fc26950189e93bdc61e11e590a4d29429f294c2b..50a26dff61400a621ca9f4acdfd7f861feb196d9 100644 (file)
--- a/csrc/oceani-tests.mdc
+++ b/csrc/oceani-tests.mdc
@@ -875,17 +875,17 @@ various places that `type_err()` are called.
 
                if 3 * 4 and not True: print "Weird"
                d:number = .fred
+               (d + b) = 12
 
 ###### output: type_err1
        .tmp.code:3:25: error: expected string found number
        .tmp.code:3:28: error: expected string found number
        .tmp.code:6:8: error: Cannot assign to a constant: b
        .tmp.code:5:8: info: name was defined as a constant here
-       .tmp.code:6:8: error: Cannot assign to a constant: b
-       .tmp.code:5:8: info: name was defined as a constant here
        .tmp.code:8:11: error: Arithmetic returns number but Boolean expected
        .tmp.code:9:20: error: expected number found label
        .tmp.code:9:8: info: variable 'd' was set as number here.
+       .tmp.code:10:8: error: cannot assign to an rval
        oceani: type error in program - not running.
 
 ###### test: type_err2

diff --git a/csrc/oceani.mdc b/csrc/oceani.mdc
index dca205570c9af2c1ae704e0a58c04f01bdd96782..0f2174de2a8f05aae2f5c0f565df28a97c47785f 100644 (file)
--- a/csrc/oceani.mdc
+++ b/csrc/oceani.mdc
@@ -592,13 +592,15 @@ passed by reference.  It has `Efail` set when an error is found, and
 any expression cannot be evaluated a compile time, `Eruntime` is set.
 If the expression can be copied, `Emaycopy` is set.
 
-If it remains unchanged at `0`, then no more propagation is needed.
+If `Erval` is set, then the value cannot be assigned to because it is
+a temporary result.  If `Erval` is clear but `Econst` is set, then
+the value can only be assigned once, when the variable is declared.
 
 ###### ast
 
-       enum val_rules {Rboolok = 1<<1, Rnoconstant = 1<<2};
+       enum val_rules {Rboolok = 1<<0,};
        enum prop_err {Efail = 1<<0, Eretry = 1<<1, Eruntime = 1<<2,
-                      Emaycopy = 1<<3};
+                      Emaycopy = 1<<3, Erval = 1<<4, Econst = 1<<5};
 
 ###### forward decls
        static struct type *propagate_types(struct exec *prog, struct parse_context *c, enum prop_err *perr,
@@ -606,6 +608,7 @@ If it remains unchanged at `0`, then no more propagation is needed.
 ###### core functions
 
        static struct type *__propagate_types(struct exec *prog, struct parse_context *c, enum prop_err *perr,
+                                             enum prop_err *perr_local,
                                              struct type *type, int rules)
        {
                struct type *t;
@@ -631,8 +634,10 @@ If it remains unchanged at `0`, then no more propagation is needed.
                                            struct type *type, int rules)
        {
                int pre_err = c->parse_error;
-               struct type *ret = __propagate_types(prog, c, perr, type, rules);
+               enum prop_err perr_local = 0;
+               struct type *ret = __propagate_types(prog, c, perr, &perr_local, type, rules);
 
+               *perr |= perr_local & (Efail | Eretry);
                if (c->parse_error > pre_err)
                        *perr |= Efail;
                return ret;
@@ -1313,6 +1318,7 @@ executable.
                if (!type_compat(type, val->vtype, rules))
                        type_err(c, "error: expected %1 found %2",
                                   prog, type, rules, val->vtype);
+               *perr |= Erval;
                return val->vtype;
        }
 
@@ -1435,6 +1441,7 @@ match "case".
                if (!type_compat(type, Tlabel, rules))
                        type_err(c, "error: expected %1 found %2",
                                 prog, type, rules, Tlabel);
+               *perr |= Erval;
                return Tlabel;
        }
 ###### interp exec cases
@@ -2266,13 +2273,6 @@ correctly.
                        return Tnone;                                   // NOTEST
                }
                v = v->merged;
-               if (v->constant && (rules & Rnoconstant)) {
-                       type_err(c, "error: Cannot assign to a constant: %v",
-                                prog, NULL, 0, NULL);
-                       type_err(c, "info: name was defined as a constant here",
-                                v->where_decl, NULL, 0, NULL);
-                       return v->type;
-               }
                if (v->type == Tnone && v->where_decl == prog)
                        type_err(c, "error: variable used but not declared: %v",
                                 prog, NULL, 0, NULL);
@@ -2290,6 +2290,8 @@ correctly.
                }
                if (!v->global || v->frame_pos < 0)
                        *perr |= Eruntime;
+               if (v->constant)
+                       *perr |= Econst;
                if (!type)
                        return v->type;
                return type;
@@ -2599,8 +2601,8 @@ with a const size by whether they are prepared at parse time or not.
                /* left must be an array, right must be a number,
                 * result is the member type of the array
                 */
-               propagate_types(b->right, c, perr, Tnum, 0);
-               t = propagate_types(b->left, c, perr, NULL, rules & Rnoconstant);
+               propagate_types(b->right, c, perr_local, Tnum, 0);
+               t = propagate_types(b->left, c, perr, NULL, 0);
                if (!t || t->compat != array_compat) {
                        type_err(c, "error: %1 cannot be indexed", prog, t, 0, NULL);
                        return NULL;
@@ -3257,6 +3259,7 @@ anything in the heap or on the stack.  A reference can be assigned
                                r->reftype = type;
                                *perr |= Eretry;
                        }
+                       *perr |= Erval;
                        return type;
                case RefNil:
                        if (type && type->free != reference_free)
@@ -3266,9 +3269,10 @@ anything in the heap or on the stack.  A reference can be assigned
                                r->reftype = type;
                                *perr |= Eretry;
                        }
+                       *perr |= Erval;
                        return type;
                case RefFree:
-                       t = propagate_types(r->right, c, perr, NULL, 0);
+                       t = propagate_types(r->right, c, perr_local, NULL, 0);
                        if (t && t->free != reference_free)
                                type_err(c, "error: @free can only be assigned a reference, not %1",
                                         prog, t, 0, NULL);
@@ -3335,6 +3339,7 @@ anything in the heap or on the stack.  A reference can be assigned
                /* left must be a reference, and we return what it refers to */
                /* FIXME how can I pass the expected type down? */
                t = propagate_types(b->left, c, perr, NULL, 0);
+               *perr &= ~Erval;
                if (!t || t->free != reference_free)
                        type_err(c, "error: Cannot dereference %1", b, t, 0, NULL);
                else
@@ -3666,9 +3671,10 @@ it in the "SimpleStatement Grammar" which will be described later.
                        return NULL;
                }
                *perr |= Eruntime;
-               v->var->type->check_args(c, perr, v->var->type, args);
+               v->var->type->check_args(c, perr_local, v->var->type, args);
                if (v->var->type->function.inline_result)
                        *perr |= Emaycopy;
+               *perr |= Erval;
                return v->var->type->function.return_type;
        }
 
@@ -3781,7 +3787,7 @@ there.
                struct binode *b2 = cast(binode, b->right);
                struct type *t2;
 
-               propagate_types(b->left, c, perr, Tbool, 0);
+               propagate_types(b->left, c, perr_local, Tbool, 0);
                t = propagate_types(b2->left, c, perr, type, 0);
                t2 = propagate_types(b2->right, c, perr, type ?: t, 0);
                return t ?: t2;
@@ -3955,6 +3961,7 @@ evaluate the second expression if not necessary.
                if (type && type != Tbool)
                        type_err(c, "error: %1 operation found where %2 expected", prog,
                                   Tbool, 0, type);
+               *perr |= Erval;
                return Tbool;
 
 ###### interp binode cases
@@ -4076,6 +4083,7 @@ expression operator, and the `CMPop` non-terminal will match one of them.
                if (!type_compat(type, Tbool, 0))
                        type_err(c, "error: Comparison returns %1 but %2 expected", prog,
                                    Tbool, rules, type);
+               *perr |= Erval;
                return Tbool;
 
 ###### interp binode cases
@@ -4253,6 +4261,7 @@ parentheses around an expression converts it into a Term,
                if (!type_compat(type, Tnum, 0))
                        type_err(c, "error: Arithmetic returns %1 but %2 expected", prog,
                                   Tnum, rules, type);
+               *perr |= Erval;
                return Tnum;
 
        case Concat:
@@ -4262,6 +4271,7 @@ parentheses around an expression converts it into a Term,
                if (!type_compat(type, Tstr, 0))
                        type_err(c, "error: Concat returns %1 but %2 expected", prog,
                                   Tstr, rules, type);
+               *perr |= Erval;
                return Tstr;
 
        case StringConv:
@@ -4271,6 +4281,7 @@ parentheses around an expression converts it into a Term,
                        type_err(c,     // UNTESTED
                          "error: Can only convert string to number, not %1",
                                prog, type, 0, NULL);
+               *perr |= Erval;
                return Tnum;
 
        case Test:
@@ -4279,6 +4290,7 @@ parentheses around an expression converts it into a Term,
                if (!t || !t->test)
                        type_err(c, "error: '?' requires a testable value, not %1",
                                 prog, t, 0, NULL);
+               *perr |= Erval;
                return Tbool;
 
        case Choose:
@@ -4290,10 +4302,11 @@ parentheses around an expression converts it into a Term,
                if (t && t->test == NULL)
                        type_err(c, "error: \"??\" requires a testable value, not %1",
                                 prog, t, 0, NULL);
+               *perr |= Erval;
                return t;
 
        case Bracket:
-               return propagate_types(b->right, c, perr, type, 0);
+               return propagate_types(b->right, c, perr, type, rules);
 
 ###### interp binode cases
 
@@ -4663,7 +4676,7 @@ printed.
                else
                        b = cast(binode, b->right);
                while (b) {
-                       propagate_types(b->left, c, perr, NULL, 0);
+                       propagate_types(b->left, c, perr_local, NULL, 0);
                        b = cast(binode, b->right);
                }
                break;
@@ -4780,23 +4793,35 @@ be declared at any time.
                 * For Assign, left must not be constant.
                 * result is Tnone
                 */
-               t = propagate_types(b->left, c, perr, NULL,
-                                   (b->op == Assign ? Rnoconstant : 0));
+               *perr &= ~(Erval | Econst);
+               t = propagate_types(b->left, c, perr, NULL, 0);
                if (!b->right)
                        return Tnone;
 
                if (t) {
-                       if (propagate_types(b->right, c, perr, t, 0) != t)
+                       if (propagate_types(b->right, c, perr_local, t, 0) != t)
                                if (b->left->type == Xvar)
                                        type_err(c, "info: variable '%v' was set as %1 here.",
                                                 cast(var, b->left)->var->where_set, t, rules, NULL);
                } else {
-                       t = propagate_types(b->right, c, perr, NULL, 0);
+                       t = propagate_types(b->right, c, perr_local, NULL, 0);
                        if (t)
-                               propagate_types(b->left, c, perr, t,
-                                               (b->op == Assign ? Rnoconstant : 0));
+                               propagate_types(b->left, c, perr, t, 0);
+               }
+               if (*perr & Erval)
+                       type_err(c, "error: cannot assign to an rval", b,
+                                NULL, 0, NULL);
+               else if (b->op == Assign && (*perr & Econst)) {
+                       type_err(c, "error: Cannot assign to a constant: %v",
+                                b->left, NULL, 0, NULL);
+                       if (b->left->type == Xvar) {
+                               struct var *var = cast(var, b->left);
+                               struct variable *v = var->var;
+                               type_err(c, "info: name was defined as a constant here",
+                                        v->where_decl, NULL, 0, NULL);
+                       }
                }
-               if (t && t->dup == NULL && !(*perr & Emaycopy))
+               if (t && t->dup == NULL && !(*perr_local & Emaycopy))
                        type_err(c, "error: cannot assign value of type %1", b, t, 0, NULL);
                return Tnone;
 
@@ -5246,7 +5271,7 @@ casepart` to track a list of case parts.
 
 ###### propagate binode cases
        case Loop:
-               t = propagate_types(b->right, c, perr, Tnone, 0);
+               t = propagate_types(b->right, c, perr_local, Tnone, 0);
                if (!type_compat(Tnone, t, 0))
                        *perr |= Efail; // UNTESTED
                return propagate_types(b->left, c, perr, type, rules);