fixed array issues, started adding library features for async

src/Main.java

@@ -1,5 +1,6 @@
 import async_runtime.Delay;
 import async_runtime.Jokio;
+import async_runtime.Util;
 import generators.RT;
 import future.Future;
 import gen.Gen;
@@ -19,6 +20,15 @@ public class Main implements Runnable {
             System.out.println("END");
             return Future.ret();
         });
+        async_lambda(() -> {
+            var start = System.currentTimeMillis();
+            while(true){
+                Util.first(Delay.delay(500), Delay.delay(1000)).await();
+                var end = System.currentTimeMillis();
+                System.out.println(end-start);
+                start = end;
+            }
+        });
         lexer();
         await();
     }

src/async_runtime/Util.java

@@ -0,0 +1,69 @@
+package async_runtime;
+
+import future.Future;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Util {
+
+    @SafeVarargs
+    public static <T, E extends Throwable> Future<T, E> first(Future<T, E>... futures){
+        return waker -> {
+            int i;
+            boolean resolved = false;
+            Object result = Future.Pending.INSTANCE;
+            for(i = 0; i < futures.length; i ++){
+                result = futures[i].poll(waker);
+                resolved = result!=Future.Pending.INSTANCE;
+                if(resolved)break;
+            }
+            if(resolved){
+                for(int j = 0; j < futures.length; j ++)
+                    if(j!=i)
+                        futures[j].cancel();
+            }
+            return result;
+        };
+    }
+
+    public static <T, E extends Throwable> Future<T, E> first(List<Future<T, E>> futures){
+        return waker -> {
+            int i = 0;
+            boolean resolved = false;
+            Object result = Future.Pending.INSTANCE;
+            for(var el : futures){
+                result = el.poll(waker);
+                resolved = result!=Future.Pending.INSTANCE;
+                if(resolved)break;
+                i++;
+            }
+            if(resolved){
+                int j = 0;
+                for(var el : futures){
+                    if(i==j)
+                        el.cancel();
+                    j++;
+                }
+            }
+            return result;
+        };
+    }
+
+    public static <T, E extends Throwable> Future<T[], E> all(Future<T, E>... futures){
+        return waker -> {
+            return Future.Pending.INSTANCE;
+        };
+    }
+
+    public static <T, E extends Throwable> Future<List<T>, E> all(List<Future<T, E>> futures){
+        var resolved = new ArrayList<T>(Collections.nCopies(futures.size(), null));
+        return waker -> {
+            for(int i = 0; i < resolved.size(); i ++){
+
+            }
+            return Future.Pending.INSTANCE;
+        };
+    }
+}

src/async_runtime/net/DatagramSocket.java

@@ -95,6 +95,25 @@ public class DatagramSocket implements AutoCloseable{
         };
     }
 
+    public Future<Integer, IOException> send(ByteBuffer buffer, SocketAddress address){
+        return waker -> {
+            var sent = socket.send(buffer, address);
+            if(sent!=0)return sent;
+            SELECTOR.register(socket, SelectionKey.OP_WRITE, waker);
+            return Future.Pending.INSTANCE;
+        };
+    }
+
+    public Future<SocketAddress, IOException> receive(ByteBuffer buffer){
+        return waker -> {
+            var address = socket.receive(buffer);
+            if(address!=null)return address;
+            SELECTOR.register(socket, SelectionKey.OP_READ, waker);
+            return Future.Pending.INSTANCE;
+        };
+    }
+
+
     public Future<Integer, IOException> read(ByteBuffer buffer){
         return waker -> {
             var read = socket.read(buffer);

src/generators/loadtime/FrameTracker.java

@@ -297,11 +297,12 @@ public class FrameTracker {
             case Instruction ins -> {
                 switch (ins) {
                     case ArrayLoadInstruction al -> {
-                        popStack();
+                        popStack();// array
-                        var arr = popStack();
+                        popStack();//index
+                        var arr = popStack();//type
                         pushStack(arr.toCD().componentType());
                     }
-                    case ArrayStoreInstruction as -> decStack(1 + as.typeKind().slotSize());
+                    case ArrayStoreInstruction as -> decStack(2 + as.typeKind().slotSize());
                     case BranchInstruction b when b.opcode() == Opcode.GOTO || b.opcode() == Opcode.GOTO_W -> {}
                     case BranchInstruction b -> popStack();
                     case ConstantInstruction c when ins.opcode() == Opcode.ACONST_NULL -> pushStack(Type.NULL_TYPE);
@@ -357,10 +358,10 @@ public class FrameTracker {
                             pushStack(locals.get(l.slot()).toCD());
                     case LookupSwitchInstruction ls -> popStack();
                     case MonitorInstruction m -> popStack();
-                    case NewMultiArrayInstruction nma -> decStack(nma.dimensions()).pushStack(nma.arrayType().asSymbol());
+                    case NewMultiArrayInstruction nma -> decStack(nma.dimensions()).pushStack(nma.arrayType().asSymbol().arrayType());
                     case NewObjectInstruction no -> pushStack(no.className().asSymbol());
                     case NewPrimitiveArrayInstruction npa -> decStack(1).pushStack(npa.typeKind().upperBound().arrayType());
-                    case NewReferenceArrayInstruction nra -> decStack(1).pushStack(nra.componentType().asSymbol());
+                    case NewReferenceArrayInstruction nra -> decStack(1).pushStack(nra.componentType().asSymbol().arrayType());
                     case NopInstruction n -> {}
                     
                     case OperatorInstruction o -> {

src/generators/loadtime/StateMachineBuilder.java

@@ -60,7 +60,13 @@ public abstract class StateMachineBuilder {
         }
         var cdn = src_clm.thisClass().asSymbol().displayName();
         var method_name = src_mem.methodName().stringValue();
-        var param_cnd = src_mem.methodTypeSymbol().parameterList().stream().map(desc -> desc.descriptorString().replace("/", "__").replace(";", "__")).collect(Collectors.joining("$"));
+        var param_cnd = src_mem.methodTypeSymbol().parameterList().stream().map(
+                desc -> desc.descriptorString()
+                        .replace("/", "__")
+                        .replace(";", "__")
+                        .replace("[", "_$_$_")
+                )
+                .collect(Collectors.joining("$"));
         innerClassName = method_name + "$$" + param_cnd + "$$";
         var name = cdn + "$" +innerClassName;
 
@@ -71,8 +77,10 @@ public abstract class StateMachineBuilder {
 
         var lt = new FrameTracker(this, src_com);
         for(var coe : src_com){
-            if(coe instanceof Instruction)
+            if(coe instanceof Instruction) {
                 frames.add(new Frame(lt.locals(), lt.stack()));
+                System.out.println(frames.getLast() + " " + coe);
+            }
             lt.encounter(coe);
         }
         frames.add(new Frame(lt.locals(), lt.stack()));