Testing out a solution to implement functions.

5 files changed, 441 insertions, 60 deletions

diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/AnonymousVariableManager.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/AnonymousVariableManager.java
index 8bec40a..12fde67 100644
--- a/src/core/src/tonkadur/wyrd/v1/compiler/util/AnonymousVariableManager.java
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/AnonymousVariableManager.java
@@ -18,96 +18,130 @@ import tonkadur.wyrd.v1.lang.computation.Constant;
 import tonkadur.wyrd.v1.lang.type.Type;
 
 
-public class AnonymousVariableManager
+public class RegisterManager
 {
    protected static final String name_prefix = ".anon.";
+   protected final Map<String, RegisterContext> context_by_name;
+   protected final Deque<RegisterContext> context;
+   protected final RegisterContext base_context;
 
-   protected final Map<String, Cons<Boolean, Variable>> by_name;
-   protected final Map<Type, List<Cons<Boolean, Variable>>> by_type;
-   protected int generated_variables;
-
-   public AnonymousVariableManager ()
+   public RegisterManager ()
    {
-      by_name = new HashMap<String, Cons<Boolean, Variable>>();
-      by_type = new HashMap<Type, List<Cons<Boolean, Variable>>>();
-      generated_variables = 0;
-   }
+      base_context = new RegisterContext("base context", false);
 
-   public Collection<Variable> get_all_variables ()
-   {
-      final Collection<Variable> result;
+      context_by_name = new HashMap<String, RegisterContext>();
+      context = new ArrayDeque<RegisterContext>();
 
-      result = new ArrayList<Variable>();
-
-      for (final Cons<Boolean, Variable> variable: by_name.values())
-      {
-         result.add(variable.get_cdr());
-      }
-
-      return result;
+      context_by_name.put("base context", base_context);
+      context.push(base_context);
    }
 
    public Ref reserve (final Type t)
    {
-      final String name;
-      final Ref result;
-      final Variable new_variable;
-      final Cons<Boolean, Variable> status;
-      List<Cons<Boolean, Variable>> list;
 
-      list = by_type.get(t);
+   }
+
+   protected static class RegisterContext
+   {
+      protected final String name;
+      protected final boolean is_stackable;
+      protected final Map<String, Register> register_by_name;
+      protected final Map<Type, Register> register_by_type;
+      protected int generated_variables;
 
-      if (list == null)
+      public RegisterContext (final String name, final boolean is_stackable)
       {
-         list = new ArrayList<Cons<Boolean, Variable>>();
+         this.name = name;
+         this.is_stackable = is_stackable;
+
+         register_by_name = new HashMap<String, Register>();
+         register_by_type = new HashMap<Type, Register>();
 
-         by_type.put(t, list);
+         generated_variables = 0;
       }
 
-      for (final Cons<Boolean, Variable> entry: list)
+      public Collection<Variable> get_all_variables ()
       {
-         if (!entry.get_car())
-         {
-            result = entry.get_cdr().get_ref();
+         final Collection<Variable> result;
 
-            entry.set_car(Boolean.TRUE);
+         result = new ArrayList<Variable>();
 
-            return result;
+         for (final Cons<Boolean, Variable> variable: by_name.values())
+         {
+            result.add(variable.get_cdr());
          }
+
+         return result;
       }
 
-      name = (name_prefix + Integer.toString(generated_variables++));
-      new_variable = new Variable(name, "local", t);
-      status = new Cons(Boolean.TRUE, new_variable);
+      public Ref reserve (final Type t)
+      {
+         final String name;
+         final Ref result;
+         final Variable new_variable;
+         final Cons<Boolean, Variable> status;
+         List<Cons<Boolean, Variable>> list;
 
-      list.add(status);
+         list = by_type.get(t);
 
-      by_name.put(name, status);
+         if (list == null)
+         {
+            list = new ArrayList<Cons<Boolean, Variable>>();
 
-      return new_variable.get_ref();
-   }
+            by_type.put(t, list);
+         }
 
-   public void release (final Ref r)
-   {
-      final Computation c;
-      final String name;
+         for (final Cons<Boolean, Variable> entry: list)
+         {
+            if (!entry.get_car())
+            {
+               result = entry.get_cdr().get_ref();
 
-      c = r.get_address();
+               entry.set_car(Boolean.TRUE);
 
-      if (!(c instanceof Constant))
-      {
-         System.err.println
-         (
-            "[P] Anonymous Variable '"
-            + r.toString()
-            + "' is not at constant address."
-         );
-
-         return;
+               return result;
+            }
+         }
+
+         name = (name_prefix + Integer.toString(generated_variables++));
+         new_variable = new Variable(name, "local", t);
+         status = new Cons(Boolean.TRUE, new_variable);
+
+         list.add(status);
+
+         by_name.put(name, status);
+
+         return new_variable.get_ref();
       }
 
-      name = ((Constant) c).get_as_string();
+      public void release (final Ref r)
+      {
+         final Computation c;
+         final String name;
+
+         c = r.get_address();
+
+         if (!(c instanceof Constant))
+         {
+            System.err.println
+            (
+               "[P] Anonymous Variable '"
+               + r.toString()
+               + "' is not at constant address."
+            );
+
+            return;
+         }
+
+         name = ((Constant) c).get_as_string();
 
-      by_name.get(name).set_car(Boolean.FALSE);
+         by_name.get(name).set_car(Boolean.FALSE);
+      }
+
+      protected static class Register
+      {
+         protected boolean is_in_use;
+         protected Variable variable;
+      }
    }
 }
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/FunctionContext.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/FunctionContext.java
new file mode 100644
index 0000000..7b9dbc2
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/FunctionContext.java
@@ -0,0 +1,9 @@
+package tonkadur.wyrd.v1.compiler.util;
+
+public class FunctionContext
+{
+   protected final List<Ref> registers;
+   protected final Map<String, Ref> parameters;
+   protected final Type result_type;
+
+}
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/registers/RegisterContext.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/registers/RegisterContext.java
new file mode 100644
index 0000000..06ca608
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/registers/RegisterContext.java
@@ -0,0 +1,97 @@
+package tonkadur.wyrd.v1.compiler.util;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Collection;
+import java.util.List;
+import java.util.ArrayList;
+
+import tonkadur.functional.Cons;
+
+import tonkadur.wyrd.v1.lang.Variable;
+
+import tonkadur.wyrd.v1.lang.meta.Computation;
+
+import tonkadur.wyrd.v1.lang.computation.Ref;
+import tonkadur.wyrd.v1.lang.computation.Constant;
+
+import tonkadur.wyrd.v1.lang.type.Type;
+
+
+public class RegisterManager
+{
+   protected static final String name_prefix = ".anon.";
+   protected final String name;
+   protected final Map<String, Register> register_by_name;
+   protected final Map<Type, Register> register_by_type;
+   protected int generated_variables;
+
+   public RegisterContext (final String name)
+   {
+      this.name = name;
+
+      register_by_name = new HashMap<String, Register>();
+      register_by_type = new HashMap<Type, Register>();
+
+      generated_variables = 0;
+   }
+
+   public Collection<Variable> get_all_variables ()
+   {
+      final Collection<Variable> result;
+
+      result = new ArrayList<Variable>();
+
+      for (final Cons<Boolean, Variable> variable: by_name.values())
+      {
+         result.add(variable.get_cdr());
+      }
+
+      return result;
+   }
+
+   public Register reserve (final Type t)
+   {
+      final String name;
+      final Register result;
+      final Variable new_variable;
+      final Cons<Boolean, Variable> status;
+      List<Cons<Boolean, Variable>> list;
+
+      list = by_type.get(t);
+
+      if (list == null)
+      {
+         list = new ArrayList<Cons<Boolean, Variable>>();
+
+         by_type.put(t, list);
+      }
+
+      for (final Cons<Boolean, Variable> entry: list)
+      {
+         if (!entry.get_car())
+         {
+            result = entry.get_cdr().get_ref();
+
+            entry.set_car(Boolean.TRUE);
+
+            return result;
+         }
+      }
+
+      name = (name_prefix + Integer.toString(generated_variables++));
+      new_variable = new Variable(name, "local", t);
+      status = new Cons(Boolean.TRUE, new_variable);
+
+      list.add(status);
+
+      by_name.put(name, status);
+
+      return new_variable.get_ref();
+   }
+
+   public void release (final Register r)
+   {
+      r.set_is_in_use(false);
+   }
+}
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/registers/RegisterManager.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/registers/RegisterManager.java
new file mode 100644
index 0000000..1519f01
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/registers/RegisterManager.java
@@ -0,0 +1,94 @@
+package tonkadur.wyrd.v1.compiler.util;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Collection;
+import java.util.List;
+import java.util.ArrayList;
+
+import tonkadur.functional.Cons;
+
+import tonkadur.wyrd.v1.lang.Variable;
+
+import tonkadur.wyrd.v1.lang.meta.Computation;
+
+import tonkadur.wyrd.v1.lang.computation.Ref;
+import tonkadur.wyrd.v1.lang.computation.Constant;
+
+import tonkadur.wyrd.v1.lang.type.Type;
+
+
+public class RegisterManager
+{
+   protected final Map<String, RegisterContext> context_by_name;
+   protected final Deque<RegisterContext> context;
+   protected final RegisterContext base_context;
+
+   public RegisterManager ()
+   {
+      base_context = new RegisterContext("base context", false);
+
+      context_by_name = new HashMap<String, RegisterContext>();
+      context = new ArrayDeque<RegisterContext>();
+
+      context_by_name.put("base context", base_context);
+      context.push(base_context);
+   }
+
+   public Register reserve (final Type t)
+   {
+      context.peekFirst().reserve(t);
+   }
+
+   public void release (final Register r)
+   {
+      context.peekFirst().release(r);
+   }
+
+   public void create_stackable_context (final String context_name)
+   {
+      final StackableRegisterContext result;
+
+      result = StackableRegisterContext.generate(base_context, context_name);
+
+      context_by_name.put(result);
+   }
+
+   public void add_context_variable (final Type t, final String variable_name)
+   {
+      context.peekFirst().reserve(t, name);
+   }
+
+   public Register get_context_variable (final String variable_name)
+   {
+      context.peekFirst().get_variable(name);
+   }
+
+   public List<Instruction> get_enter_context_instructions
+   (
+      final String context_name
+   )
+   {
+      return context_by_name.get(context_name).get_enter_instructions();
+   }
+
+   public List<Instruction> get_leave_context_instructions
+   (
+      final String context_name
+   )
+   {
+      return context_by_name.get(context_name).get_leave_instructions();
+   }
+
+   public Collection<Type> get_generated_types ()
+   {
+      /* TODO */
+      return null;
+   }
+
+   public Collection<Variable> get_generated_variables ()
+   {
+      /* TODO */
+      return null;
+   }
+}
diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/registers/StackableRegisterContext.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/registers/StackableRegisterContext.java
new file mode 100644
index 0000000..12fde67
--- /dev/null
+++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/registers/StackableRegisterContext.java
@@ -0,0 +1,147 @@
+package tonkadur.wyrd.v1.compiler.util;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Collection;
+import java.util.List;
+import java.util.ArrayList;
+
+import tonkadur.functional.Cons;
+
+import tonkadur.wyrd.v1.lang.Variable;
+
+import tonkadur.wyrd.v1.lang.meta.Computation;
+
+import tonkadur.wyrd.v1.lang.computation.Ref;
+import tonkadur.wyrd.v1.lang.computation.Constant;
+
+import tonkadur.wyrd.v1.lang.type.Type;
+
+
+public class RegisterManager
+{
+   protected static final String name_prefix = ".anon.";
+   protected final Map<String, RegisterContext> context_by_name;
+   protected final Deque<RegisterContext> context;
+   protected final RegisterContext base_context;
+
+   public RegisterManager ()
+   {
+      base_context = new RegisterContext("base context", false);
+
+      context_by_name = new HashMap<String, RegisterContext>();
+      context = new ArrayDeque<RegisterContext>();
+
+      context_by_name.put("base context", base_context);
+      context.push(base_context);
+   }
+
+   public Ref reserve (final Type t)
+   {
+
+   }
+
+   protected static class RegisterContext
+   {
+      protected final String name;
+      protected final boolean is_stackable;
+      protected final Map<String, Register> register_by_name;
+      protected final Map<Type, Register> register_by_type;
+      protected int generated_variables;
+
+      public RegisterContext (final String name, final boolean is_stackable)
+      {
+         this.name = name;
+         this.is_stackable = is_stackable;
+
+         register_by_name = new HashMap<String, Register>();
+         register_by_type = new HashMap<Type, Register>();
+
+         generated_variables = 0;
+      }
+
+      public Collection<Variable> get_all_variables ()
+      {
+         final Collection<Variable> result;
+
+         result = new ArrayList<Variable>();
+
+         for (final Cons<Boolean, Variable> variable: by_name.values())
+         {
+            result.add(variable.get_cdr());
+         }
+
+         return result;
+      }
+
+      public Ref reserve (final Type t)
+      {
+         final String name;
+         final Ref result;
+         final Variable new_variable;
+         final Cons<Boolean, Variable> status;
+         List<Cons<Boolean, Variable>> list;
+
+         list = by_type.get(t);
+
+         if (list == null)
+         {
+            list = new ArrayList<Cons<Boolean, Variable>>();
+
+            by_type.put(t, list);
+         }
+
+         for (final Cons<Boolean, Variable> entry: list)
+         {
+            if (!entry.get_car())
+            {
+               result = entry.get_cdr().get_ref();
+
+               entry.set_car(Boolean.TRUE);
+
+               return result;
+            }
+         }
+
+         name = (name_prefix + Integer.toString(generated_variables++));
+         new_variable = new Variable(name, "local", t);
+         status = new Cons(Boolean.TRUE, new_variable);
+
+         list.add(status);
+
+         by_name.put(name, status);
+
+         return new_variable.get_ref();
+      }
+
+      public void release (final Ref r)
+      {
+         final Computation c;
+         final String name;
+
+         c = r.get_address();
+
+         if (!(c instanceof Constant))
+         {
+            System.err.println
+            (
+               "[P] Anonymous Variable '"
+               + r.toString()
+               + "' is not at constant address."
+            );
+
+            return;
+         }
+
+         name = ((Constant) c).get_as_string();
+
+         by_name.get(name).set_car(Boolean.FALSE);
+      }
+
+      protected static class Register
+      {
+         protected boolean is_in_use;
+         protected Variable variable;
+      }
+   }
+}