Turned on constant reductions and tail recurrsion optimizations in mo…

…dules

front/constred.c

@@ -931,24 +931,63 @@ int func_list_constred(func_list * list, int * result)
         {
             func_constred(value, result);
         }
-
         node = node->next;
     }
     return 0;
 }
 
-int never_constred(never * nev)
+int use_constred(use * value, int * result)
+{
+    if (value->decl != NULL &&
+        value->decl->type == MODULE_DECL_TYPE_MOD)
+    {
+        module_constred(value->decl, result);
+    }
+
+    return 0;
+}
+
+int use_list_constred(use_list * list, int * result)
 {
-    int result = CONSTRED_SUCC;
+    use_list_node * node = list->tail;
+    while (node != NULL)
+    {
+        use * value = node->value;
+        if (value != NULL)
+        {
+            use_constred(value, result);
+        }
+        node = node->next;
+    }
 
+    return 0;
+}
+
+int never_constred(never * nev, int * result)
+{
+    if (nev->uses)
+    {
+        use_list_constred(nev->uses, result);
+    }
     if (nev->binds)
     {
-        bind_list_constred(nev->binds, &result);
+        bind_list_constred(nev->binds, result);
     }
     if (nev->funcs)
     {
-        func_list_constred(nev->funcs, &result);
+        func_list_constred(nev->funcs, result);
     }
 
-    return result;
+    return 0;
 }
+
+int module_constred(module_decl * value, int * result)
+{
+    if (value->nev != NULL)
+    {
+        never_constred(value->nev, result);
+    }
+
+    return 0;
+}
+

front/constred.h

@@ -48,6 +48,9 @@ int func_constred_ffi(func * value, int * result);
 int func_constred_native(func * value, int * result);
 int func_constred(func * value, int * result);
 int func_list_constred(func_list * list, int * result);
-int never_constred(never * nev);
+int use_constred(use * value, int * result);
+int use_list_constred(use_list * list, int * result);
+int never_constred(never * nev, int * result);
+int module_constred(module_decl * value, int * result);
 
 #endif /* __CONSTRED_H__ */

front/optimize.c

@@ -21,18 +21,21 @@
  */
 #include "optimize.h"
 #include "constred.h"
+#include <stdlib.h>
 
-int never_optimize(never * nev)
+int module_optimize(module_decl * value, int * result)
 {
-    return never_constred(nev);
+    return module_constred(value, result);
 }
 
 int module_decl_optimize(module_decl * module_nev)
 {
-    if (module_nev->nev)
+    int result = CONSTRED_SUCC;
+
+    if (module_nev != NULL)
     {
-        return never_optimize(module_nev->nev);
+        module_optimize(module_nev, &result);
     }
 
-    return 0;
+    return result;
 }

front/optimize.h

@@ -24,7 +24,7 @@
 
 #include "never.h"
 
-int never_optimize(never * nev);
-int module_decl_optimize(module_decl * module_nev);
+int module_optimize(module_decl * value, int * result);
+int module_decl_optimize(module_decl * value);
 
 #endif /* __OPTIMIZE_H__ */

front/tailrec.c

@@ -523,10 +523,42 @@ int func_list_tailrec(unsigned int syn_level, func_list * list)
     return 0;
 }
 
+int use_tailrec(use * value)
+{
+    if (value->decl != NULL &&
+        value->decl->type == MODULE_DECL_TYPE_MOD)
+    {
+        module_decl_tailrec(value->decl);
+    }
+
+    return 0;
+}
+
+int use_list_tailrec(use_list * list)
+{
+    use_list_node * node = list->tail;
+
+    while (node != NULL)
+    {
+        use * value = node->value;
+        if (value != NULL)
+        {
+            use_tailrec(value);
+        }
+        node = node->next;
+    }
+
+    return 0;
+}
+
 int never_tailrec(never * nev)
 {
     unsigned int syn_level = 0;
 
+    if (nev->uses)
+    {
+        use_list_tailrec(nev->uses);
+    }
     if (nev->binds)
     {
         bind_list_tailrec(syn_level, nev->stab, nev->binds, TAILREC_OP_SKIP);

front/tailrec.h

@@ -68,7 +68,8 @@ int func_tailrec_ffi(unsigned int syn_level, func * value);
 int func_tailrec_native(unsigned int syn_level, func * value);
 int func_tailrec(unsigned int syn_level, func * value);
 int func_list_tailrec(unsigned int syn_level, func_list * list);
-
+int use_tailrec(use * value);
+int use_list_tailrec(use_list * list);
 int never_tailrec(never * nev);
 int module_decl_tailrec(module_decl * module_nev);
 

sample/lib/mtail.nev

@@ -0,0 +1,9 @@
+
+module mtail {
+    func spaces(n: int) -> string {
+        func spaces0(s:string, n:int) -> string {
+            (n == 0) ? s : spaces0(s+" ", n-1)
+        }
+        spaces0(" ", n-1)
+    }
+}

sample/sample488.nev

@@ -0,0 +1,9 @@
+
+use mtail
+
+func main() -> int
+{
+    mtail.spaces(200);
+    0
+}
+