diff --git a/README.md b/README.md index fc3e1c51..d1f42e01 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,8 @@ Note that certain things like reflection and dynamic class definition downgradin downgrading. dynamic class definitions being things like `MethodHandles$Lookup#defineClass` and classloader shenanigans. -add my maven in `settings.gradle`: +~~add my maven in `settings.gradle`:~~ +JvmDowngrader is now on the gradle plugin portal, so you can skip this step, unless you want to use a snapshot version. ```gradle pluginManagement { diff --git a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/HttpClientBuilderImpl.java b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/HttpClientBuilderImpl.java similarity index 98% rename from java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/HttpClientBuilderImpl.java rename to java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/HttpClientBuilderImpl.java index f02e6ee5..4fab91f9 100644 --- a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/HttpClientBuilderImpl.java +++ b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/HttpClientBuilderImpl.java @@ -1,4 +1,4 @@ -package xyz.wagyourtail.jvmdg.j11.impl; +package xyz.wagyourtail.jvmdg.j11.impl.http; import xyz.wagyourtail.jvmdg.j11.stub.java_net_http.J_N_H_HttpClient; diff --git a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/HttpClientImpl.java b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/HttpClientImpl.java similarity index 70% rename from java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/HttpClientImpl.java rename to java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/HttpClientImpl.java index c9d0a281..bb836ca5 100644 --- a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/HttpClientImpl.java +++ b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/HttpClientImpl.java @@ -1,14 +1,19 @@ -package xyz.wagyourtail.jvmdg.j11.impl; +package xyz.wagyourtail.jvmdg.j11.impl.http; +import jdk.incubator.http.HttpRequest; +import xyz.wagyourtail.jvmdg.exc.MissingStubError; import xyz.wagyourtail.jvmdg.j11.stub.java_net_http.J_N_H_HttpClient; +import xyz.wagyourtail.jvmdg.j11.stub.java_net_http.J_N_H_HttpResponse; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLParameters; +import java.io.IOException; import java.net.Authenticator; import java.net.CookieHandler; import java.net.ProxySelector; import java.time.Duration; import java.util.Optional; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; @@ -83,6 +88,19 @@ public Optional executor() { return Optional.ofNullable(executor); } - //TODO + @Override + public J_N_H_HttpResponse send(HttpRequest var1, J_N_H_HttpResponse.BodyHandler handler) throws IOException, InterruptedException { + throw MissingStubError.create(); + } + + @Override + public CompletableFuture> sendAsync(HttpRequest var1, J_N_H_HttpResponse.BodyHandler handler) { + throw MissingStubError.create(); + } + + @Override + public CompletableFuture> sendAsync(HttpRequest var1, J_N_H_HttpResponse.BodyHandler handler, J_N_H_HttpResponse.PushPromiseHandler pushPromiseHandler) { + throw MissingStubError.create(); + } } diff --git a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/IterablePublisher.java b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/IterablePublisher.java new file mode 100644 index 00000000..afc5cde2 --- /dev/null +++ b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/IterablePublisher.java @@ -0,0 +1,78 @@ +package xyz.wagyourtail.jvmdg.j11.impl.http; + +import java.util.Iterator; +import java.util.concurrent.Flow; + +public class IterablePublisher implements Flow.Publisher { + private final Iterable iterable; + private final Throwable throwable; + + public IterablePublisher(Iterable iterable, Throwable throwable) { + this.iterable = iterable; + this.throwable = throwable; + } + + public IterablePublisher(Iterable iterable) { + this(iterable, null); + } + + @Override + public void subscribe(Flow.Subscriber subscriber) { + subscriber.onSubscribe(new Subscription(subscriber)); + } + + private class Subscription implements Flow.Subscription { + private final Flow.Subscriber subscriber; + private final Iterator iterator; + private volatile boolean completed; + private volatile boolean cancelled; + private volatile Throwable error; + + public Subscription(Flow.Subscriber subscriber) { + this.subscriber = subscriber; + this.iterator = iterable.iterator(); + this.error = throwable; + } + + @Override + public void request(long n) { + if (n <= 0) { + subscriber.onError(new IllegalArgumentException("n <= 0")); + return; + } + if (completed || cancelled) { + return; + } + if (error != null) { + completed = true; + subscriber.onError(error); + return; + } + try { + synchronized (this) { + for (long i = 0; i < n; i++) { + if (cancelled) { + break; + } + if (iterator.hasNext()) { + subscriber.onNext(iterator.next()); + } else { + completed = true; + subscriber.onComplete(); + break; + } + } + } + } catch (Throwable t) { + error = t; + subscriber.onError(t); + completed = true; + } + } + + @Override + public void cancel() { + cancelled = true; + } + } +} diff --git a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/StreamIterator.java b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/StreamIterator.java new file mode 100644 index 00000000..d2585502 --- /dev/null +++ b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/impl/http/StreamIterator.java @@ -0,0 +1,95 @@ +package xyz.wagyourtail.jvmdg.j11.impl.http; + +import java.io.IOException; +import java.io.InputStream; +import java.io.UncheckedIOException; +import java.nio.ByteBuffer; +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.function.Supplier; + +public class StreamIterator implements Iterator { + public static final int BUFSIZE = Integer.parseInt(System.getProperty("jdk.httpclient.bufsize", "16384")); + + final InputStream is; + final Supplier bufSupplier; + private volatile boolean eof; + volatile ByteBuffer nextBuffer; + volatile boolean need2Read = true; + volatile boolean haveNext; + + public StreamIterator(InputStream is) { + this(is, () -> ByteBuffer.allocate(BUFSIZE)); + } + + StreamIterator(InputStream is, Supplier bufSupplier) { + this.is = is; + this.bufSupplier = bufSupplier; + } + +// Throwable error() { +// return error; +// } + + private int read() throws IOException { + if (eof) + return -1; + nextBuffer = bufSupplier.get(); + nextBuffer.clear(); + byte[] buf = nextBuffer.array(); + int offset = nextBuffer.arrayOffset(); + int cap = nextBuffer.capacity(); + int n = is.read(buf, offset, cap); + if (n == -1) { + eof = true; + return -1; + } + //flip + nextBuffer.limit(n); + nextBuffer.position(0); + return n; + } + + /** + * Close stream in this instance. + * UncheckedIOException may be thrown if IOE happens at InputStream::close. + */ + private void closeStream() { + try { + is.close(); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } + + @Override + public synchronized boolean hasNext() { + if (need2Read) { + try { + haveNext = read() != -1; + if (haveNext) { + need2Read = false; + } + } catch (IOException e) { + haveNext = false; + need2Read = false; + throw new UncheckedIOException(e); + } finally { + if (!haveNext) { + closeStream(); + } + } + } + return haveNext; + } + + @Override + public synchronized ByteBuffer next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + need2Read = true; + return nextBuffer; + } + + } \ No newline at end of file diff --git a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpClient.java b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpClient.java index cff9313c..d7c4c6e5 100644 --- a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpClient.java +++ b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpClient.java @@ -1,16 +1,19 @@ package xyz.wagyourtail.jvmdg.j11.stub.java_net_http; -import xyz.wagyourtail.jvmdg.j11.impl.HttpClientBuilderImpl; +import jdk.incubator.http.HttpRequest; +import xyz.wagyourtail.jvmdg.j11.impl.http.HttpClientBuilderImpl; import xyz.wagyourtail.jvmdg.version.Adapter; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLParameters; +import java.io.IOException; import java.net.Authenticator; import java.net.CookieHandler; import java.net.ProxySelector; import java.time.Duration; import java.util.Optional; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; @Adapter("Ljava/net/http/HttpClient;") @@ -43,6 +46,12 @@ public static Builder newBuilder() { public abstract Optional executor(); + public abstract J_N_H_HttpResponse send(HttpRequest var1, J_N_H_HttpResponse.BodyHandler handler) throws IOException, InterruptedException; + + public abstract CompletableFuture> sendAsync(HttpRequest var1, J_N_H_HttpResponse.BodyHandler handler); + + public abstract CompletableFuture> sendAsync(HttpRequest var1, J_N_H_HttpResponse.BodyHandler handler, J_N_H_HttpResponse.PushPromiseHandler pushPromiseHandler); + @Adapter("Ljava/net/http/HttpClient$Redirect;") public enum Redirect { NEVER, diff --git a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpHeaders.java b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpHeaders.java new file mode 100644 index 00000000..b8d35e88 --- /dev/null +++ b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpHeaders.java @@ -0,0 +1,7 @@ +package xyz.wagyourtail.jvmdg.j11.stub.java_net_http; + +import xyz.wagyourtail.jvmdg.version.Adapter; + +@Adapter("Ljava/net/http/HttpHeaders;") +public class J_N_H_HttpHeaders { +} diff --git a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpRequest.java b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpRequest.java index 965ec23a..b1796d5e 100644 --- a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpRequest.java +++ b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpRequest.java @@ -1,5 +1,8 @@ package xyz.wagyourtail.jvmdg.j11.stub.java_net_http; +import xyz.wagyourtail.jvmdg.exc.MissingStubError; +import xyz.wagyourtail.jvmdg.j11.impl.http.IterablePublisher; +import xyz.wagyourtail.jvmdg.j11.impl.http.StreamIterator; import xyz.wagyourtail.jvmdg.version.Adapter; import java.io.InputStream; @@ -7,20 +10,21 @@ import java.nio.ByteBuffer; import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; +import java.nio.file.Files; import java.nio.file.Path; import java.time.Duration; -import java.util.Optional; +import java.util.*; import java.util.concurrent.Flow; import java.util.function.Supplier; @Adapter("Ljava/net/http/HttpRequest;") public abstract class J_N_H_HttpRequest { public J_N_H_HttpRequest() { - throw new UnsupportedOperationException("TODO"); + throw MissingStubError.create(); } public static Builder newBuilder() { - throw new UnsupportedOperationException("TODO"); + throw MissingStubError.create(); } public abstract Optional bodyPublisher(); @@ -96,11 +100,23 @@ private BodyPublishers() { } public static BodyPublisher fromPublisher(Flow.Publisher publisher) { - throw new UnsupportedOperationException("TODO"); + return fromPublisher(publisher, -1); } public static BodyPublisher fromPublisher(Flow.Publisher publisher, long contentLength) { - throw new UnsupportedOperationException("TODO"); + Objects.requireNonNull(publisher); + return new BodyPublisher() { + + @Override + public long contentLength() { + return contentLength; + } + + @Override + public void subscribe(Flow.Subscriber subscriber) { + publisher.subscribe(subscriber); + } + }; } public static BodyPublisher ofString(String s) { @@ -108,35 +124,263 @@ public static BodyPublisher ofString(String s) { } public static BodyPublisher ofString(String s, Charset charset) { - throw new UnsupportedOperationException("TODO"); + return ofByteArray(s.getBytes(charset)); } public static BodyPublisher ofInputStream(Supplier streamSupplier) { - throw new UnsupportedOperationException("TODO"); + return new BodyPublisher() { + @Override + public long contentLength() { + return -1; + } + + @Override + public void subscribe(Flow.Subscriber subscriber) { + IterablePublisher publisher; + InputStream is = streamSupplier.get(); + if (is == null) { + publisher = new IterablePublisher<>(null, new NullPointerException("InputStream supplier returned null")); + } else { + publisher = new IterablePublisher<>(() -> new StreamIterator(is)); + } + publisher.subscribe(subscriber); + } + }; } public static BodyPublisher ofByteArray(byte[] bytes) { - throw new UnsupportedOperationException("TODO"); + return ofByteArray(bytes, 0, bytes.length); } public static BodyPublisher ofByteArray(byte[] bytes, int offset, int length) { - throw new UnsupportedOperationException("TODO"); + return new BodyPublisher() { + @Override + public long contentLength() { + return length; + } + + @Override + public void subscribe(Flow.Subscriber subscriber) { + subscriber.onSubscribe(new Flow.Subscription() { + private boolean completed; + + @Override + public void request(long n) { + if (n <= 0) { + subscriber.onError(new IllegalArgumentException("n <= 0")); + return; + } + if (completed) { + return; + } + completed = true; + ByteBuffer buffer = ByteBuffer.wrap(bytes, offset, length); + subscriber.onNext(buffer); + subscriber.onComplete(); + } + + @Override + public void cancel() { + completed = true; + } + }); + } + }; } public static BodyPublisher ofFile(Path file) { - throw new UnsupportedOperationException("TODO"); + return new BodyPublisher() { + @Override + public long contentLength() { + try { + return Files.size(file); + } catch (Exception e) { + return -1; + } + } + + @Override + public void subscribe(Flow.Subscriber subscriber) { + subscriber.onSubscribe(new Flow.Subscription() { + private boolean completed; + + @Override + public void request(long n) { + if (n <= 0) { + subscriber.onError(new IllegalArgumentException("n <= 0")); + return; + } + if (completed) { + return; + } + completed = true; + try (InputStream is = Files.newInputStream(file)) { + ByteBuffer buffer = ByteBuffer.wrap(is.readAllBytes()); + subscriber.onNext(buffer); + subscriber.onComplete(); + } catch (Exception e) { + subscriber.onError(e); + } + } + + @Override + public void cancel() { + completed = true; + } + }); + } + }; } public static BodyPublisher ofByteArrays(Iterable byteArrays) { - throw new UnsupportedOperationException("TODO"); + return new BodyPublisher() { + @Override + public long contentLength() { + return -1; + } + + @Override + public void subscribe(Flow.Subscriber subscriber) { + IterablePublisher publisher = new IterablePublisher<>(() -> new Iterator() { + final Iterator iterator = byteArrays.iterator(); + + @Override + public boolean hasNext() { + return iterator.hasNext(); + } + + @Override + public ByteBuffer next() { + return ByteBuffer.wrap(iterator.next()); + } + }); + publisher.subscribe(subscriber); + } + }; } public static BodyPublisher noBody() { - throw new UnsupportedOperationException("TODO"); + return new BodyPublisher() { + @Override + public long contentLength() { + return 0; + } + + @Override + public void subscribe(Flow.Subscriber subscriber) { + subscriber.onSubscribe(new Flow.Subscription() { + @Override + public void request(long n) { + subscriber.onComplete(); + } + + @Override + public void cancel() { + } + }); + } + }; } public static BodyPublisher concat(BodyPublisher... publishers) { - throw new UnsupportedOperationException("TODO"); + return new BodyPublisher() { + @Override + public long contentLength() { + long sum = 0; + for (BodyPublisher publisher : publishers) { + sum += publisher.contentLength(); + } + return sum; + } + + @Override + public void subscribe(Flow.Subscriber subscriber) { + subscriber.onSubscribe(new Flow.Subscription() { + private final Iterator iterator = List.of(publishers).iterator(); + private boolean completed; + + @Override + public void request(long n) { + if (n <= 0) { + subscriber.onError(new IllegalArgumentException("n <= 0")); + return; + } + if (completed) { + return; + } + try { + while (n > 0) { + if (!iterator.hasNext()) { + completed = true; + subscriber.onComplete(); + return; + } + BodyPublisher publisher = iterator.next(); + long contentLength = publisher.contentLength(); + if (contentLength > 0) { + publisher.subscribe(new Flow.Subscriber<>() { + private long remaining = contentLength; + + @Override + public void onSubscribe(Flow.Subscription subscription) { + subscription.request(Long.MAX_VALUE); + } + + @Override + public void onNext(ByteBuffer item) { + subscriber.onNext(item); + remaining -= item.remaining(); + if (remaining == 0) { + subscriber.onComplete(); + } + } + + @Override + public void onError(Throwable throwable) { + subscriber.onError(throwable); + } + + @Override + public void onComplete() { + } + }); + } else { + publisher.subscribe(new Flow.Subscriber<>() { + @Override + public void onSubscribe(Flow.Subscription subscription) { + subscription.request(Long.MAX_VALUE); + } + + @Override + public void onNext(ByteBuffer item) { + subscriber.onNext(item); + } + + @Override + public void onError(Throwable throwable) { + subscriber.onError(throwable); + } + + @Override + public void onComplete() { + subscriber.onComplete(); + } + }); + } + n--; + } + } catch (Throwable t) { + subscriber.onError(t); + } + } + + @Override + public void cancel() { + completed = true; + } + }); + } + }; } } } diff --git a/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpResponse.java b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpResponse.java new file mode 100644 index 00000000..75e34220 --- /dev/null +++ b/java-api/src/java11/java/xyz/wagyourtail/jvmdg/j11/stub/java_net_http/J_N_H_HttpResponse.java @@ -0,0 +1,255 @@ +package xyz.wagyourtail.jvmdg.j11.stub.java_net_http; + +import xyz.wagyourtail.jvmdg.exc.MissingStubError; +import xyz.wagyourtail.jvmdg.util.Consumer; +import xyz.wagyourtail.jvmdg.util.Function; +import xyz.wagyourtail.jvmdg.version.Adapter; + +import javax.net.ssl.SSLSession; +import java.io.InputStream; +import java.net.URI; +import java.nio.ByteBuffer; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.nio.file.OpenOption; +import java.nio.file.Path; +import java.nio.file.StandardOpenOption; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.Flow; +import java.util.stream.Stream; + +@Adapter("Ljava/net/http/HttpResponse;") +public interface J_N_H_HttpResponse { + + int statusCode(); + + J_N_H_HttpRequest request(); + + Optional> previousResponse(); + + J_N_H_HttpHeaders headers(); + + T body(); + + Optional sslSession(); + + URI uri(); + + J_N_H_HttpClient.Version version(); + + @Adapter("Ljava/net/http/HttpResponse$BodySubscriber;") + interface BodySubscriber extends Flow.Subscriber> { + + CompletionStage getBody(); + + } + + @Adapter("Ljava/net/http/HttpResponse$ResponseInfo;") + interface ResponseInfo { + int statusCode(); + + J_N_H_HttpHeaders headers(); + + J_N_H_HttpClient.Version version(); + } + + @Adapter("Ljava/net/http/HttpResponse$BodyHandler;") + interface BodyHandler { + + BodySubscriber apply(ResponseInfo responseInfo); + + } + + @Adapter("Ljava/net/http/HttpResponse$BodyHandlers;") + class BodyHandlers { + private static Charset charsetFrom(J_N_H_HttpHeaders headers) { + throw MissingStubError.create(); + } + + public static BodyHandler fromSubscriber(Flow.Subscriber> subscriber) { + Objects.requireNonNull(subscriber); + return (info) -> BodySubscribers.fromSubscriber(subscriber); + } + + public static >, T> BodyHandler fromSubscriber(Flow.Subscriber> subscriber, Function finisher) { + Objects.requireNonNull(subscriber); + Objects.requireNonNull(finisher); + return (info) -> BodySubscribers.fromSubscriber(subscriber, finisher); + } + + public static BodyHandler fromLineSubscriber(Flow.Subscriber subscriber) { + Objects.requireNonNull(subscriber); + return (info) -> BodySubscribers.fromLineSubscriber(subscriber, (s) -> null, charsetFrom(info.headers()), null); + } + + public static BodyHandler fromLineSubscriber( + Flow.Subscriber subscriber, + Function,? extends Void> finisher, + String lineSeparator + ) { + Objects.requireNonNull(subscriber); + Objects.requireNonNull(finisher); + return (info) -> BodySubscribers.fromLineSubscriber(subscriber, finisher, charsetFrom(info.headers()), lineSeparator); + } + + public static BodyHandler discarding() { + return (info) -> BodySubscribers.discarding(); + } + + public static BodyHandler replacing(U value) { + Objects.requireNonNull(value); + return (info) -> BodySubscribers.replacing(value); + } + + public static BodyHandler ofString(Charset charset) { + Objects.requireNonNull(charset); + return (info) -> BodySubscribers.ofString(charset); + } + + public static BodyHandler ofFile(Path file, OpenOption... options) { + Objects.requireNonNull(file); + return (info) -> BodySubscribers.ofFile(file, options); + } + + public static BodyHandler ofFile(Path file) { + return ofFile(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE); + } + + public static BodyHandler ofFileDownload(Path dir, OpenOption... options) { + Objects.requireNonNull(dir); + return (info) -> { + throw MissingStubError.create(); + }; + } + + public static BodyHandler ofInputStream() { + return (info) -> BodySubscribers.ofInputStream(); + } + + public static BodyHandler> ofLines() { + return (info) -> BodySubscribers.ofLines(charsetFrom(info.headers())); + } + + public static BodyHandler ofByteArrayConsumer(Consumer> consumer) { + Objects.requireNonNull(consumer); + return (info) -> BodySubscribers.ofByteArrayConsumer(consumer); + } + + public static BodyHandler ofByteArray() { + return (info) -> BodySubscribers.ofByteArray(); + } + + public static BodyHandler ofString() { + return (info) -> BodySubscribers.ofString(charsetFrom(info.headers())); + } + + public static BodyHandler>> ofPublisher() { + return (info) -> BodySubscribers.ofPublisher(); + } + + public static BodyHandler buffering(BodyHandler downstream, int bufferSize) { + Objects.requireNonNull(downstream); + return (info) -> BodySubscribers.buffering(downstream.apply(info), bufferSize); + } + + } + + @Adapter("Ljava/net/http/HttpResponse$BodySubscribers;") + class BodySubscribers { + + public static BodySubscriber fromSubscriber(Flow.Subscriber> subscriber) { + return fromSubscriber(subscriber, (s) -> null); + } + + public static >, T> BodySubscriber fromSubscriber(Flow.Subscriber> subscriber, Function finisher) { + throw MissingStubError.create(); + } + + public static BodySubscriber fromLineSubscriber(Flow.Subscriber subscriber) { + return fromLineSubscriber(subscriber, (s) -> null, StandardCharsets.UTF_8, null); + } + + public static BodySubscriber fromLineSubscriber( + Flow.Subscriber subscriber, + Function,? extends Void> finisher, + Charset charset, + String lineSeparator + ) { + throw MissingStubError.create(); + } + + public static BodySubscriber ofString(Charset charset) { + throw MissingStubError.create(); + } + + public static BodySubscriber ofByteArray() { + throw MissingStubError.create(); + } + + public static BodySubscriber ofFile(Path file, OpenOption... options) { + throw MissingStubError.create(); + } + + public static BodySubscriber ofFile(Path file) { + return ofFile(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE); + } + + public static BodySubscriber ofByteArrayConsumer(Consumer> consumer) { + throw MissingStubError.create(); + } + + public static BodySubscriber ofInputStream() { + throw MissingStubError.create(); + } + + public static BodySubscriber> ofLines(Charset charset) { + throw MissingStubError.create(); + } + + public static BodySubscriber>> ofPublisher() { + throw MissingStubError.create(); + } + + public static BodySubscriber replacing(U value) { + throw MissingStubError.create(); + } + + public static BodySubscriber discarding() { + throw MissingStubError.create(); + } + + public static BodySubscriber buffering(BodySubscriber downstream, int bufferSize) { + throw MissingStubError.create(); + } + + public static BodySubscriber mapping(BodySubscriber downstream, Function mapper) { + throw MissingStubError.create(); + } + + } + + @Adapter("Ljava/net/http/HttpResponse$PushPromiseHandler;") + interface PushPromiseHandler { + + void applyPushPromise( + J_N_H_HttpRequest initiatingRequest, + J_N_H_HttpRequest pushPromiseRequest, + Function, CompletableFuture>> acceptor + ); + + static PushPromiseHandler of( + Function> pushPromiseHandler, + ConcurrentMap>> pushPromisesMap + ) { + throw MissingStubError.create(); + } + + } + + +} diff --git a/java-api/src/java12/java/xyz/wagyourtail/jvmdg/j12/stub/java_base/J_L_String.java b/java-api/src/java12/java/xyz/wagyourtail/jvmdg/j12/stub/java_base/J_L_String.java new file mode 100644 index 00000000..2f90b43a --- /dev/null +++ b/java-api/src/java12/java/xyz/wagyourtail/jvmdg/j12/stub/java_base/J_L_String.java @@ -0,0 +1,43 @@ +package xyz.wagyourtail.jvmdg.j12.stub.java_base; + +import xyz.wagyourtail.jvmdg.version.Stub; + +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class J_L_String { + + @Stub + public static String indent(String input, int n) { + if (input.isEmpty()) { + return ""; + } + Stream stream = input.lines(); + if (n > 0) { + final String spaces = " ".repeat(n); + stream = stream.map(s -> spaces + s); + } else if (n == Integer.MIN_VALUE) { + stream = stream.map(String::stripLeading); + } else if (n < 0) { + stream = stream.map(s -> s.substring(Math.min(-n, indexOfNonWhitespace(s)))); + } + return stream.collect(Collectors.joining("\n", "", "\n")); + } + + private static int indexOfNonWhitespace(String s) { + int i = 0; + int len = s.length(); + while (i < len && Character.isWhitespace(s.charAt(i))) { + i++; + } + return i; + } + + + @Stub + public static R transform(String input, Function func) { + return func.apply(input); + } + +} diff --git a/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_Buffer.java b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_Buffer.java index 4df2cb80..d4e2f1de 100644 --- a/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_Buffer.java +++ b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_Buffer.java @@ -1,13 +1,13 @@ package xyz.wagyourtail.jvmdg.j13.stub.java_base; +import xyz.wagyourtail.jvmdg.version.Coerce; import xyz.wagyourtail.jvmdg.version.Stub; import java.nio.Buffer; public class J_N_Buffer { - @Stub public static Buffer slice(Buffer buffer, int index, int length) { int pos = buffer.position(); diff --git a/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_ByteBuffer.java b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_ByteBuffer.java new file mode 100644 index 00000000..fb398e26 --- /dev/null +++ b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_ByteBuffer.java @@ -0,0 +1,43 @@ +package xyz.wagyourtail.jvmdg.j13.stub.java_base; + +import xyz.wagyourtail.jvmdg.version.Stub; + +import java.nio.ByteBuffer; +import java.nio.ReadOnlyBufferException; +import java.util.Objects; + +public class J_N_ByteBuffer { + + @Stub + public static ByteBuffer get(ByteBuffer self, int index, byte[] dst) { + return get(self, index, dst, 0, dst.length); + } + + @Stub + public static ByteBuffer get(ByteBuffer self, int index, byte[] dst, int offset, int length) { + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, dst.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + dst[i] = self.get(j); + return self; + } + + @Stub + public static ByteBuffer put(ByteBuffer self, int index, byte[] src) { + return put(self, index, src, 0, src.length); + } + + @Stub + public static ByteBuffer put(ByteBuffer self, int index, byte[] src, int offset, int length) { + if (self.isReadOnly()) + throw new ReadOnlyBufferException(); + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, src.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + self.put(j, src[i]); + return self; + } + +} diff --git a/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_CharBuffer.java b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_CharBuffer.java new file mode 100644 index 00000000..7eeedcc9 --- /dev/null +++ b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_CharBuffer.java @@ -0,0 +1,44 @@ +package xyz.wagyourtail.jvmdg.j13.stub.java_base; + +import xyz.wagyourtail.jvmdg.version.Stub; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.ReadOnlyBufferException; +import java.util.Objects; + +public class J_N_CharBuffer { + + @Stub + public static CharBuffer get(CharBuffer self, int index, char[] dst) { + return get(self, index, dst, 0, dst.length); + } + + @Stub + public static CharBuffer get(CharBuffer self, int index, char[] dst, int offset, int length) { + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, dst.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + dst[i] = self.get(j); + return self; + } + + @Stub + public static CharBuffer put(CharBuffer self, int index, char[] src) { + return put(self, index, src, 0, src.length); + } + + @Stub + public static CharBuffer put(CharBuffer self, int index, char[] src, int offset, int length) { + if (self.isReadOnly()) + throw new ReadOnlyBufferException(); + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, src.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + self.put(j, src[i]); + return self; + } + +} diff --git a/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_DoubleBuffer.java b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_DoubleBuffer.java new file mode 100644 index 00000000..6d74a932 --- /dev/null +++ b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_DoubleBuffer.java @@ -0,0 +1,44 @@ +package xyz.wagyourtail.jvmdg.j13.stub.java_base; + +import xyz.wagyourtail.jvmdg.version.Stub; + +import java.nio.ByteBuffer; +import java.nio.DoubleBuffer; +import java.nio.ReadOnlyBufferException; +import java.util.Objects; + +public class J_N_DoubleBuffer { + + @Stub + public static DoubleBuffer get(DoubleBuffer self, int index, double[] dst) { + return get(self, index, dst, 0, dst.length); + } + + @Stub + public static DoubleBuffer get(DoubleBuffer self, int index, double[] dst, int offset, int length) { + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, dst.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + dst[i] = self.get(j); + return self; + } + + @Stub + public static DoubleBuffer put(DoubleBuffer self, int index, double[] src) { + return put(self, index, src, 0, src.length); + } + + @Stub + public static DoubleBuffer put(DoubleBuffer self, int index, double[] src, int offset, int length) { + if (self.isReadOnly()) + throw new ReadOnlyBufferException(); + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, src.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + self.put(j, src[i]); + return self; + } + +} diff --git a/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_FloatBuffer.java b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_FloatBuffer.java new file mode 100644 index 00000000..3247927c --- /dev/null +++ b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_FloatBuffer.java @@ -0,0 +1,44 @@ +package xyz.wagyourtail.jvmdg.j13.stub.java_base; + +import xyz.wagyourtail.jvmdg.version.Stub; + +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.ReadOnlyBufferException; +import java.util.Objects; + +public class J_N_FloatBuffer { + + @Stub + public static FloatBuffer get(FloatBuffer self, int index, float[] dst) { + return get(self, index, dst, 0, dst.length); + } + + @Stub + public static FloatBuffer get(FloatBuffer self, int index, float[] dst, int offset, int length) { + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, dst.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + dst[i] = self.get(j); + return self; + } + + @Stub + public static FloatBuffer put(FloatBuffer self, int index, float[] src) { + return put(self, index, src, 0, src.length); + } + + @Stub + public static FloatBuffer put(FloatBuffer self, int index, float[] src, int offset, int length) { + if (self.isReadOnly()) + throw new ReadOnlyBufferException(); + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, src.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + self.put(j, src[i]); + return self; + } + +} diff --git a/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_IntBuffer.java b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_IntBuffer.java new file mode 100644 index 00000000..7abe92ee --- /dev/null +++ b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_IntBuffer.java @@ -0,0 +1,44 @@ +package xyz.wagyourtail.jvmdg.j13.stub.java_base; + +import xyz.wagyourtail.jvmdg.version.Stub; + +import java.nio.IntBuffer; +import java.nio.ReadOnlyBufferException; +import java.nio.ShortBuffer; +import java.util.Objects; + +public class J_N_IntBuffer { + + @Stub + public static IntBuffer get(IntBuffer self, int index, int[] dst) { + return get(self, index, dst, 0, dst.length); + } + + @Stub + public static IntBuffer get(IntBuffer self, int index, int[] dst, int offset, int length) { + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, dst.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + dst[i] = self.get(j); + return self; + } + + @Stub + public static IntBuffer put(IntBuffer self, int index, int[] src) { + return put(self, index, src, 0, src.length); + } + + @Stub + public static IntBuffer put(IntBuffer self, int index, int[] src, int offset, int length) { + if (self.isReadOnly()) + throw new ReadOnlyBufferException(); + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, src.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + self.put(j, src[i]); + return self; + } + +} diff --git a/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_LongBuffer.java b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_LongBuffer.java new file mode 100644 index 00000000..551f289f --- /dev/null +++ b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_LongBuffer.java @@ -0,0 +1,44 @@ +package xyz.wagyourtail.jvmdg.j13.stub.java_base; + +import xyz.wagyourtail.jvmdg.version.Stub; + +import java.nio.ByteBuffer; +import java.nio.LongBuffer; +import java.nio.ReadOnlyBufferException; +import java.util.Objects; + +public class J_N_LongBuffer { + + @Stub + public static LongBuffer get(LongBuffer self, int index, long[] dst) { + return get(self, index, dst, 0, dst.length); + } + + @Stub + public static LongBuffer get(LongBuffer self, int index, long[] dst, int offset, int length) { + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, dst.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + dst[i] = self.get(j); + return self; + } + + @Stub + public static LongBuffer put(LongBuffer self, int index, long[] src) { + return put(self, index, src, 0, src.length); + } + + @Stub + public static LongBuffer put(LongBuffer self, int index, long[] src, int offset, int length) { + if (self.isReadOnly()) + throw new ReadOnlyBufferException(); + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, src.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + self.put(j, src[i]); + return self; + } + +} diff --git a/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_ShortBuffer.java b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_ShortBuffer.java new file mode 100644 index 00000000..3d8d96b4 --- /dev/null +++ b/java-api/src/java13/java/xyz/wagyourtail/jvmdg/j13/stub/java_base/J_N_ShortBuffer.java @@ -0,0 +1,44 @@ +package xyz.wagyourtail.jvmdg.j13.stub.java_base; + +import xyz.wagyourtail.jvmdg.version.Stub; + +import java.nio.LongBuffer; +import java.nio.ReadOnlyBufferException; +import java.nio.ShortBuffer; +import java.util.Objects; + +public class J_N_ShortBuffer { + + @Stub + public static ShortBuffer get(ShortBuffer self, int index, short[] dst) { + return get(self, index, dst, 0, dst.length); + } + + @Stub + public static ShortBuffer get(ShortBuffer self, int index, short[] dst, int offset, int length) { + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, dst.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + dst[i] = self.get(j); + return self; + } + + @Stub + public static ShortBuffer put(ShortBuffer self, int index, short[] src) { + return put(self, index, src, 0, src.length); + } + + @Stub + public static ShortBuffer put(ShortBuffer self, int index, short[] src, int offset, int length) { + if (self.isReadOnly()) + throw new ReadOnlyBufferException(); + Objects.checkFromIndexSize(index, length, self.limit()); + Objects.checkFromIndexSize(offset, length, src.length); + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + self.put(j, src[i]); + return self; + } + +} diff --git a/java-api/src/java15/java/xyz/wagyourtail/jvmdg/j15/stub/java_base/J_L_I_MethodHandles$Lookup.java b/java-api/src/java15/java/xyz/wagyourtail/jvmdg/j15/stub/java_base/J_L_I_MethodHandles$Lookup.java index fc80b473..73639a9b 100644 --- a/java-api/src/java15/java/xyz/wagyourtail/jvmdg/j15/stub/java_base/J_L_I_MethodHandles$Lookup.java +++ b/java-api/src/java15/java/xyz/wagyourtail/jvmdg/j15/stub/java_base/J_L_I_MethodHandles$Lookup.java @@ -79,7 +79,7 @@ public final Class defineClass0(byte[] b, int off, int len) { @Override public byte[] apply(String s) { - URL url = findResource(s + ".class"); + URL url = getResource(s + ".class"); if (url == null) return null; try { return Utils.readAllBytes(url.openStream()); diff --git a/java-api/src/java9/java/xyz/wagyourtail/jvmdg/j9/stub/java_base/J_L_I_MethodHandles.java b/java-api/src/java9/java/xyz/wagyourtail/jvmdg/j9/stub/java_base/J_L_I_MethodHandles.java new file mode 100644 index 00000000..f4d74a10 --- /dev/null +++ b/java-api/src/java9/java/xyz/wagyourtail/jvmdg/j9/stub/java_base/J_L_I_MethodHandles.java @@ -0,0 +1,84 @@ +package xyz.wagyourtail.jvmdg.j9.stub.java_base; + +import xyz.wagyourtail.jvmdg.ClassDowngrader; +import xyz.wagyourtail.jvmdg.util.Utils; +import xyz.wagyourtail.jvmdg.version.Ref; +import xyz.wagyourtail.jvmdg.version.Stub; + +import java.lang.invoke.*; +import java.lang.reflect.Array; +import java.net.URL; +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.atomic.AtomicReference; + +public class J_L_I_MethodHandles { + private static final MethodHandles.Lookup IMPL_LOOKUP = Utils.getImplLookup(); + private static final MethodHandle LookupCtor; + private static final MethodHandle ArrayCtor; + + static { + try { + LookupCtor = IMPL_LOOKUP.findConstructor(MethodHandles.Lookup.class, MethodType.methodType(void.class, Class.class)); + ArrayCtor = IMPL_LOOKUP.findStatic(Array.class, "newInstance", MethodType.methodType(Object.class, Class.class, int.class)); + } catch (NoSuchMethodException | IllegalAccessException e) { + throw new RuntimeException(e); + } + } + + @Stub(ref = @Ref("java/lang/invoke/MethodHandles")) + public static MethodHandle arrayConstructor(Class arrayClass) { + return MethodHandles.insertArguments(ArrayCtor, 0, arrayClass); + } + + + @Stub(ref = @Ref("java/lang/invoke/MethodHandles")) + public static MethodHandles.Lookup privateLookupIn(Class cls, MethodHandles.Lookup lookup) throws Throwable { + return (MethodHandles.Lookup) LookupCtor.invokeExact(cls); + } + + public static class Lookup { + private static final MethodHandle DefineClass; + + static { + try { + DefineClass = IMPL_LOOKUP.findVirtual(ClassLoader.class, "defineClass", MethodType.methodType(Class.class, byte[].class, int.class, int.class)); + } catch (NoSuchMethodException | IllegalAccessException e) { + throw new RuntimeException(e); + } + } + + @Stub(requiresRuntime = true) + public static Class defineClass(MethodHandles.Lookup lookup, byte[] bytes) throws Throwable { + Objects.requireNonNull(bytes); + ClassLoader loader = lookup.lookupClass().getClassLoader(); + // check if classdowngrader is available + try { + Class.forName("xyz.wagyourtail.jvmdg.ClassDowngrader"); + } catch (ClassNotFoundException e) { + return (Class) DefineClass.invokeExact(loader, bytes, 0, bytes.length); + } + AtomicReference name = new AtomicReference<>(null); + Map classBytes = ClassDowngrader.getCurrentVersionDowngrader().downgrade(name, bytes, true, (s) -> { + URL url = loader.getResource(s + ".class"); + if (url == null) return null; + try { + return Utils.readAllBytes(url.openStream()); + } catch (Exception e) { + throw new RuntimeException(e); + } + }); + Class c = null; + for (Map.Entry entry : classBytes.entrySet()) { + if (Objects.equals(entry.getKey(), name.get())) { + c = (Class) DefineClass.invokeExact(loader, entry.getValue(), 0, entry.getValue().length); + } else { + DefineClass.invokeExact(loader, entry.getValue(), 0, entry.getValue().length); + } + } + if (c == null) throw new IllegalStateException("class " + name + " not found in outputs"); + return c; + } + + } +} diff --git a/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java11Downgrader.java b/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java11Downgrader.java index 07a1b915..98aaf75c 100644 --- a/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java11Downgrader.java +++ b/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java11Downgrader.java @@ -86,9 +86,7 @@ public void init() { // stub(J_N_H_HttpClient.class); // HttpConnectTimeoutException // stub(J_N_H_HttpRequest.class); -// stub(J_N_H_HttpRequest.Builder.class); -// stub(J_N_H_HttpRequest.BodyPublisher.class); - // HttpResponse +// stub(J_N_H_HttpResponse.class); // HttpTimeoutException // WebSocket // WebSocketHandshakeException diff --git a/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java12Downgrader.java b/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java12Downgrader.java index 65d7fb6f..4f8061c0 100644 --- a/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java12Downgrader.java +++ b/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java12Downgrader.java @@ -19,7 +19,7 @@ public void init() { // Float // Integer // Long - // String + stub(J_L_String.class); // ClassDesc // ConstantDesc // ConstantDescs diff --git a/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java13Downgrader.java b/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java13Downgrader.java index 61862f92..00eb5fb8 100644 --- a/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java13Downgrader.java +++ b/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java13Downgrader.java @@ -1,8 +1,7 @@ package xyz.wagyourtail.jvmdg.providers; import org.objectweb.asm.Opcodes; -import xyz.wagyourtail.jvmdg.j13.stub.java_base.J_N_Buffer; -import xyz.wagyourtail.jvmdg.j13.stub.java_base.J_N_F_FileSystems; +import xyz.wagyourtail.jvmdg.j13.stub.java_base.*; import xyz.wagyourtail.jvmdg.version.VersionProvider; public class Java13Downgrader extends VersionProvider { @@ -14,8 +13,15 @@ public void init() { // -- java.base -- // Character$UnicodeBlock (more unicode spaces); stub(J_N_Buffer.class); - // MappedByteBuffer + stub(J_N_ByteBuffer.class); + stub(J_N_CharBuffer.class); + stub(J_N_DoubleBuffer.class); stub(J_N_F_FileSystems.class); + stub(J_N_FloatBuffer.class); + stub(J_N_IntBuffer.class); + stub(J_N_LongBuffer.class); + // MappedByteBuffer + stub(J_N_ShortBuffer.class); // Signature // DecimalFormatSymbols // JapaneseEra diff --git a/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java9Downgrader.java b/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java9Downgrader.java index a803a8ae..a0b99989 100644 --- a/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java9Downgrader.java +++ b/java-api/src/main/java/xyz/wagyourtail/jvmdg/providers/Java9Downgrader.java @@ -63,7 +63,7 @@ public void init() { stub(J_L_Thread.class); // ElementType // MethodHandle - // MethodHandles + stub(J_L_I_MethodHandles.class); // MethodHandles$Lookup // StringConcatException stub(J_L_I_StringConcatFactory.class);