meow

src/Examples.java

@@ -1,5 +1,8 @@
 import generator.future.Future;
-import generator.gen.Gen;
+import generator.future.Waker;
+
+import java.util.Timer;
+import java.util.TimerTask;
 
 public class Examples {
     //    public static Gen<String, Void> parse(String str){
@@ -66,22 +69,35 @@ public class Examples {
 //        return Gen.ret();
 //    }
 
-//    public static Future<String> awaitTest2(int number){
+    public static class Delay implements Future<String>{
-//        for(int i = 0; i < number; i ++)Future.yield();
-//        return Future.ret(number+"");
-//    }
 
-    public static Future<String> awaitTest(int number){
+        private final int delay;
-        int i = 0;
+        private boolean ready;
-//        Future.yield();
+        public Delay(int ms){
-//        i = 1;
+            delay = ms;
-//        Future.yield();
+        }
-//        i += i*12;
+        @Override
-//        Future.yield();
+        public Object poll(Waker waker) {
-//        return Future.ret(awaitTest2(number).await());
+            new Timer().schedule(new TimerTask() {
-        for(; i < number; i++)
+                @Override
-            Future.yield();
+                public void run() {
-        return Future.ret("meow"+i);
+                    ready = true;
+                    waker.wake();
+                }
+            }, delay);
+            if(ready)return null;
+            return Pending.INSTANCE;
+        }
+    }
+
+    public static Future<String> awaitTest2(int number){
+        ((Future<?>)new Delay(number)).await();
+        return Future.ret(number+"ms");
+    }
+
+    public Future<String> awaitTest(int number){
+        var result = awaitTest2(number).await();
+        return Future.ret("Result: " + result);
     }
 
 //    public static Gen<Double, Void> test(double[] nyas){

src/Main.java

@@ -1,5 +1,6 @@
 import generator.RT;
 import generator.future.Future;
+import generator.future.Waker;
 import generator.gen.Gen;
 
 import java.util.function.Supplier;
@@ -32,24 +33,40 @@ public class Main implements Runnable {
 //        }
 //    }
 
-    void await(){
+    Object simple_async_rt(Future<?> fut){
-        var gen = Examples.awaitTest(10);
+        final var waker = new Waker(){
+            @Override
+            public void wake() {
+                synchronized (this){
+                    this.notifyAll();
+                }
+            }
+        };
         while(true) {
-            var next = (Object)gen.poll(() -> {});
+            var next = fut.poll(waker);
             if(!(next instanceof Future.Pending)){
-                System.out.println(next);
+                return next;
-                break;
             }
             System.out.println("Pending");
+            synchronized (waker){
+                try {
+                    waker.wait();
+                } catch (InterruptedException ignore) {}
+            }
+            System.out.println("Woke");
         }
     }
 
+    void await(){
+        System.out.println(simple_async_rt(new Examples().awaitTest(2000)));
+    }
 
-//    void lexer(){
+
-//        var gen = Lexer.parse("f7(x,y,z,w, u,v, othersIg) = v-(x*y+y+ln(z)^2*sin(z*pi/2))/(w*u)+sqrt(othersIg*120e-1)");
+    void lexer(){
-////        var gen = Examples.test(new double[]{1,2,3,4});
+        var gen = Lexer.parse("f7(x,y,z,w, u,v, othersIg) = v-(x*y+y+ln(z)^2*sin(z*pi/2))/(w*u)+sqrt(othersIg*120e-1)");
-//        while(gen.next() instanceof Gen.Yield(var tok)) {
+//        var gen = Examples.test(new double[]{1,2,3,4});
-//            System.out.println(tok);
+        while(gen.next() instanceof Gen.Yield(var tok)) {
-//        }
+            System.out.println(tok);
-//    }
+        }
+    }
 }

src/generator/future/Future.java

@@ -2,9 +2,8 @@ package generator.future;
 
 public interface Future<R> {
 
-    @SuppressWarnings("unchecked")
+    default Object poll(Waker waker){
-    default R poll(Waker waker){
+        return Pending.INSTANCE;
-        return (R)Pending.INSTANCE;
     }
 
     default R await(){

src/generator/runtime/GeneratorClassLoader.java

@@ -102,7 +102,13 @@ public class GeneratorClassLoader extends ClassLoader {
     private StateMachineBuilder futureMethod(ClassBuilder cb, MethodModel src_mem, ClassModel src_clm) {
         var com = src_mem.code().get();
         var smb = new FutureSMBuilder(src_clm, src_mem, com);
-        add(smb.CD_this.displayName(), smb.buildStateMachine());
+        try{
+            add(smb.CD_this.displayName(), smb.buildStateMachine());
+        }catch (Exception ignore){
+            cb.withMethod(src_mem.methodName(), src_mem.methodType(), src_mem.flags().flagsMask(), mb -> {
+                mb.with(com);
+            });
+        }
         cb.withMethod(src_mem.methodName(), src_mem.methodType(), src_mem.flags().flagsMask(), mb -> {
             mb.withCode(smb::buildSourceMethodShim);
         });

src/generator/runtime/LocalTracker.java

@@ -19,10 +19,13 @@ public class LocalTracker {
     HashMap<Label, StackMapFrameInfo> stackMapFrames = new HashMap<>();
     StackMapFrameInfo currentFrame;
     ArrayList<LocalStore> localStore = new ArrayList<>();
+    final int local_param_off;
 
 
-    LocalTracker(StateMachineBuilder smb, CodeModel com) {
+    LocalTracker(StateMachineBuilder smb, CodeModel com, int local_param_off) {
+        this.local_param_off = local_param_off;
         int offset = 0;
+
         for (var param : smb.params) {
             parameter_map.put(offset, param);
             offset += TypeKind.from(param).slotSize();
@@ -32,8 +35,9 @@ public class LocalTracker {
             var entries = new ArrayList<StackMapFrameInfo>();
             for (var smfi : attr.entries()) {
                 var locals = new ArrayList<>(smfi.locals());
-                for (int i = 0; i < smb.params.length; i++) locals.removeFirst();
+                for (int i = 0; i < smb.params.length; i++)
-                locals.addFirst(StackMapFrameInfo.ObjectVerificationTypeInfo.of(smb.CD_this));
+                    locals.removeFirst();
+//                locals.addFirst(StackMapFrameInfo.ObjectVerificationTypeInfo.of(smb.CD_this));
                 entries.add(StackMapFrameInfo.of(smfi.target(), locals, smfi.stack()));
                 stackMapFrames.put(smfi.target(), entries.getLast());
             }
@@ -60,8 +64,8 @@ public class LocalTracker {
                 name = StateMachineBuilder.LOCAL_PREFIX + localStore.size();
                 localStore.add(new LocalStore(name, desc));
             }
-            saved.add(new Saved(slot+1, name, desc));
+            saved.add(new Saved(slot, name, desc));
-            cob.aload(0).loadLocal(tk, slot+1).putfield(cd, name, desc);
+            cob.aload(0).loadLocal(tk, slot).putfield(cd, name, desc);
         });
         run.run();
 
@@ -97,8 +101,8 @@ public class LocalTracker {
     }
 
     public void currentLocals(LocalConsumer consumer) {
-        var slot = 0;
+        var slot = local_param_off;
-        if (currentFrame != null && false)
+        if (currentFrame != null) {
             for (var kind : currentFrame.locals()) {
                 switch (kind) {
                     case StackMapFrameInfo.ObjectVerificationTypeInfo o -> {
@@ -129,10 +133,13 @@ public class LocalTracker {
                     case StackMapFrameInfo.UninitializedVerificationTypeInfo _ -> throw new IllegalStateException();
                 }
             }
-//        for (var entry : localVarTypes.entrySet()) {
+        }else{
-//            if (entry.getKey() < slot) continue;
+            for (var entry : localVarTypes.entrySet()) {
-//            ClassDesc cd = entry.getValue().upperBound();
+                if (entry.getKey() < slot) continue;
-//            consumer.consume(entry.getKey(), TypeKind.from(cd), cd);
+                ClassDesc cd = entry.getValue().upperBound();
-//        }
+                consumer.consume(entry.getKey(), TypeKind.from(cd), cd);
+            }
+        }
+
     }
 }

src/generator/runtime/StateMachineBuilder.java

@@ -30,7 +30,7 @@ public abstract class StateMachineBuilder {
     public final MethodModel src_mem;
     public final CodeModel src_com;
 
-    public final LocalTracker lt;
+    public LocalTracker lt;
 
     protected HashMap<SpecialMethod, BiFunction<StateMachineBuilder, CodeBuilder, SpecialMethodHandler>> smmap = new HashMap<>();
 
@@ -64,8 +64,6 @@ public abstract class StateMachineBuilder {
         this.params = mts.parameterArray();
         this.MTD_init = MethodTypeDesc.of(ConstantDescs.CD_void, params);
         this.paramSlotOff = Arrays.stream(params).mapToInt(p -> TypeKind.from(p).slotSize()).sum();
-
-        this.lt = new LocalTracker(this, src_com);
     }
 
     public int add_state(Label label) {
@@ -135,6 +133,8 @@ public abstract class StateMachineBuilder {
     public void buildStateMachineCode(ClassBuilder clb, CodeBuilder cob, int loc_param_off) {
         boolean ignore_next_pop = false;
 
+        this.lt = new LocalTracker(this, src_com, loc_param_off);
+
         var invalidState = cob.newLabel();
         var start_label = cob.newLabel();
         add_state(start_label);
@@ -147,6 +147,8 @@ public abstract class StateMachineBuilder {
                     handlers.add(handler.apply(this, cob));
             }
         }
+//        if(handlers.isEmpty() && stateSwitchCases.isEmpty())
+//            throw new RuntimeException("Not a state machine");
         cob.aload(0).getfield(CD_this, STATE_NAME, TypeKind.INT.upperBound()).lookupswitch(invalidState, stateSwitchCases);
         var start = cob.startLabel();
         var end = cob.newLabel();