]> ocean-lang.org Git - ocean/blobdiff - csrc/oceani.mdc
oceani: drop "program" in favour of "func"
[ocean] / csrc / oceani.mdc
index c6163a679c2ff92c8afbf6b969e0c56854829d3d..fd753ce5e0b0d43484fb6959e19cb30c7ee04aab 100644 (file)
@@ -41,10 +41,12 @@ short-circuit Boolean operators, and the "if ... else" trinary
 operator which can select between two expressions based on a third
 (which appears syntactically in the middle).
 
-Elements that are present purely to make a usable language, and
-without any expectation that they will remain, are the "program'
-clause, which provides a list of variables to received command-line
-arguments, and the "print" statement which performs simple output.
+The "func" clause currently only allows a "main" function to be
+declared.  That will be extended when proper function support is added.
+
+An element that is present purely to make a usable language, and
+without any expectation that they will remain, is the "print" statement
+which performs simple output.
 
 The current scalar types are "number", "Boolean", and "string".
 Boolean will likely stay in its current form, the other two might, but
@@ -72,7 +74,8 @@ So the main requirements of the interpreter are:
 - Parse the program, possibly with tracing,
 - Analyse the parsed program to ensure consistency,
 - Print the program,
-- Execute the program, if no parsing or consistency errors were found.
+- Execute the "main" function in the program, if no parsing or
+  consistency errors were found.
 
 This is all performed by a single C program extracted with
 `parsergen`.
@@ -105,6 +108,7 @@ structures can be used.
 
 ###### Parser: header
        ## macros
+       struct parse_context;
        ## ast
        struct parse_context {
                struct token_config config;
@@ -225,11 +229,11 @@ structures can be used.
                                exit(1);
                        }
                } else
-                       ss = s;
+                       ss = s;                         // NOTEST
                parse_oceani(ss->code, &context.config, dotrace ? stderr : NULL);
 
                if (!context.prog) {
-                       fprintf(stderr, "oceani: no program found.\n");
+                       fprintf(stderr, "oceani: no main function found.\n");
                        context.parse_error = 1;
                }
                if (context.prog && doprint) {
@@ -242,7 +246,7 @@ structures can be used.
                                fprintf(stderr, "oceani: type error in program - not running.\n");
                                exit(1);
                        }
-                       interp_prog(context.prog, argv+optind+1);
+                       interp_prog(&context, context.prog, argc - optind, argv+optind);
                }
                free_exec(context.prog);
 
@@ -429,6 +433,7 @@ Named type are stored in a simple linked list.  Objects of each type are
                struct type *next;
                int size, align;
                void (*init)(struct type *type, struct value *val);
+               void (*prepare_type)(struct parse_context *c, struct type *type, int parse_time);
                void (*print)(struct type *type, struct value *val);
                void (*print_type)(struct type *type, FILE *f);
                int (*cmp_order)(struct type *t1, struct type *t2,
@@ -492,7 +497,7 @@ Named type are stored in a simple linked list.  Objects of each type are
        static void type_print(struct type *type, FILE *f)
        {
                if (!type)
-                       fputs("*unknown*type*", f);
+                       fputs("*unknown*type*", f);     // NOTEST
                else if (type->name.len)
                        fprintf(f, "%.*s", type->name.len, type->name.txt);
                else if (type->print_type)
@@ -507,7 +512,7 @@ Named type are stored in a simple linked list.  Objects of each type are
                        type->init(type, val);
        }
 
-       static void dup_value(struct type *type, 
+       static void dup_value(struct type *type,
                              struct value *vold, struct value *vnew)
        {
                if (type && type->dup)
@@ -521,7 +526,7 @@ Named type are stored in a simple linked list.  Objects of each type are
                        return tl->cmp_order(tl, tr, left, right);
                if (tl && tl->cmp_eq)
                        return tl->cmp_eq(tl, tr, left, right);
-               return -1;
+               return -1;                              // NOTEST
        }
 
        static void print_value(struct type *type, struct value *v)
@@ -532,20 +537,6 @@ Named type are stored in a simple linked list.  Objects of each type are
                        printf("*Unknown*");            // NOTEST
        }
 
-       static struct value *val_alloc(struct type *t, struct value *init)
-       {
-               struct value *ret;
-
-               if (!t->size)
-                       val_init(t, NULL);
-               ret = calloc(1, t->size);
-               if (init)
-                       memcpy(ret, init, t->size);
-               else
-                       val_init(t, ret);
-               return ret;
-       }
-
 ###### forward decls
 
        static void free_value(struct type *type, struct value *v);
@@ -569,6 +560,30 @@ Named type are stored in a simple linked list.  Objects of each type are
                free(t);
        }
 
+Type can be specified for local variables, for fields in a structure,
+for formal parameters to functions, and possibly elsewhere.  Different
+rules may apply in different contexts.  As a minimum, a named type may
+always be used.  Currently the type of a formal parameter can be
+different from types in other contexts, so we have a separate grammar
+symbol for those.
+
+###### Grammar
+
+       $*type
+       Type -> IDENTIFIER ${
+               $0 = find_type(c, $1.txt);
+               if (!$0) {
+                       tok_err(c,
+                               "error: undefined type", &$1);
+
+                       $0 = Tnone;
+               }
+       }$
+       ## type grammar
+
+       FormalType -> Type ${ $0 = $<1; }$
+       ## formal type grammar
+
 #### Base Types
 
 Values of the base types can be numbers, which we represent as
@@ -588,11 +603,11 @@ later.  In some cases a Boolean can be accepted as well as some other
 primary type, and in others any type is acceptable except a label (`Vlabel`).
 A separate function encoding these cases will simplify some code later.
 
-## type functions
+###### type functions
 
        int (*compat)(struct type *this, struct type *other);
 
-## ast functions
+###### ast functions
 
        static int type_compat(struct type *require, struct type *have, int rules)
        {
@@ -631,7 +646,7 @@ A separate function encoding these cases will simplify some code later.
        static void _free_value(struct type *type, struct value *v)
        {
                if (!v)
-                       return;
+                       return;         // NOTEST
                switch (type->vtype) {
                case Vnone: break;
                case Vstr: free(v->str.txt); break;
@@ -657,9 +672,9 @@ A separate function encoding these cases will simplify some code later.
                case Vbool:
                        val->bool = 0;
                        break;
-               case Vlabel:                    // NOTEST
-                       val->label = NULL;      // NOTEST
-                       break;                  // NOTEST
+               case Vlabel:
+                       val->label = NULL;
+                       break;
                }
        }
 
@@ -817,7 +832,6 @@ cannot nest, so a declaration while a name is in-scope is an error.
        struct variable {
                struct variable *previous;
                struct type *type;
-               struct value *val;
                struct binding *name;
                struct exec *where_decl;// where name was declared
                struct exec *where_set; // where type was set
@@ -967,6 +981,11 @@ recent instance.  These variables don't really belong in the
 is found.  Instead, they are detected and ignored when considering the
 list of in_scope names.
 
+The storage of the value of a variable will be described later.  For now
+we just need to know that when a variable goes out of scope, it might
+need to be freed.  For this we need to be able to find it, so assume that 
+`var_value()` will provide that.
+
 ###### variable fields
        struct variable *merged;
 
@@ -978,7 +997,7 @@ list of in_scope names.
 
                if (primary->merged)
                        // shouldn't happen
-                       primary = primary->merged;
+                       primary = primary->merged;      // NOTEST
 
                for (v = primary->previous; v; v=v->previous)
                        if (v == secondary || v == secondary->merged ||
@@ -989,6 +1008,9 @@ list of in_scope names.
                        }
        }
 
+###### forward decls
+       static struct value *var_value(struct parse_context *c, struct variable *v);
+
 ###### free context vars
 
        while (context.varlist) {
@@ -1000,8 +1022,7 @@ list of in_scope names.
                        struct variable *t = v;
 
                        v = t->previous;
-                       free_value(t->type, t->val);
-                       free(t->val);
+                       free_value(t->type, var_value(&context, t));
                        if (t->depth == 0)
                                // This is a global constant
                                free_exec(t->where_decl);
@@ -1081,7 +1102,6 @@ all pending-scope variables become conditionally scoped.
                v->scope = InScope;
                v->in_scope = c->in_scope;
                c->in_scope = v;
-               v->val = NULL;
                return v;
        }
 
@@ -1190,6 +1210,112 @@ all pending-scope variables become conditionally scoped.
                }
        }
 
+#### Storing Values
+
+The value of a variable is store separately from the variable, on an
+analogue of a stack frame.  There are (currently) two frames that can be
+active.  A global frame which currently only stores constants, and a
+stacked frame which stores local variables.  Each variable knows if it
+is global or not, and what its index into the frame is.
+
+Values in the global frame are known immediately they are relevant, so
+the frame needs to be reallocated as it grows so it can store those
+values.  The local frame doesn't get values until the interpreted phase
+is started, so there is no need to allocate until the size is known.
+
+###### variable fields
+               short frame_pos;
+               short global;
+
+###### parse context
+
+       short global_size, global_alloc;
+       short local_size;
+       void *global, *local;
+
+###### ast functions
+
+       static struct value *var_value(struct parse_context *c, struct variable *v)
+       {
+               if (!v->global) {
+                       if (!c->local || !v->type)
+                               return NULL;
+                       if (v->frame_pos + v->type->size > c->local_size) {
+                               printf("INVALID frame_pos\n");  // NOTEST
+                               exit(2);                        // NOTEST
+                       }
+                       return c->local + v->frame_pos;
+               }
+               if (c->global_size > c->global_alloc) {
+                       int old = c->global_alloc;
+                       c->global_alloc = (c->global_size | 1023) + 1024;
+                       c->global = realloc(c->global, c->global_alloc);
+                       memset(c->global + old, 0, c->global_alloc - old);
+               }
+               return c->global + v->frame_pos;
+       }
+
+       static struct value *global_alloc(struct parse_context *c, struct type *t,
+                                         struct variable *v, struct value *init)
+       {
+               struct value *ret;
+               struct variable scratch;
+
+               if (t->prepare_type)
+                       t->prepare_type(c, t, 1);
+
+               if (c->global_size & (t->align - 1))
+                       c->global_size = (c->global_size + t->align) & ~(t->align-1);
+               if (!v) {
+                       v = &scratch;
+                       v->type = t;
+               }
+               v->frame_pos = c->global_size;
+               v->global = 1;
+               c->global_size += v->type->size;
+               ret = var_value(c, v);
+               if (init)
+                       memcpy(ret, init, t->size);
+               else
+                       val_init(t, ret);
+               return ret;
+       }
+
+As global values are found -- struct field initializers, labels etc --
+`global_alloc()` is called to record the value in the global frame.
+
+When the program is fully parsed, we need to walk the list of variables
+to find any that weren't merged away and that aren't global, and to
+calculate the frame size and assign a frame position for each variable.
+For this we have `scope_finalize()`.
+
+###### ast functions
+
+       static void scope_finalize(struct parse_context *c)
+       {
+               struct binding *b;
+
+               for (b = c->varlist; b; b = b->next) {
+                       struct variable *v;
+                       for (v = b->var; v; v = v->previous) {
+                               struct type *t = v->type;
+                               if (v->merged && v->merged != v)
+                                       continue;
+                               if (v->global)
+                                       continue;
+                               if (c->local_size & (t->align - 1))
+                                       c->local_size = (c->local_size + t->align) & ~(t->align-1);
+                               v->frame_pos = c->local_size;
+                               c->local_size += v->type->size;
+                       }
+               }
+               c->local = calloc(1, c->local_size);
+       }
+
+###### free context vars
+       free(context.global);
+       free(context.local);
+
 ### Executables
 
 Executables can be lots of different things.  In many cases an
@@ -1250,8 +1376,8 @@ from the `exec_types` enum.
                }
                if (loc->type == Xbinode)
                        return __fput_loc(cast(binode,loc)->left, f) ||
-                              __fput_loc(cast(binode,loc)->right, f);
-               return 0;
+                              __fput_loc(cast(binode,loc)->right, f);  // NOTEST
+               return 0;                       // NOTEST
        }
        static void fput_loc(struct exec *loc, FILE *f)
        {
@@ -1401,8 +1527,8 @@ propagation is needed.
 
 Interpreting an `exec` doesn't require anything but the `exec`.  State
 is stored in variables and each variable will be directly linked from
-within the `exec` tree.  The exception to this is the whole `program`
-which needs to look at command line arguments.  The `program` will be
+within the `exec` tree.  The exception to this is the `main` function
+which needs to look at command line arguments.  This function will be
 interpreted separately.
 
 Each `exec` can return a value combined with a type in `struct lrval`.
@@ -1411,7 +1537,6 @@ the location of a value, which can be updated, in `lval`.  Others will
 set `lval` to NULL indicating that there is a value of appropriate type
 in `rval`.
 
-
 ###### core functions
 
        struct lrval {
@@ -1419,11 +1544,12 @@ in `rval`.
                struct value rval, *lval;
        };
 
-       static struct lrval _interp_exec(struct exec *e);
+       static struct lrval _interp_exec(struct parse_context *c, struct exec *e);
 
-       static struct value interp_exec(struct exec *e, struct type **typeret)
+       static struct value interp_exec(struct parse_context *c, struct exec *e,
+                                       struct type **typeret)
        {
-               struct lrval ret = _interp_exec(e);
+               struct lrval ret = _interp_exec(c, e);
 
                if (!ret.type) abort();
                if (typeret)
@@ -1433,16 +1559,19 @@ in `rval`.
                return ret.rval;
        }
 
-       static struct value *linterp_exec(struct exec *e, struct type **typeret)
+       static struct value *linterp_exec(struct parse_context *c, struct exec *e,
+                                         struct type **typeret)
        {
-               struct lrval ret = _interp_exec(e);
+               struct lrval ret = _interp_exec(c, e);
 
-               if (typeret)
+               if (ret.lval)
                        *typeret = ret.type;
+               else
+                       free_value(ret.type, &ret.rval);
                return ret.lval;
        }
 
-       static struct lrval _interp_exec(struct exec *e)
+       static struct lrval _interp_exec(struct parse_context *c, struct exec *e)
        {
                struct lrval ret;
                struct value rv = {}, *lrv = NULL;
@@ -1485,10 +1614,6 @@ different phases of parse, analyse, print, interpret.
 
 Thus far we have arrays and structs.
 
-Some complex types need do not exist in a name table, so they are kept
-on a linked list in the context (`anon_typelist`).  This allows them to
-be freed when parsing is complete.
-
 #### Arrays
 
 Arrays can be declared by giving a size and a type, as `[size]type' so
@@ -1496,6 +1621,12 @@ Arrays can be declared by giving a size and a type, as `[size]type' so
 size can be either a literal number, or a named constant.  Some day an
 arbitrary expression will be supported.
 
+As a formal parameter to a function, the array can be declared with a
+new variable as the size: `name:[size::number]string`.  The `size`
+variable is set to the size of the array and must be a constant.  As
+`number` is the only supported type, it can be left out:
+`name:[size::]string`.
+
 Arrays cannot be assigned.  When pointers are introduced we will also
 introduce array slices which can refer to part or all of an array -
 the assignment syntax will create a slice.  For now, an array can only
@@ -1503,36 +1634,69 @@ ever be referenced by the name it is declared with.  It is likely that
 a "`copy`" primitive will eventually be define which can be used to
 make a copy of an array with controllable recursive depth.
 
+For now we have two sorts of array, those with fixed size either because
+it is given as a literal number or because it is a struct member (which
+cannot have a runtime-changing size), and those with a size that is
+determined at runtime - local variables with a const size.  The former
+have their size calculated at parse time, the latter at run time.
+
+For the latter type, the `size` field of the type is the size of a
+pointer, and the array is reallocated every time it comes into scope.
+
+We differentiate struct fields with a const size from local variables
+with a const size by whether they are prepared at parse time or not.
+
 ###### type union fields
 
        struct {
-               int size;
+               int unspec;     // size is unspecified - vsize must be set.
+               short size;
+               short static_size;
                struct variable *vsize;
                struct type *member;
        } array;
 
+###### value union fields
+       void *array;  // used if not static_size
+
 ###### value functions
 
-       static void array_init(struct type *type, struct value *val)
+       static void array_prepare_type(struct parse_context *c, struct type *type,
+                                      int parse_time)
        {
-               int i;
+               struct value *vsize;
+               mpz_t q;
+               if (!type->array.vsize || type->array.static_size)
+                       return;
 
-               if (type->array.vsize) {
-                       mpz_t q;
-                       mpz_init(q);
-                       mpz_tdiv_q(q, mpq_numref(type->array.vsize->val->num),
-                                  mpq_denref(type->array.vsize->val->num));
-                       type->array.size = mpz_get_si(q);
-                       mpz_clear(q);
+               vsize = var_value(c, type->array.vsize);
+               mpz_init(q);
+               mpz_tdiv_q(q, mpq_numref(vsize->num), mpq_denref(vsize->num));
+               type->array.size = mpz_get_si(q);
+               mpz_clear(q);
+
+               if (parse_time) {
+                       type->array.static_size = 1;
+                       type->size = type->array.size * type->array.member->size;
+                       type->align = type->array.member->align;
                }
-               type->size = type->array.size * type->array.member->size;
-               type->align = type->array.member->align;
+       }
+
+       static void array_init(struct type *type, struct value *val)
+       {
+               int i;
+               void *ptr = val->ptr;
 
                if (!val)
-                       return;         
+                       return;
+               if (!type->array.static_size) {
+                       val->array = calloc(type->array.size, 
+                                           type->array.member->size);
+                       ptr = val->array;
+               }
                for (i = 0; i < type->array.size; i++) {
                        struct value *v;
-                       v = (void*)val->ptr + i * type->array.member->size;
+                       v = (void*)ptr + i * type->array.member->size;
                        val_init(type->array.member, v);
                }
        }
@@ -1540,12 +1704,17 @@ make a copy of an array with controllable recursive depth.
        static void array_free(struct type *type, struct value *val)
        {
                int i;
+               void *ptr = val->ptr;
 
+               if (!type->array.static_size)
+                       ptr = val->array;
                for (i = 0; i < type->array.size; i++) {
                        struct value *v;
-                       v = (void*)val->ptr + i * type->array.member->size;
+                       v = (void*)ptr + i * type->array.member->size;
                        free_value(type->array.member, v);
                }
+               if (!type->array.static_size)
+                       free(ptr);
        }
 
        static int array_compat(struct type *require, struct type *have)
@@ -1555,6 +1724,15 @@ make a copy of an array with controllable recursive depth.
                /* 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)
+                               /* sizes might not be the same */
+                               return 0;
+                       return 1;
+               }
+               if (have->array.unspec || require->array.unspec)
+                       return 1;
                if (require->array.vsize == NULL && have->array.vsize == NULL)
                        return require->array.size == have->array.size;
 
@@ -1566,7 +1744,8 @@ make a copy of an array with controllable recursive depth.
                fputs("[", f);
                if (type->array.vsize) {
                        struct binding *b = type->array.vsize->name;
-                       fprintf(f, "%.*s]", b->name.len, b->name.txt);
+                       fprintf(f, "%.*s%s]", b->name.len, b->name.txt,
+                               type->array.unspec ? "::" : "");
                } else
                        fprintf(f, "%d]", type->array.size);
                type_print(type->array.member, f);
@@ -1574,9 +1753,12 @@ make a copy of an array with controllable recursive depth.
 
        static struct type array_prototype = {
                .init = array_init,
+               .prepare_type = array_prepare_type,
                .print_type = array_print_type,
                .compat = array_compat,
                .free = array_free,
+               .size = sizeof(void*),
+               .align = sizeof(void*),
        };
 
 ###### declare terminals
@@ -1584,20 +1766,21 @@ make a copy of an array with controllable recursive depth.
 
 ###### type grammar
 
-       | [ NUMBER ] Type ${
-               $0 = calloc(1, sizeof(struct type));
-               *($0) = array_prototype;
-               $0->array.member = $<4;
-               $0->array.vsize = NULL;
-               {
+       | [ NUMBER ] Type ${ {
                char tail[3];
                mpq_t num;
+               struct text noname = { "", 0 };
+               struct type *t;
+
+               $0 = t = add_type(c, noname, &array_prototype);
+               t->array.member = $<4;
+               t->array.vsize = NULL;
                if (number_parse(num, tail, $2.txt) == 0)
                        tok_err(c, "error: unrecognised number", &$2);
                else if (tail[0])
                        tok_err(c, "error: unsupported number suffix", &$2);
                else {
-                       $0->array.size = mpz_get_ui(mpq_numref(num));
+                       t->array.size = mpz_get_ui(mpq_numref(num));
                        if (mpz_cmp_ui(mpq_denref(num), 1) != 0) {
                                tok_err(c, "error: array size must be an integer",
                                        &$2);
@@ -1606,40 +1789,47 @@ make a copy of an array with controllable recursive depth.
                                        &$2);
                        mpq_clear(num);
                }
-               $0->next = c->anon_typelist;
-               c->anon_typelist = $0;
-               }
-       }$
+               t->array.static_size = 1;
+               t->size = t->array.size * t->array.member->size;
+               t->align = t->array.member->align;
+       } }$
 
        | [ IDENTIFIER ] Type ${ {
                struct variable *v = var_ref(c, $2.txt);
+               struct text noname = { "", 0 };
 
                if (!v)
                        tok_err(c, "error: name undeclared", &$2);
                else if (!v->constant)
                        tok_err(c, "error: array size must be a constant", &$2);
 
-               $0 = calloc(1, sizeof(struct type));
-               *($0) = array_prototype;
+               $0 = add_type(c, noname, &array_prototype);
                $0->array.member = $<4;
                $0->array.size = 0;
                $0->array.vsize = v;
-               $0->next = c->anon_typelist;
-               c->anon_typelist = $0;
        } }$
 
-###### parse context
-
-       struct type *anon_typelist;
+###### Grammar
+       $*type
+       OptType -> Type ${ $0 = $<1; }$
+               | ${ $0 = NULL; }$
 
-###### free context types
+###### formal type grammar
 
-       while (context.anon_typelist) {
-               struct type *t = context.anon_typelist;
+       | [ IDENTIFIER :: OptType ] Type ${ {
+               struct variable *v = var_decl(c, $ID.txt);
+               struct text noname = { "", 0 };
 
-               context.anon_typelist = t->next;
-               free(t);
-       }
+               v->type = $<OT;
+               v->constant = 1;
+               if (!v->type)
+                       v->type = Tnum;
+               $0 = add_type(c, noname, &array_prototype);
+               $0->array.member = $<6;
+               $0->array.size = 0;
+               $0->array.unspec = 1;
+               $0->array.vsize = v;
+       } }$
 
 ###### Binode types
        Index,
@@ -1685,17 +1875,22 @@ make a copy of an array with controllable recursive depth.
        case Index: {
                mpz_t q;
                long i;
+               void *ptr;
 
-               lleft = linterp_exec(b->left, &ltype);
-               right = interp_exec(b->right, &rtype);
+               lleft = linterp_exec(c, b->left, &ltype);
+               right = interp_exec(c, b->right, &rtype);
                mpz_init(q);
                mpz_tdiv_q(q, mpq_numref(right.num), mpq_denref(right.num));
                i = mpz_get_si(q);
                mpz_clear(q);
 
+               if (ltype->array.static_size)
+                       ptr = lleft;
+               else
+                       ptr = *(void**)lleft;
                rvtype = ltype->array.member;
                if (i >= 0 && i < ltype->array.size)
-                       lrv = (void*)lleft + i * rvtype->size;
+                       lrv = ptr + i * rvtype->size;
                else
                        val_init(ltype->array.member, &rv);
                ltype = NULL;
@@ -1767,7 +1962,12 @@ function will be needed.
                for (i = 0; i < type->structure.nfields; i++) {
                        struct value *v;
                        v = (void*) val->ptr + type->structure.fields[i].offset;
-                       val_init(type->structure.fields[i].type, v);
+                       if (type->structure.fields[i].init)
+                               dup_value(type->structure.fields[i].type, 
+                                         type->structure.fields[i].init,
+                                         v);
+                       else
+                               val_init(type->structure.fields[i].type, v);
                }
        }
 
@@ -1789,7 +1989,6 @@ function will be needed.
                        if (t->structure.fields[i].init) {
                                free_value(t->structure.fields[i].type,
                                           t->structure.fields[i].init);
-                               free(t->structure.fields[i].init);
                        }
                free(t->structure.fields);
        }
@@ -1885,7 +2084,7 @@ function will be needed.
        {
                struct fieldref *f = cast(fieldref, e);
                struct type *ltype;
-               struct value *lleft = linterp_exec(f->left, &ltype);
+               struct value *lleft = linterp_exec(c, f->left, &ltype);
                lrv = (void*)lleft->ptr + ltype->structure.fields[f->index].offset;
                rvtype = ltype->structure.fields[f->index].type;
                break;
@@ -1974,15 +2173,16 @@ function will be needed.
                        if (!ok)
                                c->parse_error = 1;
                        else {
-                               struct value vl = interp_exec($5, NULL);
-                               $0->f.init = val_alloc($0->f.type, &vl);
+                               struct value vl = interp_exec(c, $5, NULL);
+                               $0->f.init = global_alloc(c, $0->f.type, NULL, &vl);
                        }
                } }$
                | IDENTIFIER : Type ${
                        $0 = calloc(1, sizeof(struct fieldlist));
                        $0->f.name = $1.txt;
                        $0->f.type = $<3;
-                       $0->f.init = val_alloc($0->f.type, NULL);
+                       if ($0->f.type->prepare_type)
+                               $0->f.type->prepare_type(c, $0->f.type, 1);
                }$
 
 ###### forward decls
@@ -2034,6 +2234,92 @@ function will be needed.
                }
        }
 
+### Functions
+
+A function is a named chunk of code which can be passed parameters and
+can return results.  Each function has an implicit type which includes
+the set of parameters and the return value.  As yet these types cannot
+be declared separate from the function itself.
+
+In fact, only one function is currently possible - `main`.  `main` is
+passed an array of strings together with the size of the array, and
+doesn't return anything.  The strings are command line arguments.
+
+The parameters can be specified either in parentheses as a list, such as
+
+##### Example: function 1
+
+       func main(av:[ac::number]string)
+               code block
+
+or as an indented list of one parameter per line
+
+##### Example: function 2
+
+       func main
+               argv:[argc::number]string
+       do
+               code block
+
+###### Binode types
+       Func, List,
+
+###### Grammar
+
+       $TERM func main
+
+       $*binode
+       MainFunction -> func main ( OpenScope Args ) Block Newlines ${
+                       $0 = new(binode);
+                       $0->op = Func;
+                       $0->left = reorder_bilist($<Ar);
+                       $0->right = $<Bl;
+                       var_block_close(c, CloseSequential);
+                       if (c->scope_stack && !c->parse_error) abort();
+               }$
+               | func main IN OpenScope OptNL Args OUT OptNL do Block Newlines ${
+                       $0 = new(binode);
+                       $0->op = Func;
+                       $0->left = reorder_bilist($<Ar);
+                       $0->right = $<Bl;
+                       var_block_close(c, CloseSequential);
+                       if (c->scope_stack && !c->parse_error) abort();
+               }$
+               | func main NEWLINE OpenScope OptNL do Block Newlines ${
+                       $0 = new(binode);
+                       $0->op = Func;
+                       $0->left = NULL;
+                       $0->right = $<Bl;
+                       var_block_close(c, CloseSequential);
+                       if (c->scope_stack && !c->parse_error) abort();
+               }$
+
+       Args -> ${ $0 = NULL; }$
+               | Varlist ${ $0 = $<1; }$
+               | Varlist ; ${ $0 = $<1; }$
+               | Varlist NEWLINE ${ $0 = $<1; }$
+
+       Varlist -> Varlist ; ArgDecl ${
+                       $0 = new(binode);
+                       $0->op = List;
+                       $0->left = $<Vl;
+                       $0->right = $<AD;
+               }$
+               | ArgDecl ${
+                       $0 = new(binode);
+                       $0->op = List;
+                       $0->left = NULL;
+                       $0->right = $<AD;
+               }$
+
+       $*var
+       ArgDecl -> IDENTIFIER : FormalType ${ {
+               struct variable *v = var_decl(c, $1.txt);
+               $0 = new(var);
+               $0->var = v;
+               v->type = $<FT;
+       } }$
+
 ## Executables: the elements of code
 
 Each code element needs to be parsed, printed, analysed,
@@ -2232,7 +2518,6 @@ link to find the primary instance.
                        v->where_decl = $0;
                        v->where_set = $0;
                        v->type = $<Type;
-                       v->val = NULL;
                } else {
                        v = var_ref(c, $1.txt);
                        $0->var = v;
@@ -2250,7 +2535,6 @@ link to find the primary instance.
                        v->where_decl = $0;
                        v->where_set = $0;
                        v->type = $<Type;
-                       v->val = NULL;
                        v->constant = 1;
                } else {
                        v = var_ref(c, $1.txt);
@@ -2270,7 +2554,6 @@ link to find the primary instance.
                        /* This might be a label - allocate a var just in case */
                        v = var_decl(c, $1.txt);
                        if (v) {
-                               v->val = NULL;
                                v->type = Tnone;
                                v->where_decl = $0;
                                v->where_set = $0;
@@ -2280,18 +2563,6 @@ link to find the primary instance.
        } }$
        ## variable grammar
 
-       $*type
-       Type -> IDENTIFIER ${
-               $0 = find_type(c, $1.txt);
-               if (!$0) {
-                       tok_err(c,
-                               "error: undefined type", &$1);
-
-                       $0 = Tnone;
-               }
-       }$
-       ## type grammar
-
 ###### print exec cases
        case Xvar:
        {
@@ -2305,7 +2576,7 @@ link to find the primary instance.
 
 ###### format cases
        case 'v':
-               if (loc->type == Xvar) {
+               if (loc && loc->type == Xvar) {
                        struct var *v = cast(var, loc);
                        if (v->var) {
                                struct binding *b = v->var->name;
@@ -2341,7 +2612,6 @@ link to find the primary instance.
                if (v->type == NULL) {
                        if (type && *ok != 0) {
                                v->type = type;
-                               v->val = NULL;
                                v->where_set = prog;
                                *ok = 2;
                        }
@@ -2366,7 +2636,7 @@ link to find the primary instance.
 
                if (v->merged)
                        v = v->merged;
-               lrv = v->val;
+               lrv = var_value(c, v);
                rvtype = v->type;
                break;
        }
@@ -2448,11 +2718,11 @@ there.
 
        case CondExpr: {
                struct binode *b2 = cast(binode, b->right);
-               left = interp_exec(b->left, &ltype);
+               left = interp_exec(c, b->left, &ltype);
                if (left.bool)
-                       rv = interp_exec(b2->left, &rvtype);
+                       rv = interp_exec(c, b2->left, &rvtype);
                else
-                       rv = interp_exec(b2->right, &rvtype);
+                       rv = interp_exec(c, b2->right, &rvtype);
                }
                break;
 
@@ -2565,27 +2835,27 @@ evaluate the second expression if not necessary.
 
 ###### interp binode cases
        case And:
-               rv = interp_exec(b->left, &rvtype);
-               right = interp_exec(b->right, &rtype);
+               rv = interp_exec(c, b->left, &rvtype);
+               right = interp_exec(c, b->right, &rtype);
                rv.bool = rv.bool && right.bool;
                break;
        case AndThen:
-               rv = interp_exec(b->left, &rvtype);
+               rv = interp_exec(c, b->left, &rvtype);
                if (rv.bool)
-                       rv = interp_exec(b->right, NULL);
+                       rv = interp_exec(c, b->right, NULL);
                break;
        case Or:
-               rv = interp_exec(b->left, &rvtype);
-               right = interp_exec(b->right, &rtype);
+               rv = interp_exec(c, b->left, &rvtype);
+               right = interp_exec(c, b->right, &rtype);
                rv.bool = rv.bool || right.bool;
                break;
        case OrElse:
-               rv = interp_exec(b->left, &rvtype);
+               rv = interp_exec(c, b->left, &rvtype);
                if (!rv.bool)
-                       rv = interp_exec(b->right, NULL);
+                       rv = interp_exec(c, b->right, NULL);
                break;
        case Not:
-               rv = interp_exec(b->right, &rvtype);
+               rv = interp_exec(c, b->right, &rvtype);
                rv.bool = !rv.bool;
                break;
 
@@ -2693,8 +2963,8 @@ expression operator, and the `CMPop` non-terminal will match one of them.
        case NEql:
        {
                int cmp;
-               left = interp_exec(b->left, &ltype);
-               right = interp_exec(b->right, &rtype);
+               left = interp_exec(c, b->left, &ltype);
+               right = interp_exec(c, b->right, &rtype);
                cmp = value_cmp(ltype, rtype, &left, &right);
                rvtype = Tbool;
                switch (b->op) {
@@ -2868,30 +3138,30 @@ should only insert brackets were needed for precedence.
 ###### interp binode cases
 
        case Plus:
-               rv = interp_exec(b->left, &rvtype);
-               right = interp_exec(b->right, &rtype);
+               rv = interp_exec(c, b->left, &rvtype);
+               right = interp_exec(c, b->right, &rtype);
                mpq_add(rv.num, rv.num, right.num);
                break;
        case Minus:
-               rv = interp_exec(b->left, &rvtype);
-               right = interp_exec(b->right, &rtype);
+               rv = interp_exec(c, b->left, &rvtype);
+               right = interp_exec(c, b->right, &rtype);
                mpq_sub(rv.num, rv.num, right.num);
                break;
        case Times:
-               rv = interp_exec(b->left, &rvtype);
-               right = interp_exec(b->right, &rtype);
+               rv = interp_exec(c, b->left, &rvtype);
+               right = interp_exec(c, b->right, &rtype);
                mpq_mul(rv.num, rv.num, right.num);
                break;
        case Divide:
-               rv = interp_exec(b->left, &rvtype);
-               right = interp_exec(b->right, &rtype);
+               rv = interp_exec(c, b->left, &rvtype);
+               right = interp_exec(c, b->right, &rtype);
                mpq_div(rv.num, rv.num, right.num);
                break;
        case Rem: {
                mpz_t l, r, rem;
 
-               left = interp_exec(b->left, &ltype);
-               right = interp_exec(b->right, &rtype);
+               left = interp_exec(c, b->left, &ltype);
+               right = interp_exec(c, b->right, &rtype);
                mpz_init(l); mpz_init(r); mpz_init(rem);
                mpz_tdiv_q(l, mpq_numref(left.num), mpq_denref(left.num));
                mpz_tdiv_q(r, mpq_numref(right.num), mpq_denref(right.num));
@@ -2903,24 +3173,24 @@ should only insert brackets were needed for precedence.
                break;
        }
        case Negate:
-               rv = interp_exec(b->right, &rvtype);
+               rv = interp_exec(c, b->right, &rvtype);
                mpq_neg(rv.num, rv.num);
                break;
        case Absolute:
-               rv = interp_exec(b->right, &rvtype);
+               rv = interp_exec(c, b->right, &rvtype);
                mpq_abs(rv.num, rv.num);
                break;
        case Bracket:
-               rv = interp_exec(b->right, &rvtype);
+               rv = interp_exec(c, b->right, &rvtype);
                break;
        case Concat:
-               left = interp_exec(b->left, &ltype);
-               right = interp_exec(b->right, &rtype);
+               left = interp_exec(c, b->left, &ltype);
+               right = interp_exec(c, b->right, &rtype);
                rvtype = Tstr;
                rv.str = text_join(left.str, right.str);
                break;
        case StringConv:
-               right = interp_exec(b->right, &rvtype);
+               right = interp_exec(c, b->right, &rvtype);
                rtype = Tstr;
                rvtype = Tnum;
 
@@ -3142,7 +3412,7 @@ is in-place.
                while (rvtype == Tnone &&
                       b) {
                        if (b->left)
-                               rv = interp_exec(b->left, &rvtype);
+                               rv = interp_exec(c, b->left, &rvtype);
                        b = cast(binode, b->right);
                }
                break;
@@ -3231,7 +3501,7 @@ same solution.
                        if (b->left) {
                                if (sep)
                                        putchar(sep);
-                               left = interp_exec(b->left, &ltype);
+                               left = interp_exec(c, b->left, &ltype);
                                print_value(ltype, &left);
                                free_value(ltype, &left);
                                if (b->right)
@@ -3362,8 +3632,8 @@ it is declared, and error will be raised as the name is created as
 ###### interp binode cases
 
        case Assign:
-               lleft = linterp_exec(b->left, &ltype);
-               right = interp_exec(b->right, &rtype);
+               lleft = linterp_exec(c, b->left, &ltype);
+               right = interp_exec(c, b->right, &rtype);
                if (lleft) {
                        free_value(ltype, lleft);
                        dup_value(ltype, &right, lleft);
@@ -3374,17 +3644,19 @@ it is declared, and error will be raised as the name is created as
        case Declare:
        {
                struct variable *v = cast(var, b->left)->var;
+               struct value *val;
                if (v->merged)
                        v = v->merged;
+               val = var_value(c, v);
+               free_value(v->type, val);
+               if (v->type->prepare_type)
+                       v->type->prepare_type(c, v->type, 0);
                if (b->right) {
-                       right = interp_exec(b->right, &rtype);
-                       free_value(v->type, v->val);
-                       free(v->val);
-                       v->val = val_alloc(v->type, &right);
+                       right = interp_exec(c, b->right, &rtype);
+                       memcpy(val, &right, rtype->size);
                        rtype = Tnone;
                } else {
-                       free_value(v->type, v->val);
-                       v->val = val_alloc(v->type, NULL);
+                       val_init(v->type, val);
                }
                break;
        }
@@ -3411,9 +3683,11 @@ function.
                        struct var *v = cast(var, $0->right);
                        if (v->var->type == Tnone) {
                                /* Convert this to a label */
+                               struct value *val;
+
                                v->var->type = Tlabel;
-                               v->var->val = val_alloc(Tlabel, NULL);
-                               v->var->val->label = v->var->val;
+                               val = global_alloc(c, Tlabel, v->var, NULL);
+                               val->label = val;
                        }
                }
        }$
@@ -3436,7 +3710,7 @@ function.
 ###### interp binode cases
 
        case Use:
-               rv = interp_exec(b->right, &rvtype);
+               rv = interp_exec(c, b->right, &rvtype);
                break;
 
 ### The Conditional Statement
@@ -3565,7 +3839,6 @@ defined.
        // may or may not end with EOL
        // WhilePart and IfPart include an appropriate Suffix
 
-
        // Both ForPart and Whilepart open scopes, and CondSuffix only
        // closes one - so in the first branch here we have another to close.
        CondStatement -> ForPart OptNL ThenPart OptNL WhilePart CondSuffix ${
@@ -3866,44 +4139,44 @@ defined.
                struct value v, cnd;
                struct type *vtype, *cndtype;
                struct casepart *cp;
-               struct cond_statement *c = cast(cond_statement, e);
+               struct cond_statement *cs = cast(cond_statement, e);
 
-               if (c->forpart)
-                       interp_exec(c->forpart, NULL);
+               if (cs->forpart)
+                       interp_exec(c, cs->forpart, NULL);
                do {
-                       if (c->condpart)
-                               cnd = interp_exec(c->condpart, &cndtype);
+                       if (cs->condpart)
+                               cnd = interp_exec(c, cs->condpart, &cndtype);
                        else
                                cndtype = Tnone;
                        if (!(cndtype == Tnone ||
                              (cndtype == Tbool && cnd.bool != 0)))
                                break;
                        // cnd is Tnone or Tbool, doesn't need to be freed
-                       if (c->dopart)
-                               interp_exec(c->dopart, NULL);
+                       if (cs->dopart)
+                               interp_exec(c, cs->dopart, NULL);
 
-                       if (c->thenpart) {
-                               rv = interp_exec(c->thenpart, &rvtype);
-                               if (rvtype != Tnone || !c->dopart)
+                       if (cs->thenpart) {
+                               rv = interp_exec(c, cs->thenpart, &rvtype);
+                               if (rvtype != Tnone || !cs->dopart)
                                        goto Xcond_done;
                                free_value(rvtype, &rv);
                                rvtype = Tnone;
                        }
-               } while (c->dopart);
+               } while (cs->dopart);
 
-               for (cp = c->casepart; cp; cp = cp->next) {
-                       v = interp_exec(cp->value, &vtype);
+               for (cp = cs->casepart; cp; cp = cp->next) {
+                       v = interp_exec(c, cp->value, &vtype);
                        if (value_cmp(cndtype, vtype, &v, &cnd) == 0) {
                                free_value(vtype, &v);
                                free_value(cndtype, &cnd);
-                               rv = interp_exec(cp->action, &rvtype);
+                               rv = interp_exec(c, cp->action, &rvtype);
                                goto Xcond_done;
                        }
                        free_value(vtype, &v);
                }
                free_value(cndtype, &cnd);
-               if (c->elsepart)
-                       rv = interp_exec(c->elsepart, &rvtype);
+               if (cs->elsepart)
+                       rv = interp_exec(c, cs->elsepart, &rvtype);
                else
                        rvtype = Tnone;
        Xcond_done:
@@ -3919,8 +4192,8 @@ At the top level of a file there will be a number of declarations.
 Many of the things that can be declared haven't been described yet,
 such as functions, procedures, imports, and probably more.
 For now there are two sorts of things that can appear at the top
-level.  They are predefined constants, `struct` types, and the main
-program.  While the syntax will allow the main program to appear
+level.  They are predefined constants, `struct` types, and the `main`
+function.  While the syntax will allow the `main` function to appear
 multiple times, that will trigger an error if it is actually attempted.
 
 The various declarations do not return anything.  They store the
@@ -3946,11 +4219,13 @@ various declarations in the parse context.
                                "error: unhandled parse error", &$1);
                }$
                | DeclareConstant
-               | DeclareProgram
+               | DeclareFunction
                | DeclareStruct
 
        ## top level grammar
 
+       ## Grammar
+
 ### The `const` section
 
 As well as being defined in with the code that uses them, constants
@@ -4019,8 +4294,8 @@ searching through for the Nth constant for decreasing N.
                if (!ok)
                        c->parse_error = 1;
                else if (v) {
-                       struct value res = interp_exec($5, &v->type);
-                       v->val = val_alloc(v->type, &res);
+                       struct value res = interp_exec(c, $5, &v->type);
+                       global_alloc(c, v->type, v, &res);
                }
        } }$
 
@@ -4043,12 +4318,13 @@ searching through for the Nth constant for decreasing N.
                                        printf("const\n");
                                target = i;
                        } else {
+                               struct value *val = var_value(&context, v);
                                printf("    %.*s :: ", v->name->name.len, v->name->name.txt);
                                type_print(v->type, stdout);
                                printf(" = ");
                                if (v->type == Tstr)
                                        printf("\"");
-                               print_value(v->type, v->val);
+                               print_value(v->type, val);
                                if (v->type == Tstr)
                                        printf("\"");
                                printf("\n");
@@ -4057,122 +4333,102 @@ searching through for the Nth constant for decreasing N.
                }
        }
 
-### Finally the whole program.
+### Finally the whole `main` function.
 
-Somewhat reminiscent of Pascal a (current) Ocean program starts with
-the keyword "program" and a list of variable names which are assigned
-values from command line arguments.  Following this is a `block` which
-is the code to execute.  Unlike Pascal, constants and other
-declarations come *before* the program.
+An Ocean program can currently have only one function - `main` - and
+that must exist.  It expects an array of strings with a provided size.
+Following this is a `block` which is the code to execute.
 
 As this is the top level, several things are handled a bit
 differently.
-The whole program is not interpreted by `interp_exec` as that isn't
+The function is not interpreted by `interp_exec` as that isn't
 passed the argument list which the program requires.  Similarly type
 analysis is a bit more interesting at this level.
 
-###### Binode types
-       Program,
-
 ###### top level grammar
 
-       DeclareProgram -> Program ${ {
+       DeclareFunction -> MainFunction ${ {
                if (c->prog)
-                       type_err(c, "Program defined a second time",
+                       type_err(c, "\"main\" defined a second time",
                                 $1, NULL, 0, NULL);
                else
                        c->prog = $<1;
        } }$
 
-       $TERM program
-
-       $*binode
-       Program -> program OpenScope Varlist ColonBlock Newlines ${
-               $0 = new(binode);
-               $0->op = Program;
-               $0->left = reorder_bilist($<Vl);
-               $0->right = $<Bl;
-               var_block_close(c, CloseSequential);
-               if (c->scope_stack && !c->parse_error) abort();
-               }$
-
-       Varlist -> Varlist ArgDecl ${
-                       $0 = new(binode);
-                       $0->op = Program;
-                       $0->left = $<1;
-                       $0->right = $<2;
-               }$
-               | ${ $0 = NULL; }$
-
-       $*var
-       ArgDecl -> IDENTIFIER ${ {
-               struct variable *v = var_decl(c, $1.txt);
-               $0 = new(var);
-               $0->var = v;
-       } }$
-
-       ## Grammar
-
 ###### print binode cases
-       case Program:
-               do_indent(indent, "program");
+       case Func:
+       case List:
+               do_indent(indent, "func main(");
                for (b2 = cast(binode, b->left); b2; b2 = cast(binode, b2->right)) {
+                       struct variable *v = cast(var, b2->left)->var;
                        printf(" ");
                        print_exec(b2->left, 0, 0);
+                       printf(":");
+                       type_print(v->type, stdout);
                }
                if (bracket)
-                       printf(" {\n");
+                       printf(") {\n");
                else
-                       printf(":\n");
+                       printf(")\n");
                print_exec(b->right, indent+1, bracket);
                if (bracket)
                        do_indent(indent, "}\n");
                break;
 
 ###### propagate binode cases
-       case Program: abort();          // NOTEST
+       case List:
+       case Func: abort();             // NOTEST
 
 ###### core functions
 
        static int analyse_prog(struct exec *prog, struct parse_context *c)
        {
-               struct binode *b = cast(binode, prog);
+               struct binode *bp = cast(binode, prog);
+               struct binode *b;
                int ok = 1;
+               int arg = 0;
+               struct type *argv_type;
+               struct text argv_type_name = { " argv", 5 };
 
-               if (!b)
+               if (!bp)
                        return 0;       // NOTEST
-               do {
-                       ok = 1;
-                       propagate_types(b->right, c, &ok, Tnone, 0);
-               } while (ok == 2);
-               if (!ok)
-                       return 0;
 
-               for (b = cast(binode, b->left); b; b = cast(binode, b->right)) {
-                       struct var *v = cast(var, b->left);
-                       if (!v->var->type) {
-                               v->var->where_set = b;
-                               v->var->type = Tstr;
-                               v->var->val = NULL;
+               argv_type = add_type(c, argv_type_name, &array_prototype);
+               argv_type->array.member = Tstr;
+               argv_type->array.unspec = 1;
+
+               for (b = cast(binode, bp->left); b; b = cast(binode, b->right)) {
+                       ok = 1;
+                       switch (arg++) {
+                       case 0: /* argv */
+                               propagate_types(b->left, c, &ok, argv_type, 0);
+                               break;
+                       default: /* invalid */  // NOTEST
+                               propagate_types(b->left, c, &ok, Tnone, 0);     // NOTEST
                        }
                }
-               b = cast(binode, prog);
+
                do {
                        ok = 1;
-                       propagate_types(b->right, c, &ok, Tnone, 0);
+                       propagate_types(bp->right, c, &ok, Tnone, 0);
                } while (ok == 2);
                if (!ok)
                        return 0;
 
                /* Make sure everything is still consistent */
-               propagate_types(b->right, c, &ok, Tnone, 0);
-               return !!ok;
+               propagate_types(bp->right, c, &ok, Tnone, 0);
+               if (!ok)
+                       return 0;
+               scope_finalize(c);
+               return 1;
        }
 
-       static void interp_prog(struct exec *prog, char **argv)
+       static void interp_prog(struct parse_context *c, struct exec *prog, 
+                               int argc, char **argv)
        {
                struct binode *p = cast(binode, prog);
                struct binode *al;
+               int anum = 0;
                struct value v;
                struct type *vtype;
 
@@ -4181,31 +4437,40 @@ analysis is a bit more interesting at this level.
                al = cast(binode, p->left);
                while (al) {
                        struct var *v = cast(var, al->left);
-                       struct value *vl = v->var->val;
-
-                       if (argv[0] == NULL) {
-                               printf("Not enough args\n");
-                               exit(1);
+                       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;
+                               mpq_init(argcq);
+                               mpq_set_ui(argcq, argc, 1);
+                               memcpy(var_value(c, t->array.vsize), &argcq, sizeof(argcq));
+                               t->prepare_type(c, t, 0);
+                               array_init(v->var->type, vl);
+                               for (i = 0; i < argc; i++) {
+                                       struct value *vl2 = vl->array + i * v->var->type->array.member->size;
+                                       
+
+                                       arg.str.txt = argv[i];
+                                       arg.str.len = strlen(argv[i]);
+                                       free_value(Tstr, vl2);
+                                       dup_value(Tstr, &arg, vl2);
+                               }
+                               break;
                        }
                        al = cast(binode, al->right);
-                       if (vl)
-                               free_value(v->var->type, vl);
-                       if (!vl) {
-                               vl = val_alloc(v->var->type, NULL);
-                               v->var->val = vl;
-                       }
-                       free_value(v->var->type, vl);
-                       vl->str.len = strlen(argv[0]);
-                       vl->str.txt = malloc(vl->str.len);
-                       memcpy(vl->str.txt, argv[0], vl->str.len);
-                       argv++;
                }
-               v = interp_exec(p->right, &vtype);
+               v = interp_exec(c, p->right, &vtype);
                free_value(vtype, &v);
        }
 
 ###### interp binode cases
-       case Program: abort();  // NOTEST
+       case List:
+       case Func: abort();     // NOTEST
 
 ## And now to test it out.
 
@@ -4235,12 +4500,14 @@ things which will likely grow as the languages grows.
                name:string
                alive:Boolean
 
-       program Astr Bstr:
+       func main
+               argv:[argc::]string
+       do
                print "Hello World, what lovely oceans you have!"
                print "Are there", five, "?"
                print pi, pie, "but", cake
 
-               A := $Astr; B := $Bstr
+               A := $argv[1]; B := $argv[2]
 
                /* When a variable is defined in both branches of an 'if',
                 * and used afterwards, the variables are merged.