oceani: mark some more UNTESTED code

[ocean] / csrc / oceani.mdc

diff --git a/csrc/oceani.mdc b/csrc/oceani.mdc
index fb154be366f3c5759231c29fd7a0309daa001581..f5e2b6ea9707c19c0638ecb8962373de2a443723 100644 (file)
--- a/csrc/oceani.mdc
+++ b/csrc/oceani.mdc
@@ -1274,13 +1274,13 @@ executable.
                $0->val.bool = 0;
        }$
        | NUMBER ${ {
                $0->val.bool = 0;
        }$
        | NUMBER ${ {

-               char tail[3];
+               char tail[3] = "";

                $0 = new_val(Tnum, $1);
                $0 = new_val(Tnum, $1);

-               if (number_parse($0->val.num, tail, $1.txt) == 0)
-                       mpq_init($0->val.num);  // UNTESTED
-                       if (tail[0])
-                               tok_err(c, "error: unsupported number suffix",
-                                       &$1);
+               if (number_parse($0->val.num, tail, $1.txt) == 0) {
+                       mpq_init($0->val.num);
+                       tok_err(c, "error: unsupported number format", &$NUM);
+               } else if (tail[0])
+                       tok_err(c, "error: unsupported number suffix", &$1);

        } }$
        | STRING ${ {
                char tail[3];
        } }$
        | STRING ${ {
                char tail[3];


@@ -2023,7 +2023,7 @@ tell if it was set or not later.
        {
                if (!v->global) {
                        if (!c->local || !v->type)
        {
                if (!v->global) {
                        if (!c->local || !v->type)

-                               return NULL;    // UNTESTED
+                               return NULL;    // NOTEST

                        if (v->frame_pos + v->type->size > c->local_size) {
                                printf("INVALID frame_pos\n");  // NOTEST
                                exit(2);                        // NOTEST
                        if (v->frame_pos + v->type->size > c->local_size) {
                                printf("INVALID frame_pos\n");  // NOTEST
                                exit(2);                        // NOTEST


@@ -2049,7 +2049,7 @@ tell if it was set or not later.
                        t->prepare_type(c, t, 1);       // NOTEST
 
                if (c->global_size & (t->align - 1))
                        t->prepare_type(c, t, 1);       // NOTEST
 
                if (c->global_size & (t->align - 1))

-                       c->global_size = (c->global_size + t->align) & ~(t->align-1);   // NOTEST
+                       c->global_size = (c->global_size + t->align) & ~(t->align-1);

                if (!v) {
                        v = &scratch;
                        v->type = t;
                if (!v) {
                        v = &scratch;
                        v->type = t;


@@ -2398,16 +2398,16 @@ with a const size by whether they are prepared at parse time or not.
                struct value *vsize;
                mpz_t q;
                if (type->array.static_size)
                struct value *vsize;
                mpz_t q;
                if (type->array.static_size)

-                       return 1;       // UNTESTED
+                       return 1;       // NOTEST - guard against reentry

                if (type->array.unspec && parse_time)
                if (type->array.unspec && parse_time)

-                       return 1;       // UNTESTED
+                       return 1;       // NOTEST - unspec is still incomplete

                if (parse_time && type->array.vsize && !type->array.vsize->global)
                if (parse_time && type->array.vsize && !type->array.vsize->global)

-                       return 1;       // UNTESTED
+                       return 1;       // NOTEST - should be impossible

 
                if (type->array.vsize) {
                        vsize = var_value(c, type->array.vsize);
                        if (!vsize)
 
                if (type->array.vsize) {
                        vsize = var_value(c, type->array.vsize);
                        if (!vsize)

-                               return 1;       // UNTESTED
+                               return 1;       // NOTEST - should be impossible

                        mpz_init(q);
                        mpz_tdiv_q(q, mpq_numref(vsize->num), mpq_denref(vsize->num));
                        type->array.size = mpz_get_si(q);
                        mpz_init(q);
                        mpz_tdiv_q(q, mpq_numref(vsize->num), mpq_denref(vsize->num));
                        type->array.size = mpz_get_si(q);


@@ -2416,7 +2416,7 @@ with a const size by whether they are prepared at parse time or not.
                if (!parse_time)
                        return 1;
                if (type->array.member->size <= 0)
                if (!parse_time)
                        return 1;
                if (type->array.member->size <= 0)

-                       return 0;       // UNTESTED
+                       return 0;       // NOTEST - error caught before here

 
                type->array.static_size = 1;
                type->size = type->array.size * type->array.member->size;
 
                type->array.static_size = 1;
                type->size = type->array.size * type->array.member->size;


@@ -2468,19 +2468,15 @@ with a const size by whether they are prepared at parse time or not.
                /* Both are arrays, so we can look at details */
                if (!type_compat(require->array.member, have->array.member, 0))
                        return 0;
                /* Both are arrays, so we can look at details */
                if (!type_compat(require->array.member, have->array.member, 0))
                        return 0;

-               if (have->array.unspec && require->array.unspec) {
-                       if (have->array.vsize && require->array.vsize &&
-                           have->array.vsize != require->array.vsize)  // UNTESTED
-                               /* sizes might not be the same */
-                               return 0;       // UNTESTED
-                       return 1;
-               }
+               if (have->array.unspec && require->array.unspec &&
+                   have->array.size != require->array.size)
+                       return 0;       // NOTEST

                if (have->array.unspec || require->array.unspec)
                if (have->array.unspec || require->array.unspec)

-                       return 1;       // UNTESTED
+                       return 1;

                if (require->array.vsize == NULL && have->array.vsize == NULL)
                        return require->array.size == have->array.size;
 
                if (require->array.vsize == NULL && have->array.vsize == NULL)
                        return require->array.size == have->array.size;
 

-               return require->array.vsize == have->array.vsize;       // UNTESTED
+               return require->array.vsize == have->array.vsize;

        }
 
        static void array_print_type(struct type *type, FILE *f)
        }
 
        static void array_print_type(struct type *type, FILE *f)


@@ -2554,25 +2550,14 @@ with a const size by whether they are prepared at parse time or not.
                $0->array.vsize = v;
        } }$
 
                $0->array.vsize = v;
        } }$
 

-###### Grammar
-       $*type
-       OptType -> Type ${ $0 = $<1; }$
-               | ${ $0 = NULL; }$
-

 ###### formal type grammar
 
 ###### formal type grammar
 

-       | [ IDENTIFIER :: OptType ] Type ${ {
-               struct variable *v = var_decl(c, $ID.txt);
-
-               v->type = $<OT;
-               v->constant = 1;
-               if (!v->type)
-                       v->type = Tnum;
-               $0 = add_anon_type(c, &array_prototype, "array[var]");
-               $0->array.member = $<6;
+       | [ ] Type ${ {
+               $0 = add_anon_type(c, &array_prototype, "array[]");
+               $0->array.member = $<Type;

                $0->array.size = 0;
                $0->array.unspec = 1;
                $0->array.size = 0;
                $0->array.unspec = 1;

-               $0->array.vsize = v;
+               $0->array.vsize = NULL;

        } }$
 
 ###### Binode types
        } }$
 
 ###### Binode types


@@ -2978,16 +2963,25 @@ function will be needed.
        } }$
 
        $*fieldlist
        } }$
 
        $*fieldlist

-       FieldBlock -> { IN OptNL FieldLines OUT OptNL } ${ $0 = $<FL; }$
+       FieldBlock -> { IN OptNL FieldLines OUT OptNL } ${ $0 = $<FL;   // UNTESTED
+               }$

        | { SimpleFieldList } ${ $0 = $<SFL; }$
        | IN OptNL FieldLines OUT ${ $0 = $<FL; }$
        | { SimpleFieldList } ${ $0 = $<SFL; }$
        | IN OptNL FieldLines OUT ${ $0 = $<FL; }$

-       | SimpleFieldList EOL ${ $0 = $<SFL; }$
+       | SimpleFieldList EOL ${ $0 = $<SFL;    // UNTESTED
+               }$

 
        FieldLines -> SimpleFieldList Newlines ${ $0 = $<SFL; }$
 
        FieldLines -> SimpleFieldList Newlines ${ $0 = $<SFL; }$

-       | FieldLines SimpleFieldList Newlines ${
-               $SFL->prev = $<FL;
-               $0 = $<SFL;
-       }$
+       | FieldLines SimpleFieldList Newlines ${ {
+               struct fieldlist *f = $<SFL;
+
+               if (f) {
+                       $0 = f;
+                       while (f->prev)
+                               f = f->prev;
+                       f->prev = $<FL;
+               } else
+                       $0 = $<FL;
+       } }$

 
        SimpleFieldList -> Field ${ $0 = $<F; }$
        | SimpleFieldList ; Field ${
 
        SimpleFieldList -> Field ${ $0 = $<F; }$
        | SimpleFieldList ; Field ${


@@ -3029,10 +3023,10 @@ function will be needed.
                        if (fl->type->print && fl->init) {
                                fprintf(f, " = ");
                                if (fl->type == Tstr)
                        if (fl->type->print && fl->init) {
                                fprintf(f, " = ");
                                if (fl->type == Tstr)

-                                       fprintf(f, "\"");       // UNTESTED
+                                       fprintf(f, "\"");

                                print_value(fl->type, fl->init, f);
                                if (fl->type == Tstr)
                                print_value(fl->type, fl->init, f);
                                if (fl->type == Tstr)

-                                       fprintf(f, "\"");       // UNTESTED
+                                       fprintf(f, "\"");

                        }
                        fprintf(f, "\n");
                }
                        }
                        fprintf(f, "\n");
                }


@@ -3395,7 +3389,7 @@ anything in the heap or on the stack.  A reference can be assigned
        case AddressOf:
                /* left must be lval, we create reference to it */
                if (!type || type->free != reference_free)
        case AddressOf:
                /* left must be lval, we create reference to it */
                if (!type || type->free != reference_free)

-                       t = propagate_types(b->left, c, perr, type, 0); // UNTESTED
+                       t = propagate_types(b->left, c, perr, type, 0); // NOTEST impossible

                else
                        t = propagate_types(b->left, c, perr,
                                            type->reference.referent, 0);
                else
                        t = propagate_types(b->left, c, perr,
                                            type->reference.referent, 0);


@@ -3880,7 +3874,7 @@ there.
                struct binode *b2 = cast(binode, b->right);
                left = interp_exec(c, b->left, &ltype);
                if (left.bool)
                struct binode *b2 = cast(binode, b->right);
                left = interp_exec(c, b->left, &ltype);
                if (left.bool)

-                       rv = interp_exec(c, b2->left, &rvtype); // UNTESTED
+                       rv = interp_exec(c, b2->left, &rvtype);

                else
                        rv = interp_exec(c, b2->right, &rvtype);
                }
                else
                        rv = interp_exec(c, b2->right, &rvtype);
                }


@@ -4157,9 +4151,9 @@ expression operator, and the `CMPop` non-terminal will match one of them.
                if (t)
                        propagate_types(b->right, c, perr, t, 0);
                else {
                if (t)
                        propagate_types(b->right, c, perr, t, 0);
                else {

-                       t = propagate_types(b->right, c, perr, NULL, 0);        // UNTESTED
-                       if (t)  // UNTESTED
-                               t = propagate_types(b->left, c, perr, t, 0);    // UNTESTED
+                       t = propagate_types(b->right, c, perr, NULL, 0);        // NOTEST
+                       if (t)  // NOTEST
+                               t = propagate_types(b->left, c, perr, t, 0);    // NOTEST

                }
                if (!type_compat(type, Tbool, 0))
                        type_err(c, "error: Comparison returns %1 but %2 expected", prog,
                }
                if (!type_compat(type, Tbool, 0))
                        type_err(c, "error: Comparison returns %1 but %2 expected", prog,


@@ -4359,7 +4353,7 @@ parentheses around an expression converts it into a Term,
                /* op must be string, result is number */
                propagate_types(b->left, c, perr, Tstr, 0);
                if (!type_compat(type, Tnum, 0))
                /* op must be string, result is number */
                propagate_types(b->left, c, perr, Tstr, 0);
                if (!type_compat(type, Tnum, 0))

-                       type_err(c,     // UNTESTED
+                       type_err(c,

                          "error: Can only convert string to number, not %1",
                                prog, type, 0, NULL);
                *perr |= Erval;
                          "error: Can only convert string to number, not %1",
                                prog, type, 0, NULL);
                *perr |= Erval;


@@ -4449,19 +4443,19 @@ parentheses around an expression converts it into a Term,
                rvtype = Tnum;
 
                struct text tx = right.str;
                rvtype = Tnum;
 
                struct text tx = right.str;

-               char tail[3];
+               char tail[3] = "";

                int neg = 0;
                if (tx.txt[0] == '-') {
                int neg = 0;
                if (tx.txt[0] == '-') {

-                       neg = 1;        // UNTESTED
-                       tx.txt++;       // UNTESTED
-                       tx.len--;       // UNTESTED
+                       neg = 1;
+                       tx.txt++;
+                       tx.len--;

                }
                if (number_parse(rv.num, tail, tx) == 0)
                }
                if (number_parse(rv.num, tail, tx) == 0)

-                       mpq_init(rv.num);       // UNTESTED
+                       mpq_init(rv.num);

                else if (neg)
                else if (neg)

-                       mpq_neg(rv.num, rv.num);        // UNTESTED
+                       mpq_neg(rv.num, rv.num);

                if (tail[0])
                if (tail[0])

-                       printf("Unsupported suffix: %.*s\n", tx.len, tx.txt);   // UNTESTED
+                       printf("Unsupported suffix: %.*s\n", tx.len, tx.txt);

 
                break;
        case Test:
 
                break;
        case Test:


@@ -4558,23 +4552,29 @@ the common header for all reductions to use.
        $TERM { } ;
 
        $*binode
        $TERM { } ;
 
        $*binode

-       Block -> { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
-       |        { SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
+       Block -> { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl;     // UNTESTED
+               }$
+       |        { SimpleStatements } ${ $0 = reorder_bilist($<SS);     // UNTESTED
+               }$

        |        SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$
        |        SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$

-       |        SimpleStatements EOL ${ $0 = reorder_bilist($<SS); }$
+       |        SimpleStatements EOL ${ $0 = reorder_bilist($<SS);     // UNTESTED
+               }$

        |        IN OptNL Statementlist OUT ${ $0 = $<Sl; }$
 
        |        IN OptNL Statementlist OUT ${ $0 = $<Sl; }$
 

-       OpenBlock -> OpenScope { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
+       OpenBlock -> OpenScope { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl;       // UNTESTED
+               }$

        |        OpenScope { SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
        |        OpenScope SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$
        |        OpenScope SimpleStatements EOL ${ $0 = reorder_bilist($<SS); }$
        |        IN OpenScope OptNL Statementlist OUT ${ $0 = $<Sl; }$
 
        |        OpenScope { SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
        |        OpenScope SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$
        |        OpenScope SimpleStatements EOL ${ $0 = reorder_bilist($<SS); }$
        |        IN OpenScope OptNL Statementlist OUT ${ $0 = $<Sl; }$
 

-       UseBlock -> { OpenScope IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
+       UseBlock -> { OpenScope IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl;        // UNTESTED
+               }$

        |        { OpenScope SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
        |        IN OpenScope OptNL Statementlist OUT ${ $0 = $<Sl; }$
 
        |        { OpenScope SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
        |        IN OpenScope OptNL Statementlist OUT ${ $0 = $<Sl; }$
 

-       ColonBlock -> { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
+       ColonBlock -> { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl;        // UNTESTED
+               }$

        |        { SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
        |        : SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$
        |        : SimpleStatements EOL ${ $0 = reorder_bilist($<SS); }$
        |        { SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
        |        : SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$
        |        : SimpleStatements EOL ${ $0 = reorder_bilist($<SS); }$


@@ -4584,7 +4584,7 @@ the common header for all reductions to use.
 
        ComplexStatements -> ComplexStatements ComplexStatement ${
                if ($2 == NULL) {
 
        ComplexStatements -> ComplexStatements ComplexStatement ${
                if ($2 == NULL) {

-                       $0 = $<1;
+                       $0 = $<1;       // NOTEST - impossible

                } else {
                        $0 = new(binode);
                        $0->op = Block;
                } else {
                        $0 = new(binode);
                        $0->op = Block;


@@ -4594,7 +4594,7 @@ the common header for all reductions to use.
        }$
        | ComplexStatement ${
                if ($1 == NULL) {
        }$
        | ComplexStatement ${
                if ($1 == NULL) {

-                       $0 = NULL;
+                       $0 = NULL;      // NOTEST - impossible

                } else {
                        $0 = new(binode);
                        $0->op = Block;
                } else {
                        $0 = new(binode);
                        $0->op = Block;


@@ -4634,25 +4634,13 @@ the common header for all reductions to use.
 
 ###### print binode cases
        case Block:
 
 ###### print binode cases
        case Block:

-               if (indent < 0) {
-                       // simple statement
-                       if (b->left == NULL)    // UNTESTED
-                               printf("pass"); // UNTESTED
-                       else
-                               print_exec(b->left, indent, bracket);   // UNTESTED
-                       if (b->right) { // UNTESTED
-                               printf("; ");   // UNTESTED
-                               print_exec(b->right, indent, bracket);  // UNTESTED
-                       }
-               } else {
-                       // block, one per line
-                       if (b->left == NULL)
-                               do_indent(indent, "pass\n");
-                       else
-                               print_exec(b->left, indent, bracket);
-                       if (b->right)
-                               print_exec(b->right, indent, bracket);
-               }
+               // block, one per line
+               if (b->left == NULL)
+                       do_indent(indent, "pass\n");
+               else
+                       print_exec(b->left, indent, bracket);
+               if (b->right)
+                       print_exec(b->right, indent, bracket);

                break;
 
 ###### propagate binode cases
                break;
 
 ###### propagate binode cases


@@ -5382,9 +5370,7 @@ casepart` to track a list of case parts.
 
 ###### propagate binode cases
        case Loop:
 
 ###### propagate binode cases
        case Loop:

-               t = propagate_types(b->right, c, perr_local, Tnone, 0);
-               if (!type_compat(Tnone, t, 0))
-                       *perr |= Efail; // UNTESTED
+               propagate_types(b->right, c, perr_local, Tnone, 0);

                return propagate_types(b->left, c, perr, type, rules);
 
 ###### propagate exec cases
                return propagate_types(b->left, c, perr, type, rules);
 
 ###### propagate exec cases


@@ -5404,13 +5390,9 @@ casepart` to track a list of case parts.
                struct casepart *cp;
 
                t = propagate_types(cs->forpart, c, perr, Tnone, 0);
                struct casepart *cp;
 
                t = propagate_types(cs->forpart, c, perr, Tnone, 0);

-               if (!type_compat(Tnone, t, 0))
-                       *perr |= Efail; // UNTESTED

 
                if (cs->looppart) {
                        t = propagate_types(cs->thenpart, c, perr, Tnone, 0);
 
                if (cs->looppart) {
                        t = propagate_types(cs->thenpart, c, perr, Tnone, 0);

-                       if (!type_compat(Tnone, t, 0))
-                               *perr |= Efail; // UNTESTED

                }
                if (cs->casepart == NULL) {
                        propagate_types(cs->condpart, c, perr, Tbool, 0);
                }
                if (cs->casepart == NULL) {
                        propagate_types(cs->condpart, c, perr, Tbool, 0);


@@ -5422,9 +5404,9 @@ casepart` to track a list of case parts.
                             cp && !t; cp = cp->next)
                                t = propagate_types(cp->value, c, perr, NULL, 0);
                        if (!t && cs->condpart)
                             cp && !t; cp = cp->next)
                                t = propagate_types(cp->value, c, perr, NULL, 0);
                        if (!t && cs->condpart)

-                               t = propagate_types(cs->condpart, c, perr, NULL, Rboolok);      // UNTESTED
+                               t = propagate_types(cs->condpart, c, perr, NULL, Rboolok);      // NOTEST

                        if (!t && cs->looppart)
                        if (!t && cs->looppart)

-                               t = propagate_types(cs->looppart, c, perr, NULL, Rboolok);      // UNTESTED
+                               t = propagate_types(cs->looppart, c, perr, NULL, Rboolok);      // NOTEST

                        // Now we have a type (I hope) push it down
                        if (t) {
                                for (cp = cs->casepart; cp; cp = cp->next)
                        // Now we have a type (I hope) push it down
                        if (t) {
                                for (cp = cs->casepart; cp; cp = cp->next)


@@ -5440,8 +5422,8 @@ casepart` to track a list of case parts.
                        type = propagate_types(cs->elsepart, c, perr, NULL, rules);
                for (cp = cs->casepart;
                     cp && !type;
                        type = propagate_types(cs->elsepart, c, perr, NULL, rules);
                for (cp = cs->casepart;
                     cp && !type;

-                    cp = cp->next)     // UNTESTED
-                       type = propagate_types(cp->action, c, perr, NULL, rules);       // UNTESTED
+                    cp = cp->next)     // NOTEST
+                       type = propagate_types(cp->action, c, perr, NULL, rules);       // NOTEST

                if (type) {
                        if (!cs->looppart)
                                propagate_types(cs->thenpart, c, perr, type, rules);
                if (type) {
                        if (!cs->looppart)
                                propagate_types(cs->thenpart, c, perr, type, rules);


@@ -5539,7 +5521,7 @@ various declarations in the parse context.
        | DeclarationList Declaration
 
        Declaration -> ERROR Newlines ${
        | DeclarationList Declaration
 
        Declaration -> ERROR Newlines ${

-               tok_err(c,      // UNTESTED
+               tok_err(c,      // NOTEST

                        "error: unhandled parse error", &$1);
        }$
        | DeclareConstant
                        "error: unhandled parse error", &$1);
        }$
        | DeclareConstant


@@ -5950,15 +5932,12 @@ is a bit more interesting at this level.
                        struct value *vl = var_value(c, v->var);
                        struct value arg;
                        struct type *t;
                        struct value *vl = var_value(c, v->var);
                        struct value arg;
                        struct type *t;

-                       mpq_t argcq;

                        int i;
 
                        switch (anum++) {
                        case 0: /* argv */
                                t = v->var->type;
                        int i;
 
                        switch (anum++) {
                        case 0: /* argv */
                                t = v->var->type;

-                               mpq_init(argcq);
-                               mpq_set_ui(argcq, argc, 1);
-                               memcpy(var_value(c, t->array.vsize), &argcq, sizeof(argcq));
+                               t->array.size = argc;

                                t->prepare_type(c, t, 0);
                                array_init(v->var->type, vl);
                                for (i = 0; i < argc; i++) {
                                t->prepare_type(c, t, 0);
                                array_init(v->var->type, vl);
                                for (i = 0; i < argc; i++) {


@@ -6012,7 +5991,7 @@ things which will likely grow as the languages grows.
                name:string
                alive:Boolean
 
                name:string
                alive:Boolean
 

-       func main(argv:[argc::]string)
+       func main(argv:[]string)

                print "Hello World, what lovely oceans you have!"
                print "Are there", five, "?"
                print pi, pie, "but", cake
                print "Hello World, what lovely oceans you have!"
                print "Are there", five, "?"
                print pi, pie, "but", cake