oceani: fix parsing for function declaration parameters

[ocean] / csrc / oceani.mdc

diff --git a/csrc/oceani.mdc b/csrc/oceani.mdc
index c89ecafc6c33890f838890eceb91b815e07575f3..fabfe188c07ebd5bc9abdca9dd492aad34041de2 100644 (file)
--- a/csrc/oceani.mdc
+++ b/csrc/oceani.mdc
@@ -2340,19 +2340,22 @@ has a type which includes the set of parameters and the return value.
 As yet these types cannot be declared separately from the function
 itself.
 
 As yet these types cannot be declared separately from the function
 itself.
 

-The parameters can be specified either in parentheses as a list, such as
+The parameters can be specified either in parentheses as a ';' separated
+list, such as

 
 ##### Example: function 1
 
 
 ##### Example: function 1
 

-       func main(av:[ac::number]string)
+       func main(av:[ac::number]string; env:[envc::number]string)

                code block
 
                code block
 

-or as an indented list of one parameter per line
+or as an indented list of one parameter per line (though each line can
+be a ';' separated list)

 
 ##### Example: function 2
 
        func main
                argv:[argc::number]string
 
 ##### Example: function 2
 
        func main
                argv:[argc::number]string

+               env:[envc::number]string

        do
                code block
 
        do
                code block
 


@@ -2479,12 +2482,21 @@ further detailed when Expression Lists are introduced.
 
 
        $*binode
 
 
        $*binode

-       Args -> ${ $0 = NULL; }$
+       Args -> ArgsLine NEWLINE ${ $0 = $<AL; }$
+               | Args ArgsLine NEWLINE ${ {
+                       struct binode *b = $<AL;
+                       struct binode **bp = &b;
+                       while (*bp)
+                               bp = (struct binode **)&(*bp)->left;
+                       *bp = $<A;
+                       $0 = b;
+               } }$
+
+       ArgsLine -> ${ $0 = NULL; }$

                | Varlist ${ $0 = $<1; }$
                | Varlist ; ${ $0 = $<1; }$
                | Varlist ${ $0 = $<1; }$
                | Varlist ; ${ $0 = $<1; }$

-               | Varlist NEWLINE ${ $0 = $<1; }$

 
 

-       Varlist -> Varlist ; ArgDecl ${ // UNTESTED
+       Varlist -> Varlist ; ArgDecl ${

                        $0 = new(binode);
                        $0->op = List;
                        $0->left = $<Vl;
                        $0 = new(binode);
                        $0->op = List;
                        $0->left = $<Vl;


@@ -4725,10 +4737,10 @@ analysis is a bit more interesting at this level.
 ###### top level grammar
 
        $*variable
 ###### top level grammar
 
        $*variable

-       DeclareFunction -> func FuncName ( OpenScope Args ) Block Newlines ${
+       DeclareFunction -> func FuncName ( OpenScope ArgsLine ) Block Newlines ${

                        $0 = declare_function(c, $<FN, $<Ar, $<Bl);
                }$
                        $0 = declare_function(c, $<FN, $<Ar, $<Bl);
                }$

-               | func FuncName IN OpenScope OptNL Args OUT OptNL do Block Newlines ${
+               | func FuncName IN OpenScope Args OUT OptNL do Block Newlines ${

                        $0 = declare_function(c, $<FN, $<Ar, $<Bl);
                }$
                | func FuncName NEWLINE OpenScope OptNL do Block Newlines ${
                        $0 = declare_function(c, $<FN, $<Ar, $<Bl);
                }$
                | func FuncName NEWLINE OpenScope OptNL do Block Newlines ${


@@ -4770,9 +4782,10 @@ analysis is a bit more interesting at this level.
        static int analyse_funcs(struct parse_context *c)
        {
                struct variable *v;
        static int analyse_funcs(struct parse_context *c)
        {
                struct variable *v;

-               int ok = 1;
-               for (v = c->in_scope; ok && v; v = v->in_scope) {
+               int all_ok = 1;
+               for (v = c->in_scope; v; v = v->in_scope) {

                        struct value *val;
                        struct value *val;

+                       int ok = 1;

                        if (v->depth != 0 || !v->type || !v->type->check_args)
                                continue;
                        val = var_value(c, v);
                        if (v->depth != 0 || !v->type || !v->type->check_args)
                                continue;
                        val = var_value(c, v);


@@ -4783,9 +4796,11 @@ analysis is a bit more interesting at this level.
                        if (ok)
                                /* Make sure everything is still consistent */
                                propagate_types(val->function, c, &ok, Tnone, 0);
                        if (ok)
                                /* Make sure everything is still consistent */
                                propagate_types(val->function, c, &ok, Tnone, 0);

+                       if (!ok)
+                               all_ok = 0;

                        v->type->function.local_size = scope_finalize(c);
                }
                        v->type->function.local_size = scope_finalize(c);
                }

-               return ok;
+               return all_ok;

        }
 
        static int analyse_main(struct type *type, struct parse_context *c)
        }
 
        static int analyse_main(struct type *type, struct parse_context *c)