Test changes required for stack change

Author: ngallagher

snap-core/src/test/java/org/snapscript/core/stack/CompoundStatement2.java

@@ -0,0 +1,68 @@
+package org.snapscript.core.stack;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.snapscript.core.InternalStateException;
+import org.snapscript.core.Result;
+import org.snapscript.core.ResultType;
+import org.snapscript.core.Scope;
+import org.snapscript.core.Statement;
+
+public class CompoundStatement2  {
+   
+   private final Statement[] statements;
+   private final AtomicBoolean compile;
+   private final AtomicInteger depth;
+   
+   public CompoundStatement2(Statement... statements) {
+      this.compile = new AtomicBoolean();
+      this.depth = new AtomicInteger();
+      this.statements = statements;
+   }
+   
+   public Result compile(Scope scope) throws Exception {
+      Result last = ResultType.getNormal();
+      
+      if(compile.get()) {
+         throw new InternalStateException("Statement was already compiled");
+      }
+      try {
+         for(Statement statement : statements) {
+            Result result = statement.compile(scope);
+            
+            if(result.isDeclare()){
+               depth.getAndIncrement();
+            }
+         }
+      } finally {
+         compile.set(true);
+      }
+      return last;
+   }
+   
+   public Result execute(Scope2 scope) throws Exception {
+      Result last = ResultType.getNormal();
+      State2 state2 = scope.getStack();
+      State2 next = state2.create(); // allow the stack to grow in a compound statement!!
+      
+      if(!compile.get()) {
+         throw new InternalStateException("Statement was not compiled");
+      }
+      try {
+         for(Statement statement : statements) {
+            Result result = statement.execute(null); // execute(scope); NOT NEED FOR CHANGE
+            
+            if(!result.isNormal()){
+               return result;
+            }
+            last = result;
+         }
+      }finally {
+         next.clear();
+      }
+      return last;
+   }
+   
+   
+}

snap-core/src/test/java/org/snapscript/core/stack/FunctionPointer2.java

@@ -0,0 +1,40 @@
+package org.snapscript.core.stack;
+
+import org.snapscript.core.Result;
+import org.snapscript.core.Scope;
+import org.snapscript.core.error.ThreadStack;
+import org.snapscript.core.function.ArgumentConverter;
+import org.snapscript.core.function.Function;
+import org.snapscript.core.function.Invocation;
+import org.snapscript.core.function.Signature;
+
+public class FunctionPointer2 {
+   
+   private final ThreadStack stack;
+   private final Function function;
+   private final Object[] arguments;
+   
+   public FunctionPointer2(Function function, ThreadStack stack, Object[] arguments) {
+      this.arguments = arguments;
+      this.function = function;
+      this.stack = stack;
+   }
+   
+   public Result call(Scope2 scope, Object object) throws Exception{
+      Signature signature = function.getSignature();
+      ArgumentConverter converter = signature.getConverter();
+      Object[] list = converter.convert(arguments);
+      Invocation invocation = function.getInvocation();
+      State2 state = scope.getStack();
+      State2 next = state.create(); /// allow stack to grow after invocation!!
+      
+      try {
+         stack.before(function);
+         //return invocation.invoke(scope, object, list);
+         return null;
+      } finally {
+         stack.after(function);
+         next.clear(); /// clear the stack that was built up!!!
+      }
+   }
+}

snap-core/src/test/java/org/snapscript/core/stack/StatementInvocation2.java

@@ -0,0 +1,73 @@
+package org.snapscript.core.stack;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.snapscript.core.Context;
+import org.snapscript.core.Module;
+import org.snapscript.core.Result;
+import org.snapscript.core.ResultType;
+import org.snapscript.core.Statement;
+import org.snapscript.core.Type;
+import org.snapscript.core.convert.ConstraintConverter;
+import org.snapscript.core.convert.ConstraintMatcher;
+import org.snapscript.core.function.Signature;
+import org.snapscript.core.function.SignatureAligner;
+
+public class StatementInvocation2  {
+
+   //private final ParameterExtractor extractor;
+   private final SignatureAligner aligner;
+   private final AtomicBoolean compile;
+   private final Statement statement;
+   private final Type constraint;
+   
+   public StatementInvocation2(Signature signature, Statement statement, Type constraint) {
+      //this.extractor = new ParameterExtractor(signature);
+      this.aligner = new SignatureAligner(signature);
+      this.compile = new AtomicBoolean();
+      this.constraint = constraint;
+      this.statement = statement;
+   }
+   
+   public Result invoke(Scope2 scope, Object object, Object... list) throws Exception {
+      //
+      // THIS IS THE LIST OF ARGUMENTS... DO NOT NEED TO BE TAKEN FROM
+      // PREVIIOUS SCOPE!!!!!
+      //
+      //
+      Object[] arguments = aligner.align(list); 
+      Module module = scope.getModule();
+      Context context = module.getContext();
+      State2 previous = scope.getStack(); 
+      State2 next = previous.create();
+      
+      try {
+         if(arguments.length > 0) {
+            //extractor.extract(previous, next, arguments); // maybe this returns scope.getStack().create()
+            //
+            // State2 next = extractor.extract(previous, arguments);
+            //
+            
+         }
+         if(compile.compareAndSet(false, true)) {
+            // scope = scope.getObject()
+            // 
+            //statement.compile(scope);
+         } 
+         ConstraintMatcher matcher = context.getMatcher();
+         ConstraintConverter converter = matcher.match(constraint);
+         //
+         // scope = scope.getObject();
+         //Result result = statement.execute(scope);
+   //      Object value = result.getValue();
+   //      
+   //      if(value != null) {
+   //         value = converter.convert(value);
+   //      }
+   //      return ResultType.getNormal(value); 
+      return null;
+      } finally {
+         next.clear();
+      }
+   }
+}

snap-core/src/test/java/org/snapscript/core/stack/TraceStatement2.java

@@ -25,6 +25,12 @@ public Result compile(Scope2 scope) throws Exception {
    }
 
    public Result execute(Scope2 scope) throws Exception {
+      //
+      // MAYBE NOT HERE AS THE INVOCATION NEEDS TO GRAB THE PARAMETERS
+      // FROM THE PREVIOUS STACK/STATE, once you pass the parameters
+      // from the previous stack on to the new stack then you can
+      // grow the stack
+      //
       State2 stack = scope.getStack();
       State2 outer = stack.create(); // allow the stack to grow!!