Revert "threading testing"

This reverts commit 9ba573af

src/main/java/carpet/script/CarpetExpression.java

@@ -944,18 +944,14 @@ public class CarpetExpression
 
         this.expr.addLazyFunction("set", -1, (c, t, lv) ->
         {
-            CarpetSettings.LOG.error("starting");
             CarpetContext cc = (CarpetContext)c;
             ServerWorld world = cc.s.getWorld();
             if (lv.size() < 2 || lv.size() % 2 == 1)
                 throw new InternalExpressionException("'set' should have at least 2 params and odd attributes");
             BlockValue.LocatorResult targetLocator = BlockValue.fromParams(cc, lv, 0);
             BlockValue.LocatorResult sourceLocator = BlockValue.fromParams(cc, lv, targetLocator.offset, true);
-            CarpetSettings.LOG.error("dafuq");
             BlockState sourceBlockState = sourceLocator.block.getBlockState();
-            CarpetSettings.LOG.error("finish dafuq");
             BlockState targetBlockState = world.getBlockState(targetLocator.block.getPos());
-            CarpetSettings.LOG.error("finish dafuq 2");
             if (sourceLocator.offset < lv.size())
             {
                 StateFactory<Block, BlockState> states = sourceBlockState.getBlock().getStateFactory();
@@ -969,7 +965,6 @@ public class CarpetExpression
                     sourceBlockState = setProperty(property, paramString, paramValue, sourceBlockState);
                 }
             }
-            CarpetSettings.LOG.error("finish properties got");
 
             CompoundTag data = sourceLocator.block.getData();
 

src/main/java/carpet/script/value/ThreadValue.java

@@ -1,6 +1,5 @@
 package carpet.script.value;
 
-import carpet.CarpetSettings;
 import carpet.script.Context;
 import carpet.script.Expression;
 import carpet.script.Tokenizer;
@@ -10,7 +9,6 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadPoolExecutor;
@@ -19,13 +17,9 @@ import java.util.function.Supplier;
 public class ThreadValue extends Value
 {
     private CompletableFuture<Value> taskFuture;
-    //public static ThreadLocal<Boolean> joining = ThreadLocal.withInitial(() -> false);
-    public final static Map<Thread,Integer> waitingTreads = new ConcurrentHashMap<>();
-    public static Map<Thread,Integer> joinRequestedThreads = new ConcurrentHashMap<>();
     private long id;
     private final Object lock;
-    //private final boolean[] started;
-    private Thread executingThread;
+    private final boolean[] started;
     private Supplier<Value>task;
     private static long sequence = 0L;
 
@@ -35,20 +29,18 @@ public class ThreadValue extends Value
     {
         id = sequence++;
         lock = new Object();
-        executingThread = null;
-        //started = new boolean[]{false};
+        started = new boolean[]{false};
         task = () ->
         {
-            if (executingThread == null)
+            if (!started[0])
             {
-                CarpetSettings.LOG.error("Setting the thread");
-                executingThread = Thread.currentThread();
+                started[0] = true;
                 return function.lazyEval(ctx, Context.NONE, expr, token, Collections.emptyList()).evalValue(ctx);
             }
             return null;
         };
         taskFuture = CompletableFuture.supplyAsync(
-                () -> { synchronized (lock) {  CarpetSettings.LOG.error("getting in future"); Value ret = task.get();  CarpetSettings.LOG.error("gotten in future"); return ret;} },
+                () -> { synchronized (lock) { return task.get(); } },
                 executorServices.computeIfAbsent(pool, (v) -> (ThreadPoolExecutor)Executors.newCachedThreadPool())
         );
         Thread.yield();
@@ -68,45 +60,26 @@ public class ThreadValue extends Value
 
     public Value join()
     {
-        CarpetSettings.LOG.error("in join "+id);
-        if (executingThread == null)
+        if (!started[0])
         {
-            CarpetSettings.LOG.error("not started "+id);
-            Value res;
-            waitingTreads.put(Thread.currentThread(), 1);
-            try
+            synchronized (lock)
             {
-                CarpetSettings.LOG.error(" getting result "+id);
-                res = task.get();
-                CarpetSettings.LOG.error(" result got "+id);
+                if (!started[0])
+                {
+                    Value res = task.get();
+                    taskFuture.complete(res);
+                    return res;
+                }
             }
-            finally
-            {
-                waitingTreads.remove(Thread.currentThread());
-            }
-            taskFuture.complete(res);
-            return res;
         }
         try
         {
-            synchronized (waitingTreads)
-            {
-                if (waitingTreads.containsKey(executingThread))
-                    throw new InternalExpressionException("Cannot wait/join on world accessing thread");
-                waitingTreads.put(executingThread, 1);
-            }
-            CarpetSettings.LOG.error("getting future "+id);
             return taskFuture.get();
         }
         catch (InterruptedException | ExecutionException e)
         {
             return Value.NULL;
         }
-        finally
-        {
-            waitingTreads.remove(executingThread);
-            CarpetSettings.LOG.error(" future gotten "+id);
-        }
     }
 
     public boolean isFinished()
@@ -120,7 +93,7 @@ public class ThreadValue extends Value
         {
             if (!taskFuture.isDone())
             {
-                executingThread = Thread.currentThread();
+                started[0] = true;
                 taskFuture.complete(Value.NULL);
             }
         }