* private void writeObject(java.io.ObjectOutputStream out)
- * throws IOException
+ * throws IOException;
* private void readObject(java.io.ObjectInputStream in)
* throws IOException, ClassNotFoundException;
* private void readObjectNoData()
diff --git a/src/java.base/share/classes/java/lang/FdLibm.java b/src/java.base/share/classes/java/lang/FdLibm.java
index dd79ee82863..70d728a16db 100644
--- a/src/java.base/share/classes/java/lang/FdLibm.java
+++ b/src/java.base/share/classes/java/lang/FdLibm.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -3005,7 +3005,6 @@ static double compute(double x) {
hx = __HI(x); // high word of x
xsb = hx & SIGN_BIT; // sign bit of x
- y = Math.abs(x);
hx &= EXP_SIGNIF_BITS; // high word of |x|
// filter out huge and non-finite argument
diff --git a/src/java.base/share/classes/java/lang/classfile/BufWriter.java b/src/java.base/share/classes/java/lang/classfile/BufWriter.java
index bab8ebda4b8..f178b6b2db0 100644
--- a/src/java.base/share/classes/java/lang/classfile/BufWriter.java
+++ b/src/java.base/share/classes/java/lang/classfile/BufWriter.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -124,6 +124,7 @@ public sealed interface BufWriter
* @param arr the byte array
* @param start the offset within the byte array of the range
* @param length the length of the range
+ * @throws IndexOutOfBoundsException if range is outside of the array bounds
*/
void writeBytes(byte[] arr, int start, int length);
@@ -134,6 +135,7 @@ public sealed interface BufWriter
* @param offset the offset at which to patch
* @param size the size of the integer value being written, in bytes
* @param value the integer value
+ * @throws IndexOutOfBoundsException if patched int is outside of bounds
*/
void patchInt(int offset, int size, int value);
@@ -152,7 +154,7 @@ public sealed interface BufWriter
* to the buffer
*
* @param entry the constant pool entry
- * @throws NullPointerException if the entry is null
+ * @throws IllegalArgumentException if the entry has invalid index
*/
void writeIndex(PoolEntry entry);
@@ -161,6 +163,7 @@ public sealed interface BufWriter
* to the buffer, or zero if the entry is null
*
* @param entry the constant pool entry
+ * @throws IllegalArgumentException if the entry has invalid index
*/
void writeIndexOrZero(PoolEntry entry);
@@ -180,6 +183,7 @@ public sealed interface BufWriter
* entry in the list.
*
* @param list the list of entries
+ * @throws IllegalArgumentException if any entry has invalid index
*/
void writeListIndices(List list);
@@ -199,6 +203,7 @@ public sealed interface BufWriter
* @param array the byte array
* @param bufferOffset the offset into the array at which to write the
* contents of the buffer
+ * @throws IndexOutOfBoundsException if copying outside of the array bounds
*/
void copyTo(byte[] array, int bufferOffset);
}
diff --git a/src/java.base/share/classes/java/lang/constant/ClassDesc.java b/src/java.base/share/classes/java/lang/constant/ClassDesc.java
index 60adc7f1ab1..89be851dbf5 100644
--- a/src/java.base/share/classes/java/lang/constant/ClassDesc.java
+++ b/src/java.base/share/classes/java/lang/constant/ClassDesc.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -158,19 +158,10 @@ static ClassDesc of(String packageName, String className) {
* @see ClassDesc#ofInternalName(String)
*/
static ClassDesc ofDescriptor(String descriptor) {
- requireNonNull(descriptor);
- if (descriptor.isEmpty()) {
- throw new IllegalArgumentException(
- "not a valid reference type descriptor: " + descriptor);
- }
- int depth = ConstantUtils.arrayDepth(descriptor);
- if (depth > ConstantUtils.MAX_ARRAY_TYPE_DESC_DIMENSIONS) {
- throw new IllegalArgumentException(
- "Cannot create an array type descriptor with more than " +
- ConstantUtils.MAX_ARRAY_TYPE_DESC_DIMENSIONS + " dimensions");
- }
+ // implicit null-check
return (descriptor.length() == 1)
- ? new PrimitiveClassDescImpl(descriptor)
+ ? Wrapper.forPrimitiveType(descriptor.charAt(0)).classDescriptor()
+ // will throw IAE on descriptor.length == 0 or if array dimensions too long
: new ReferenceClassDescImpl(descriptor);
}
@@ -279,7 +270,7 @@ default ClassDesc nested(String firstNestedName, String... moreNestedNames) {
* @return whether this {@linkplain ClassDesc} describes an array type
*/
default boolean isArray() {
- return descriptorString().startsWith("[");
+ return descriptorString().charAt(0) == '[';
}
/**
@@ -297,7 +288,7 @@ default boolean isPrimitive() {
* @return whether this {@linkplain ClassDesc} describes a class or interface type
*/
default boolean isClassOrInterface() {
- return descriptorString().startsWith("L");
+ return descriptorString().charAt(0) == 'L';
}
/**
diff --git a/src/java.base/share/classes/java/lang/constant/ConstantDescs.java b/src/java.base/share/classes/java/lang/constant/ConstantDescs.java
index 82f56b7cbd4..a67a16643c3 100644
--- a/src/java.base/share/classes/java/lang/constant/ConstantDescs.java
+++ b/src/java.base/share/classes/java/lang/constant/ConstantDescs.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -64,125 +64,125 @@ private ConstantDescs() { }
// Don't change the order of these declarations!
/** {@link ClassDesc} representing {@link Object} */
- public static final ClassDesc CD_Object = ClassDesc.of("java.lang.Object");
+ public static final ClassDesc CD_Object = new ReferenceClassDescImpl("Ljava/lang/Object;");
/** {@link ClassDesc} representing {@link String} */
- public static final ClassDesc CD_String = ClassDesc.of("java.lang.String");
+ public static final ClassDesc CD_String = new ReferenceClassDescImpl("Ljava/lang/String;");
/** {@link ClassDesc} representing {@link Class} */
- public static final ClassDesc CD_Class = ClassDesc.of("java.lang.Class");
+ public static final ClassDesc CD_Class = new ReferenceClassDescImpl("Ljava/lang/Class;");
/** {@link ClassDesc} representing {@link Number} */
- public static final ClassDesc CD_Number = ClassDesc.of("java.lang.Number");
+ public static final ClassDesc CD_Number = new ReferenceClassDescImpl("Ljava/lang/Number;");
/** {@link ClassDesc} representing {@link Integer} */
- public static final ClassDesc CD_Integer = ClassDesc.of("java.lang.Integer");
+ public static final ClassDesc CD_Integer = new ReferenceClassDescImpl("Ljava/lang/Integer;");
/** {@link ClassDesc} representing {@link Long} */
- public static final ClassDesc CD_Long = ClassDesc.of("java.lang.Long");
+ public static final ClassDesc CD_Long = new ReferenceClassDescImpl("Ljava/lang/Long;");
/** {@link ClassDesc} representing {@link Float} */
- public static final ClassDesc CD_Float = ClassDesc.of("java.lang.Float");
+ public static final ClassDesc CD_Float = new ReferenceClassDescImpl("Ljava/lang/Float;");
/** {@link ClassDesc} representing {@link Double} */
- public static final ClassDesc CD_Double = ClassDesc.of("java.lang.Double");
+ public static final ClassDesc CD_Double = new ReferenceClassDescImpl("Ljava/lang/Double;");
/** {@link ClassDesc} representing {@link Short} */
- public static final ClassDesc CD_Short = ClassDesc.of("java.lang.Short");
+ public static final ClassDesc CD_Short = new ReferenceClassDescImpl("Ljava/lang/Short;");
/** {@link ClassDesc} representing {@link Byte} */
- public static final ClassDesc CD_Byte = ClassDesc.of("java.lang.Byte");
+ public static final ClassDesc CD_Byte = new ReferenceClassDescImpl("Ljava/lang/Byte;");
/** {@link ClassDesc} representing {@link Character} */
- public static final ClassDesc CD_Character = ClassDesc.of("java.lang.Character");
+ public static final ClassDesc CD_Character = new ReferenceClassDescImpl("Ljava/lang/Character;");
/** {@link ClassDesc} representing {@link Boolean} */
- public static final ClassDesc CD_Boolean = ClassDesc.of("java.lang.Boolean");
+ public static final ClassDesc CD_Boolean = new ReferenceClassDescImpl("Ljava/lang/Boolean;");
/** {@link ClassDesc} representing {@link Void} */
- public static final ClassDesc CD_Void = ClassDesc.of("java.lang.Void");
+ public static final ClassDesc CD_Void = new ReferenceClassDescImpl("Ljava/lang/Void;");
/** {@link ClassDesc} representing {@link Throwable} */
- public static final ClassDesc CD_Throwable = ClassDesc.of("java.lang.Throwable");
+ public static final ClassDesc CD_Throwable = new ReferenceClassDescImpl("Ljava/lang/Throwable;");
/** {@link ClassDesc} representing {@link Exception} */
- public static final ClassDesc CD_Exception = ClassDesc.of("java.lang.Exception");
+ public static final ClassDesc CD_Exception = new ReferenceClassDescImpl("Ljava/lang/Exception;");
/** {@link ClassDesc} representing {@link Enum} */
- public static final ClassDesc CD_Enum = ClassDesc.of("java.lang.Enum");
+ public static final ClassDesc CD_Enum = new ReferenceClassDescImpl("Ljava/lang/Enum;");
/** {@link ClassDesc} representing {@link VarHandle} */
- public static final ClassDesc CD_VarHandle = ClassDesc.of("java.lang.invoke.VarHandle");
+ public static final ClassDesc CD_VarHandle = new ReferenceClassDescImpl("Ljava/lang/invoke/VarHandle;");
/** {@link ClassDesc} representing {@link MethodHandles} */
- public static final ClassDesc CD_MethodHandles = ClassDesc.of("java.lang.invoke.MethodHandles");
+ public static final ClassDesc CD_MethodHandles = new ReferenceClassDescImpl("Ljava/lang/invoke/MethodHandles;");
/** {@link ClassDesc} representing {@link MethodHandles.Lookup} */
- public static final ClassDesc CD_MethodHandles_Lookup = CD_MethodHandles.nested("Lookup");
+ public static final ClassDesc CD_MethodHandles_Lookup = new ReferenceClassDescImpl("Ljava/lang/invoke/MethodHandles$Lookup;");
/** {@link ClassDesc} representing {@link MethodHandle} */
- public static final ClassDesc CD_MethodHandle = ClassDesc.of("java.lang.invoke.MethodHandle");
+ public static final ClassDesc CD_MethodHandle = new ReferenceClassDescImpl("Ljava/lang/invoke/MethodHandle;");
/** {@link ClassDesc} representing {@link MethodType} */
- public static final ClassDesc CD_MethodType = ClassDesc.of("java.lang.invoke.MethodType");
+ public static final ClassDesc CD_MethodType = new ReferenceClassDescImpl("Ljava/lang/invoke/MethodType;");
/** {@link ClassDesc} representing {@link CallSite} */
- public static final ClassDesc CD_CallSite = ClassDesc.of("java.lang.invoke.CallSite");
+ public static final ClassDesc CD_CallSite = new ReferenceClassDescImpl("Ljava/lang/invoke/CallSite;");
/** {@link ClassDesc} representing {@link Collection} */
- public static final ClassDesc CD_Collection = ClassDesc.of("java.util.Collection");
+ public static final ClassDesc CD_Collection = new ReferenceClassDescImpl("Ljava/util/Collection;");
/** {@link ClassDesc} representing {@link List} */
- public static final ClassDesc CD_List = ClassDesc.of("java.util.List");
+ public static final ClassDesc CD_List = new ReferenceClassDescImpl("Ljava/util/List;");
/** {@link ClassDesc} representing {@link Set} */
- public static final ClassDesc CD_Set = ClassDesc.of("java.util.Set");
+ public static final ClassDesc CD_Set = new ReferenceClassDescImpl("Ljava/util/Set;");
/** {@link ClassDesc} representing {@link Map} */
- public static final ClassDesc CD_Map = ClassDesc.of("java.util.Map");
+ public static final ClassDesc CD_Map = new ReferenceClassDescImpl("Ljava/util/Map;");
/** {@link ClassDesc} representing {@link ConstantDesc} */
- public static final ClassDesc CD_ConstantDesc = ClassDesc.of("java.lang.constant.ConstantDesc");
+ public static final ClassDesc CD_ConstantDesc = new ReferenceClassDescImpl("Ljava/lang/constant/ConstantDesc;");
/** {@link ClassDesc} representing {@link ClassDesc} */
- public static final ClassDesc CD_ClassDesc = ClassDesc.of("java.lang.constant.ClassDesc");
+ public static final ClassDesc CD_ClassDesc = new ReferenceClassDescImpl("Ljava/lang/constant/ClassDesc;");
/** {@link ClassDesc} representing {@link EnumDesc} */
- public static final ClassDesc CD_EnumDesc = CD_Enum.nested("EnumDesc");
+ public static final ClassDesc CD_EnumDesc = new ReferenceClassDescImpl("Ljava/lang/Enum$EnumDesc;");
/** {@link ClassDesc} representing {@link MethodTypeDesc} */
- public static final ClassDesc CD_MethodTypeDesc = ClassDesc.of("java.lang.constant.MethodTypeDesc");
+ public static final ClassDesc CD_MethodTypeDesc = new ReferenceClassDescImpl("Ljava/lang/constant/MethodTypeDesc;");
/** {@link ClassDesc} representing {@link MethodHandleDesc} */
- public static final ClassDesc CD_MethodHandleDesc = ClassDesc.of("java.lang.constant.MethodHandleDesc");
+ public static final ClassDesc CD_MethodHandleDesc = new ReferenceClassDescImpl("Ljava/lang/constant/MethodHandleDesc;");
/** {@link ClassDesc} representing {@link DirectMethodHandleDesc} */
- public static final ClassDesc CD_DirectMethodHandleDesc = ClassDesc.of("java.lang.constant.DirectMethodHandleDesc");
+ public static final ClassDesc CD_DirectMethodHandleDesc = new ReferenceClassDescImpl("Ljava/lang/constant/DirectMethodHandleDesc;");
/** {@link ClassDesc} representing {@link VarHandleDesc} */
- public static final ClassDesc CD_VarHandleDesc = CD_VarHandle.nested("VarHandleDesc");
+ public static final ClassDesc CD_VarHandleDesc = new ReferenceClassDescImpl("Ljava/lang/invoke/VarHandle$VarHandleDesc;");
/** {@link ClassDesc} representing {@link DirectMethodHandleDesc.Kind} */
- public static final ClassDesc CD_MethodHandleDesc_Kind = CD_DirectMethodHandleDesc.nested("Kind");
+ public static final ClassDesc CD_MethodHandleDesc_Kind = new ReferenceClassDescImpl("Ljava/lang/constant/DirectMethodHandleDesc$Kind;");
/** {@link ClassDesc} representing {@link DynamicConstantDesc} */
- public static final ClassDesc CD_DynamicConstantDesc = ClassDesc.of("java.lang.constant.DynamicConstantDesc");
+ public static final ClassDesc CD_DynamicConstantDesc = new ReferenceClassDescImpl("Ljava/lang/constant/DynamicConstantDesc;");
/** {@link ClassDesc} representing {@link DynamicCallSiteDesc} */
- public static final ClassDesc CD_DynamicCallSiteDesc = ClassDesc.of("java.lang.constant.DynamicCallSiteDesc");
+ public static final ClassDesc CD_DynamicCallSiteDesc = new ReferenceClassDescImpl("Ljava/lang/constant/DynamicCallSiteDesc;");
/** {@link ClassDesc} representing {@link ConstantBootstraps} */
- public static final ClassDesc CD_ConstantBootstraps = ClassDesc.of("java.lang.invoke.ConstantBootstraps");
+ public static final ClassDesc CD_ConstantBootstraps = new ReferenceClassDescImpl("Ljava/lang/invoke/ConstantBootstraps;");
private static final ClassDesc[] INDY_BOOTSTRAP_ARGS = {
- ConstantDescs.CD_MethodHandles_Lookup,
- ConstantDescs.CD_String,
- ConstantDescs.CD_MethodType};
+ CD_MethodHandles_Lookup,
+ CD_String,
+ CD_MethodType};
private static final ClassDesc[] CONDY_BOOTSTRAP_ARGS = {
- ConstantDescs.CD_MethodHandles_Lookup,
- ConstantDescs.CD_String,
- ConstantDescs.CD_Class};
+ CD_MethodHandles_Lookup,
+ CD_String,
+ CD_Class};
/** {@link MethodHandleDesc} representing {@link ConstantBootstraps#primitiveClass(Lookup, String, Class) ConstantBootstraps.primitiveClass} */
public static final DirectMethodHandleDesc BSM_PRIMITIVE_CLASS
@@ -236,31 +236,31 @@ private ConstantDescs() { }
CD_Object, CD_Object);
/** {@link ClassDesc} representing the primitive type {@code int} */
- public static final ClassDesc CD_int = ClassDesc.ofDescriptor("I");
+ public static final ClassDesc CD_int = new PrimitiveClassDescImpl("I");
/** {@link ClassDesc} representing the primitive type {@code long} */
- public static final ClassDesc CD_long = ClassDesc.ofDescriptor("J");
+ public static final ClassDesc CD_long = new PrimitiveClassDescImpl("J");
/** {@link ClassDesc} representing the primitive type {@code float} */
- public static final ClassDesc CD_float = ClassDesc.ofDescriptor("F");
+ public static final ClassDesc CD_float = new PrimitiveClassDescImpl("F");
/** {@link ClassDesc} representing the primitive type {@code double} */
- public static final ClassDesc CD_double = ClassDesc.ofDescriptor("D");
+ public static final ClassDesc CD_double = new PrimitiveClassDescImpl("D");
/** {@link ClassDesc} representing the primitive type {@code short} */
- public static final ClassDesc CD_short = ClassDesc.ofDescriptor("S");
+ public static final ClassDesc CD_short = new PrimitiveClassDescImpl("S");
/** {@link ClassDesc} representing the primitive type {@code byte} */
- public static final ClassDesc CD_byte = ClassDesc.ofDescriptor("B");
+ public static final ClassDesc CD_byte = new PrimitiveClassDescImpl("B");
/** {@link ClassDesc} representing the primitive type {@code char} */
- public static final ClassDesc CD_char = ClassDesc.ofDescriptor("C");
+ public static final ClassDesc CD_char = new PrimitiveClassDescImpl("C");
/** {@link ClassDesc} representing the primitive type {@code boolean} */
- public static final ClassDesc CD_boolean = ClassDesc.ofDescriptor("Z");
+ public static final ClassDesc CD_boolean = new PrimitiveClassDescImpl("Z");
/** {@link ClassDesc} representing the primitive type {@code void} */
- public static final ClassDesc CD_void = ClassDesc.ofDescriptor("V");
+ public static final ClassDesc CD_void = new PrimitiveClassDescImpl("V");
/**
* {@link MethodHandleDesc} representing {@link MethodHandles#classData(Lookup, String, Class) MethodHandles.classData}
diff --git a/src/java.base/share/classes/java/lang/constant/ConstantUtils.java b/src/java.base/share/classes/java/lang/constant/ConstantUtils.java
index 10ed2758e3a..d8a1ccd543b 100644
--- a/src/java.base/share/classes/java/lang/constant/ConstantUtils.java
+++ b/src/java.base/share/classes/java/lang/constant/ConstantUtils.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -24,6 +24,8 @@
*/
package java.lang.constant;
+import sun.invoke.util.Wrapper;
+
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
@@ -144,7 +146,6 @@ public static String validateModuleName(String name) {
* @throws IllegalArgumentException if the member name is invalid
*/
public static String validateMemberName(String name, boolean method) {
- requireNonNull(name);
if (name.length() == 0)
throw new IllegalArgumentException("zero-length member name");
for (int i=0; i parseMethodDescriptor(String descriptor) {
+ static List parseMethodDescriptor(String descriptor) {
int cur = 0, end = descriptor.length();
- ArrayList ptypes = new ArrayList<>();
- ptypes.add(null); //placeholder for return type
+ ArrayList ptypes = new ArrayList<>();
+ ptypes.add(null); // placeholder for return type
if (cur >= end || descriptor.charAt(cur) != '(')
throw new IllegalArgumentException("Bad method descriptor: " + descriptor);
@@ -208,7 +209,7 @@ static List parseMethodDescriptor(String descriptor) {
int len = skipOverFieldSignature(descriptor, cur, end, false);
if (len == 0)
throw new IllegalArgumentException("Bad method descriptor: " + descriptor);
- ptypes.add(descriptor.substring(cur, cur + len));
+ ptypes.add(resolveClassDesc(descriptor, cur, len));
cur += len;
}
if (cur >= end)
@@ -218,10 +219,17 @@ static List parseMethodDescriptor(String descriptor) {
int rLen = skipOverFieldSignature(descriptor, cur, end, true);
if (rLen == 0 || cur + rLen != end)
throw new IllegalArgumentException("Bad method descriptor: " + descriptor);
- ptypes.set(0, descriptor.substring(cur, cur + rLen));
+ ptypes.set(0, resolveClassDesc(descriptor, cur, rLen));
return ptypes;
}
+ private static ClassDesc resolveClassDesc(String descriptor, int start, int len) {
+ if (len == 1) {
+ return Wrapper.forPrimitiveType(descriptor.charAt(start)).classDescriptor();
+ }
+ return ClassDesc.ofDescriptor(descriptor.substring(start, start + len));
+ }
+
private static final char JVM_SIGNATURE_ARRAY = '[';
private static final char JVM_SIGNATURE_BYTE = 'B';
private static final char JVM_SIGNATURE_CHAR = 'C';
diff --git a/src/java.base/share/classes/java/lang/constant/DirectMethodHandleDescImpl.java b/src/java.base/share/classes/java/lang/constant/DirectMethodHandleDescImpl.java
index 77f61d83133..47aa3dc36d2 100644
--- a/src/java.base/share/classes/java/lang/constant/DirectMethodHandleDescImpl.java
+++ b/src/java.base/share/classes/java/lang/constant/DirectMethodHandleDescImpl.java
@@ -67,8 +67,8 @@ final class DirectMethodHandleDescImpl implements DirectMethodHandleDesc {
name = "";
requireNonNull(kind);
- validateClassOrInterface(requireNonNull(owner));
- validateMemberName(requireNonNull(name), true);
+ validateClassOrInterface(owner);
+ validateMemberName(name, true);
requireNonNull(type);
switch (kind) {
diff --git a/src/java.base/share/classes/java/lang/constant/DynamicConstantDesc.java b/src/java.base/share/classes/java/lang/constant/DynamicConstantDesc.java
index bf6ae2670b1..180841cd798 100644
--- a/src/java.base/share/classes/java/lang/constant/DynamicConstantDesc.java
+++ b/src/java.base/share/classes/java/lang/constant/DynamicConstantDesc.java
@@ -87,12 +87,9 @@ protected DynamicConstantDesc(DirectMethodHandleDesc bootstrapMethod,
ClassDesc constantType,
ConstantDesc... bootstrapArgs) {
this.bootstrapMethod = requireNonNull(bootstrapMethod);
- this.constantName = validateMemberName(requireNonNull(constantName), true);
+ this.constantName = validateMemberName(constantName, true);
this.constantType = requireNonNull(constantType);
- this.bootstrapArgs = requireNonNull(bootstrapArgs).clone();
-
- if (constantName.length() == 0)
- throw new IllegalArgumentException("Illegal invocation name: " + constantName);
+ this.bootstrapArgs = bootstrapArgs.length == 0 ? EMPTY_CONSTANTDESC : bootstrapArgs.clone();
}
/**
diff --git a/src/java.base/share/classes/java/lang/constant/MethodTypeDescImpl.java b/src/java.base/share/classes/java/lang/constant/MethodTypeDescImpl.java
index c50cf7c58f0..7ee0995439a 100644
--- a/src/java.base/share/classes/java/lang/constant/MethodTypeDescImpl.java
+++ b/src/java.base/share/classes/java/lang/constant/MethodTypeDescImpl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -33,7 +33,6 @@
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
-import java.util.StringJoiner;
import static java.util.Objects.requireNonNull;
@@ -55,8 +54,8 @@ final class MethodTypeDescImpl implements MethodTypeDesc {
* @param validatedArgTypes {@link ClassDesc}s describing the trusted and validated parameter types
*/
private MethodTypeDescImpl(ClassDesc returnType, ClassDesc[] validatedArgTypes) {
- this.returnType = requireNonNull(returnType);
- this.argTypes = requireNonNull(validatedArgTypes);
+ this.returnType = returnType;
+ this.argTypes = validatedArgTypes;
}
/**
@@ -67,12 +66,12 @@ private MethodTypeDescImpl(ClassDesc returnType, ClassDesc[] validatedArgTypes)
* @param trustedArgTypes {@link ClassDesc}s describing the trusted parameter types
*/
static MethodTypeDescImpl ofTrusted(ClassDesc returnType, ClassDesc[] trustedArgTypes) {
- Objects.requireNonNull(returnType);
+ requireNonNull(returnType);
if (trustedArgTypes.length == 0) // implicit null check
return new MethodTypeDescImpl(returnType, ConstantUtils.EMPTY_CLASSDESC);
for (ClassDesc cd : trustedArgTypes)
- if (cd.isPrimitive() && cd.descriptorString().charAt(0) == 'V') // implicit null check
+ if (cd.descriptorString().charAt(0) == 'V') // implicit null check
throw new IllegalArgumentException("Void parameters not permitted");
return new MethodTypeDescImpl(returnType, trustedArgTypes);
@@ -88,21 +87,19 @@ static MethodTypeDescImpl ofTrusted(ClassDesc returnType, ClassDesc[] trustedArg
* @jvms 4.3.3 Method Descriptors
*/
static MethodTypeDescImpl ofDescriptor(String descriptor) {
- requireNonNull(descriptor);
-
- List types = ConstantUtils.parseMethodDescriptor(descriptor);
-
- int paramCount = types.size() - 1;
- var paramTypes = paramCount > 0 ? new ClassDesc[paramCount] : ConstantUtils.EMPTY_CLASSDESC;
- for (int i = 0; i < paramCount; i++) {
- paramTypes[i] = ClassDesc.ofDescriptor(types.get(i + 1));
- }
-
- MethodTypeDescImpl result = ofTrusted(ClassDesc.ofDescriptor(types.getFirst()), paramTypes);
+ // Implicit null-check of descriptor
+ List ptypes = ConstantUtils.parseMethodDescriptor(descriptor);
+ int args = ptypes.size() - 1;
+ ClassDesc[] paramTypes = args > 0
+ ? ptypes.subList(1, args + 1).toArray(ConstantUtils.EMPTY_CLASSDESC)
+ : ConstantUtils.EMPTY_CLASSDESC;
+
+ MethodTypeDescImpl result = ofTrusted(ptypes.get(0), paramTypes);
result.cachedDescriptorString = descriptor;
return result;
}
+
@Override
public ClassDesc returnType() {
return returnType;
@@ -130,7 +127,7 @@ public ClassDesc[] parameterArray() {
@Override
public MethodTypeDesc changeReturnType(ClassDesc returnType) {
- return new MethodTypeDescImpl(returnType, argTypes);
+ return new MethodTypeDescImpl(requireNonNull(returnType), argTypes);
}
@Override
@@ -146,8 +143,12 @@ public MethodTypeDesc dropParameterTypes(int start, int end) {
Objects.checkFromToIndex(start, end, argTypes.length);
ClassDesc[] newArgs = new ClassDesc[argTypes.length - (end - start)];
- System.arraycopy(argTypes, 0, newArgs, 0, start);
- System.arraycopy(argTypes, end, newArgs, start, argTypes.length - end);
+ if (start > 0) {
+ System.arraycopy(argTypes, 0, newArgs, 0, start);
+ }
+ if (end < argTypes.length) {
+ System.arraycopy(argTypes, end, newArgs, start, argTypes.length - end);
+ }
return ofTrusted(returnType, newArgs);
}
@@ -157,10 +158,13 @@ public MethodTypeDesc insertParameterTypes(int pos, ClassDesc... paramTypes) {
throw new IndexOutOfBoundsException(pos);
ClassDesc[] newArgs = new ClassDesc[argTypes.length + paramTypes.length];
- System.arraycopy(argTypes, 0, newArgs, 0, pos);
+ if (pos > 0) {
+ System.arraycopy(argTypes, 0, newArgs, 0, pos);
+ }
System.arraycopy(paramTypes, 0, newArgs, pos, paramTypes.length);
- System.arraycopy(argTypes, pos, newArgs, pos+paramTypes.length, argTypes.length - pos);
-
+ if (pos < argTypes.length) {
+ System.arraycopy(argTypes, pos, newArgs, pos + paramTypes.length, argTypes.length - pos);
+ }
return ofTrusted(returnType, newArgs);
}
@@ -170,11 +174,17 @@ public String descriptorString() {
if (desc != null)
return desc;
- var sj = new StringJoiner("", "(", ")" + returnType().descriptorString());
- for (int i = 0; i < parameterCount(); i++) {
- sj.add(parameterType(i).descriptorString());
+ int len = 2 + returnType.descriptorString().length();
+ for (ClassDesc argType : argTypes) {
+ len += argType.descriptorString().length();
+ }
+ StringBuilder sb = new StringBuilder(len).append('(');
+ for (ClassDesc argType : argTypes) {
+ sb.append(argType.descriptorString());
}
- return cachedDescriptorString = sj.toString();
+ desc = sb.append(')').append(returnType.descriptorString()).toString();
+ cachedDescriptorString = desc;
+ return desc;
}
@Override
diff --git a/src/java.base/share/classes/java/lang/constant/ReferenceClassDescImpl.java b/src/java.base/share/classes/java/lang/constant/ReferenceClassDescImpl.java
index 4cc77b1851d..5e2aaa98442 100644
--- a/src/java.base/share/classes/java/lang/constant/ReferenceClassDescImpl.java
+++ b/src/java.base/share/classes/java/lang/constant/ReferenceClassDescImpl.java
@@ -47,10 +47,9 @@ final class ReferenceClassDescImpl implements ClassDesc {
* @jvms 4.3.2 Field Descriptors
*/
ReferenceClassDescImpl(String descriptor) {
- requireNonNull(descriptor);
- int len = ConstantUtils.skipOverFieldSignature(descriptor, 0, descriptor.length(), false);
- if (len == 0 || len == 1
- || len != descriptor.length())
+ int dLen = descriptor.length();
+ int len = ConstantUtils.skipOverFieldSignature(descriptor, 0, dLen, false);
+ if (len <= 1 || len != dLen)
throw new IllegalArgumentException(String.format("not a valid reference type descriptor: %s", descriptor));
this.descriptor = descriptor;
}
diff --git a/src/java.base/share/classes/java/lang/invoke/StringConcatFactory.java b/src/java.base/share/classes/java/lang/invoke/StringConcatFactory.java
index b918b756332..cd2f7ec170a 100644
--- a/src/java.base/share/classes/java/lang/invoke/StringConcatFactory.java
+++ b/src/java.base/share/classes/java/lang/invoke/StringConcatFactory.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2015, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -27,16 +27,25 @@
import jdk.internal.access.JavaLangAccess;
import jdk.internal.access.SharedSecrets;
-import jdk.internal.javac.PreviewFeature;
+import jdk.internal.misc.VM;
+import jdk.internal.util.ClassFileDumper;
import jdk.internal.vm.annotation.Stable;
import sun.invoke.util.Wrapper;
+import java.lang.classfile.ClassBuilder;
+import java.lang.classfile.ClassFile;
+import java.lang.classfile.CodeBuilder;
+import java.lang.classfile.TypeKind;
+import java.lang.constant.ClassDesc;
+import java.lang.constant.ConstantDescs;
+import java.lang.constant.MethodTypeDesc;
import java.lang.invoke.MethodHandles.Lookup;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
+import java.lang.reflect.AccessFlag;
import java.util.Objects;
+import java.util.Set;
+import java.util.function.Consumer;
+import static java.lang.invoke.MethodHandles.Lookup.ClassOption.STRONG;
import static java.lang.invoke.MethodType.methodType;
/**
@@ -98,6 +107,13 @@
*/
public final class StringConcatFactory {
+ private static final int HIGH_ARITY_THRESHOLD;
+
+ static {
+ String highArity = VM.getSavedProperty("java.lang.invoke.StringConcat.highArityThreshold");
+ HIGH_ARITY_THRESHOLD = highArity != null ? Integer.parseInt(highArity) : 20;
+ }
+
/**
* Tag used to demarcate an ordinary argument.
*/
@@ -354,9 +370,14 @@ public static CallSite makeConcatWithConstants(MethodHandles.Lookup lookup,
}
try {
- return new ConstantCallSite(
- generateMHInlineCopy(concatType, constantStrings)
- .viewAsType(concatType, true));
+ if (concatType.parameterCount() <= HIGH_ARITY_THRESHOLD) {
+ return new ConstantCallSite(
+ generateMHInlineCopy(concatType, constantStrings)
+ .viewAsType(concatType, true));
+ } else {
+ return new ConstantCallSite(
+ SimpleStringBuilderStrategy.generate(lookup, concatType, constantStrings));
+ }
} catch (Error e) {
// Pass through any error
throw e;
@@ -1032,4 +1053,140 @@ private StringConcatFactory() {
// no instantiation
}
+ /**
+ * Bytecode StringBuilder strategy.
+ *
+ * This strategy emits StringBuilder chains as similar as possible
+ * to what javac would. No exact sizing of parameters or estimates.
+ */
+ private static final class SimpleStringBuilderStrategy {
+ static final String METHOD_NAME = "concat";
+ static final ClassDesc STRING_BUILDER = ClassDesc.ofDescriptor("Ljava/lang/StringBuilder;");
+ static final ClassFileDumper DUMPER =
+ ClassFileDumper.getInstance("java.lang.invoke.StringConcatFactory.dump", "stringConcatClasses");
+ static final MethodTypeDesc APPEND_BOOLEAN_TYPE = MethodTypeDesc.of(STRING_BUILDER, ConstantDescs.CD_boolean);
+ static final MethodTypeDesc APPEND_CHAR_TYPE = MethodTypeDesc.of(STRING_BUILDER, ConstantDescs.CD_char);
+ static final MethodTypeDesc APPEND_DOUBLE_TYPE = MethodTypeDesc.of(STRING_BUILDER, ConstantDescs.CD_double);
+ static final MethodTypeDesc APPEND_FLOAT_TYPE = MethodTypeDesc.of(STRING_BUILDER, ConstantDescs.CD_float);
+ static final MethodTypeDesc APPEND_INT_TYPE = MethodTypeDesc.of(STRING_BUILDER, ConstantDescs.CD_int);
+ static final MethodTypeDesc APPEND_LONG_TYPE = MethodTypeDesc.of(STRING_BUILDER, ConstantDescs.CD_long);
+ static final MethodTypeDesc APPEND_OBJECT_TYPE = MethodTypeDesc.of(STRING_BUILDER, ConstantDescs.CD_Object);
+ static final MethodTypeDesc APPEND_STRING_TYPE = MethodTypeDesc.of(STRING_BUILDER, ConstantDescs.CD_String);
+ static final MethodTypeDesc INT_CONSTRUCTOR_TYPE = MethodTypeDesc.of(ConstantDescs.CD_void, ConstantDescs.CD_int);
+ static final MethodTypeDesc TO_STRING_TYPE = MethodTypeDesc.of(ConstantDescs.CD_String);
+
+ /**
+ * Ensure a capacity in the initial StringBuilder to accommodate all
+ * constants plus this factor times the number of arguments.
+ */
+ static final int ARGUMENT_SIZE_FACTOR = 4;
+
+ static final Set SET_OF_STRONG = Set.of(STRONG);
+
+ private SimpleStringBuilderStrategy() {
+ // no instantiation
+ }
+
+ private static MethodHandle generate(Lookup lookup, MethodType args, String[] constants) throws Exception {
+ String className = getClassName(lookup.lookupClass());
+
+ byte[] classBytes = ClassFile.of().build(ClassDesc.of(className),
+ new Consumer() {
+ @Override
+ public void accept(ClassBuilder clb) {
+ clb.withFlags(AccessFlag.FINAL, AccessFlag.SUPER, AccessFlag.SYNTHETIC)
+ .withMethodBody(METHOD_NAME,
+ MethodTypeDesc.ofDescriptor(args.toMethodDescriptorString()),
+ ClassFile.ACC_FINAL | ClassFile.ACC_PRIVATE | ClassFile.ACC_STATIC,
+ generateMethod(constants, args));
+ }});
+ try {
+ Lookup hiddenLookup = lookup.makeHiddenClassDefiner(className, classBytes, SET_OF_STRONG, DUMPER)
+ .defineClassAsLookup(true);
+ Class innerClass = hiddenLookup.lookupClass();
+ return hiddenLookup.findStatic(innerClass, METHOD_NAME, args);
+ } catch (Exception e) {
+ throw new StringConcatException("Exception while spinning the class", e);
+ }
+ }
+
+ private static Consumer generateMethod(String[] constants, MethodType args) {
+ return new Consumer() {
+ @Override
+ public void accept(CodeBuilder cb) {
+ cb.new_(STRING_BUILDER);
+ cb.dup();
+
+ int len = 0;
+ for (String constant : constants) {
+ if (constant != null) {
+ len += constant.length();
+ }
+ }
+ len += args.parameterCount() * ARGUMENT_SIZE_FACTOR;
+ cb.constantInstruction(len);
+ cb.invokespecial(STRING_BUILDER, "", INT_CONSTRUCTOR_TYPE);
+
+ // At this point, we have a blank StringBuilder on stack, fill it in with .append calls.
+ {
+ int off = 0;
+ for (int c = 0; c < args.parameterCount(); c++) {
+ if (constants[c] != null) {
+ cb.ldc(constants[c]);
+ cb.invokevirtual(STRING_BUILDER, "append", APPEND_STRING_TYPE);
+ }
+ Class cl = args.parameterType(c);
+ TypeKind kind = TypeKind.from(cl);
+ cb.loadInstruction(kind, off);
+ off += kind.slotSize();
+ MethodTypeDesc desc = getSBAppendDesc(cl);
+ cb.invokevirtual(STRING_BUILDER, "append", desc);
+ }
+ if (constants[constants.length - 1] != null) {
+ cb.ldc(constants[constants.length - 1]);
+ cb.invokevirtual(STRING_BUILDER, "append", APPEND_STRING_TYPE);
+ }
+ }
+
+ cb.invokevirtual(STRING_BUILDER, "toString", TO_STRING_TYPE);
+ cb.areturn();
+ }
+ };
+ }
+
+ /**
+ * The generated class is in the same package as the host class as
+ * it's the implementation of the string concatenation for the host
+ * class.
+ */
+ private static String getClassName(Class hostClass) {
+ String name = hostClass.isHidden() ? hostClass.getName().replace('/', '_')
+ : hostClass.getName();
+ return name + "$$StringConcat";
+ }
+
+ private static MethodTypeDesc getSBAppendDesc(Class cl) {
+ if (cl.isPrimitive()) {
+ if (cl == Integer.TYPE || cl == Byte.TYPE || cl == Short.TYPE) {
+ return APPEND_INT_TYPE;
+ } else if (cl == Boolean.TYPE) {
+ return APPEND_BOOLEAN_TYPE;
+ } else if (cl == Character.TYPE) {
+ return APPEND_CHAR_TYPE;
+ } else if (cl == Double.TYPE) {
+ return APPEND_DOUBLE_TYPE;
+ } else if (cl == Float.TYPE) {
+ return APPEND_FLOAT_TYPE;
+ } else if (cl == Long.TYPE) {
+ return APPEND_LONG_TYPE;
+ } else {
+ throw new IllegalStateException("Unhandled primitive StringBuilder.append: " + cl);
+ }
+ } else if (cl == String.class) {
+ return APPEND_STRING_TYPE;
+ } else {
+ return APPEND_OBJECT_TYPE;
+ }
+ }
+ }
}
diff --git a/src/java.base/share/classes/java/text/DateFormat.java b/src/java.base/share/classes/java/text/DateFormat.java
index d7a4b5a39b7..a67ba676836 100644
--- a/src/java.base/share/classes/java/text/DateFormat.java
+++ b/src/java.base/share/classes/java/text/DateFormat.java
@@ -407,7 +407,8 @@ public Date parse(String source) throws ParseException
/**
* Parse a date/time string according to the given parse position. For
- * example, a time text {@code "07/10/96 4:5 PM, PDT"} will be parsed into a {@code Date}
+ * example, if {@code this} has the pattern {@code "M/d/yy h:m a, z"},
+ * then a time text {@code "07/10/96 4:5 PM, PDT"} will be parsed into a {@code Date}
* that is equivalent to {@code Date(837039900000L)}.
*
* By default, parsing is lenient: If the input is not in the form used
diff --git a/src/java.base/share/classes/java/util/concurrent/AbstractExecutorService.java b/src/java.base/share/classes/java/util/concurrent/AbstractExecutorService.java
index f45c0036230..1b1ba4b29a0 100644
--- a/src/java.base/share/classes/java/util/concurrent/AbstractExecutorService.java
+++ b/src/java.base/share/classes/java/util/concurrent/AbstractExecutorService.java
@@ -117,6 +117,7 @@ protected RunnableFuture newTaskFor(Callable callable) {
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
+ @Override
public Future submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture ftask = newTaskFor(task, null);
@@ -128,6 +129,7 @@ public Future submit(Runnable task) {
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
+ @Override
public Future submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture ftask = newTaskFor(task, result);
@@ -139,6 +141,7 @@ public Future submit(Runnable task, T result) {
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
+ @Override
public Future submit(Callable task) {
if (task == null) throw new NullPointerException();
RunnableFuture ftask = newTaskFor(task);
@@ -219,6 +222,14 @@ else if (timed) {
}
}
+ /**
+ * @throws InterruptedException {@inheritDoc}
+ * @throws NullPointerException {@inheritDoc}
+ * @throws IllegalArgumentException {@inheritDoc}
+ * @throws ExecutionException {@inheritDoc}
+ * @throws RejectedExecutionException {@inheritDoc}
+ */
+ @Override
public T invokeAny(Collection> tasks)
throws InterruptedException, ExecutionException {
try {
@@ -229,12 +240,26 @@ public T invokeAny(Collection> tasks)
}
}
+ /**
+ * @throws InterruptedException {@inheritDoc}
+ * @throws NullPointerException {@inheritDoc}
+ * @throws TimeoutException {@inheritDoc}
+ * @throws ExecutionException {@inheritDoc}
+ * @throws RejectedExecutionException {@inheritDoc}
+ */
+ @Override
public T invokeAny(Collection> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
return doInvokeAny(tasks, true, unit.toNanos(timeout));
}
+ /**
+ * @throws InterruptedException {@inheritDoc}
+ * @throws NullPointerException {@inheritDoc}
+ * @throws RejectedExecutionException {@inheritDoc}
+ */
+ @Override
public List> invokeAll(Collection> tasks)
throws InterruptedException {
if (tasks == null)
@@ -260,6 +285,12 @@ public List> invokeAll(Collection> tasks)
}
}
+ /**
+ * @throws InterruptedException {@inheritDoc}
+ * @throws NullPointerException {@inheritDoc}
+ * @throws RejectedExecutionException {@inheritDoc}
+ */
+ @Override
public List> invokeAll(Collection> tasks,
long timeout, TimeUnit unit)
throws InterruptedException {
diff --git a/src/java.base/share/classes/java/util/spi/LocaleServiceProvider.java b/src/java.base/share/classes/java/util/spi/LocaleServiceProvider.java
index 86aa580b619..2bf0c711cfe 100644
--- a/src/java.base/share/classes/java/util/spi/LocaleServiceProvider.java
+++ b/src/java.base/share/classes/java/util/spi/LocaleServiceProvider.java
@@ -159,6 +159,8 @@
* CLDR version
*
*
+ * JDK 23
+ * CLDR 45 JDK 22
* CLDR 44 JDK 21
diff --git a/src/java.base/share/classes/jdk/internal/classfile/impl/ClassReaderImpl.java b/src/java.base/share/classes/jdk/internal/classfile/impl/ClassReaderImpl.java
index 9b6c7d7ad4c..2022f8f0154 100644
--- a/src/java.base/share/classes/jdk/internal/classfile/impl/ClassReaderImpl.java
+++ b/src/java.base/share/classes/jdk/internal/classfile/impl/ClassReaderImpl.java
@@ -150,7 +150,7 @@ public int flags() {
@Override
public ClassEntry thisClassEntry() {
if (thisClass == null) {
- thisClass = readEntry(thisClassPos, ClassEntry.class);
+ thisClass = readClassEntry(thisClassPos);
}
return thisClass;
}
@@ -339,6 +339,10 @@ void writeConstantPoolEntries(BufWriter buf) {
// Constantpool
@Override
public PoolEntry entryByIndex(int index) {
+ return entryByIndex(index, 0, 0xff);
+ }
+
+ private PoolEntry entryByIndex(int index, int lowerBoundTag, int upperBoundTag) {
if (index <= 0 || index >= constantPoolCount) {
throw new ConstantPoolException("Bad CP index: " + index);
}
@@ -349,6 +353,10 @@ public PoolEntry entryByIndex(int index) {
throw new ConstantPoolException("Unusable CP index: " + index);
}
int tag = readU1(offset);
+ if (tag < lowerBoundTag || tag > upperBoundTag) {
+ throw new ConstantPoolException(
+ "Bad tag (" + tag + ") at index (" + index + ") position (" + offset + ")");
+ }
final int q = offset + 1;
info = switch (tag) {
case TAG_UTF8 -> new AbstractPoolEntry.Utf8EntryImpl(this, index, buffer, q + 2, readU2(q));
@@ -367,7 +375,7 @@ public PoolEntry entryByIndex(int index) {
case TAG_NAMEANDTYPE -> new AbstractPoolEntry.NameAndTypeEntryImpl(this, index, (AbstractPoolEntry.Utf8EntryImpl) readUtf8Entry(q),
(AbstractPoolEntry.Utf8EntryImpl) readUtf8Entry(q + 2));
case TAG_METHODHANDLE -> new AbstractPoolEntry.MethodHandleEntryImpl(this, index, readU1(q),
- (AbstractPoolEntry.AbstractMemberRefEntry) readEntry(q + 1));
+ readEntry(q + 1, AbstractPoolEntry.AbstractMemberRefEntry.class, TAG_FIELDREF, TAG_INTERFACEMETHODREF));
case TAG_METHODTYPE -> new AbstractPoolEntry.MethodTypeEntryImpl(this, index, (AbstractPoolEntry.Utf8EntryImpl) readUtf8Entry(q));
case TAG_CONSTANTDYNAMIC -> new AbstractPoolEntry.ConstantDynamicEntryImpl(this, index, readU2(q), (AbstractPoolEntry.NameAndTypeEntryImpl) readNameAndTypeEntry(q + 2));
case TAG_INVOKEDYNAMIC -> new AbstractPoolEntry.InvokeDynamicEntryImpl(this, index, readU2(q), (AbstractPoolEntry.NameAndTypeEntryImpl) readNameAndTypeEntry(q + 2));
@@ -423,7 +431,15 @@ public PoolEntry readEntry(int pos) {
@Override
public T readEntry(int pos, Class cls) {
- var e = readEntry(pos);
+ return readEntry(pos, cls, 0, 0xff);
+ }
+
+ private T readEntry(int pos, Class cls, int expectedTag) {
+ return readEntry(pos, cls, expectedTag, expectedTag);
+ }
+
+ private T readEntry(int pos, Class cls, int lowerBoundTag, int upperBoundTag) {
+ var e = entryByIndex(readU2(pos), lowerBoundTag, upperBoundTag);
if (cls.isInstance(e)) return cls.cast(e);
throw new ConstantPoolException("Not a " + cls.getSimpleName() + " at index: " + readU2(pos));
}
@@ -454,27 +470,27 @@ public Utf8Entry readUtf8EntryOrNull(int pos) {
@Override
public ModuleEntry readModuleEntry(int pos) {
- return readEntry(pos, ModuleEntry.class);
+ return readEntry(pos, ModuleEntry.class, TAG_MODULE);
}
@Override
public PackageEntry readPackageEntry(int pos) {
- return readEntry(pos, PackageEntry.class);
+ return readEntry(pos, PackageEntry.class, TAG_PACKAGE);
}
@Override
public ClassEntry readClassEntry(int pos) {
- return readEntry(pos, ClassEntry.class);
+ return readEntry(pos, ClassEntry.class, TAG_CLASS);
}
@Override
public NameAndTypeEntry readNameAndTypeEntry(int pos) {
- return readEntry(pos, NameAndTypeEntry.class);
+ return readEntry(pos, NameAndTypeEntry.class, TAG_NAMEANDTYPE);
}
@Override
public MethodHandleEntry readMethodHandleEntry(int pos) {
- return readEntry(pos, MethodHandleEntry.class);
+ return readEntry(pos, MethodHandleEntry.class, TAG_METHODHANDLE);
}
@Override
diff --git a/src/java.base/share/classes/jdk/internal/event/FileForceEvent.java b/src/java.base/share/classes/jdk/internal/event/FileForceEvent.java
new file mode 100644
index 00000000000..f6dec6c8a5e
--- /dev/null
+++ b/src/java.base/share/classes/jdk/internal/event/FileForceEvent.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.internal.event;
+
+/**
+ * A JFR event for forced updates written to files. This event is mirrored in
+ * {@code jdk.jfr.events.FileForceEvent } where the event annotations are
+ * provided. Some of the methods are replaced by generated
+ * methods when jfr is enabled. Note that the order of the arguments of the
+ * {@link #commit(long, long, String, boolean)} method
+ * must be the same as the order of the fields.
+ */
+public class FileForceEvent extends Event {
+
+ // THE ORDER OF THE FOLLOWING FIELDS IS IMPORTANT!
+ // The order must match the argument order of the generated commit method.
+ public String path;
+ public boolean metaData;
+
+ /**
+ * Helper method to offer the data needed to potentially commit an event.
+ * The duration of the operation is computed using the current
+ * timestamp and the given start time. If the duration is meets
+ * or exceeds the configured value (determined by calling the generated method
+ * {@link #shouldCommit(long)}), an event will be emitted by calling
+ * {@link #commit(long, long, String, boolean)}.
+ *
+ * @param start timestamp of the start of the operation
+ * @param path the full pathname of the file
+ * @param metaData true if the file metadata is updated
+ */
+ public static void offer(long start, String path, boolean metaData) {
+ long duration = timestamp() - start;
+ if (shouldCommit(duration)) {
+ commit(start, duration, path, metaData);
+ }
+ }
+
+ /**
+ * Actually commit an event. The implementation is generated automatically.
+ * The order of the fields must be the same as the parameters in this method.
+ *
+ * @param start timestamp of the start of the operation
+ * @param duration time in nanoseconds to complete the operation
+ * @param path the full pathname of the file
+ * @param metaData true if the file metadata is updated
+ */
+ public static void commit(long start, long duration, String path, boolean metaData) {
+ // Generated by JFR
+ }
+
+ /**
+ * Determine if an event should be emitted. The duration of the operation
+ * must exceed some threshold in order to commit the event. The implementation
+ * of this method is generated automatically if jfr is enabled.
+ *
+ * @param duration time in nanoseconds to complete the operation
+ * @return true if the event should be commited
+ */
+ public static boolean shouldCommit(long duration) {
+ // Generated by JFR
+ return false;
+ }
+
+ /**
+ * Determine if this kind of event is enabled. The implementation
+ * of this method is generated automatically if jfr is enabled.
+ *
+ * @return true if this type of event is enabled, false otherwise
+ */
+ public static boolean enabled() {
+ // Generated by JFR
+ return false;
+ }
+
+ /**
+ * Fetch the current timestamp in nanoseconds. This method is used
+ * to determine the start and end of an operation. The implementation
+ * of this method is generated automatically if jfr is enabled.
+ *
+ * @return the current timestamp value
+ */
+ public static long timestamp() {
+ // Generated by JFR
+ return 0L;
+ }
+}
diff --git a/src/java.base/share/classes/jdk/internal/javac/PreviewFeature.java b/src/java.base/share/classes/jdk/internal/javac/PreviewFeature.java
index c24a58f0230..cfccff7dd93 100644
--- a/src/java.base/share/classes/jdk/internal/javac/PreviewFeature.java
+++ b/src/java.base/share/classes/jdk/internal/javac/PreviewFeature.java
@@ -79,7 +79,7 @@ public enum Feature {
STRUCTURED_CONCURRENCY,
@JEP(number=466, title="ClassFile API", status="Second Preview")
CLASSFILE_API,
- @JEP(number=461, title="Stream Gatherers", status="Preview")
+ @JEP(number=473, title="Stream Gatherers", status="Second Preview")
STREAM_GATHERERS,
LANGUAGE_MODEL,
/**
diff --git a/src/java.base/share/classes/jdk/internal/util/ArraysSupport.java b/src/java.base/share/classes/jdk/internal/util/ArraysSupport.java
index 61be28519fc..8f8ea651d65 100644
--- a/src/java.base/share/classes/jdk/internal/util/ArraysSupport.java
+++ b/src/java.base/share/classes/jdk/internal/util/ArraysSupport.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -200,7 +200,7 @@ public static int vectorizedMismatch(Object a, long aOffset,
public static int vectorizedHashCode(Object array, int fromIndex, int length, int initialValue,
int basicType) {
return switch (basicType) {
- case T_BOOLEAN -> signedHashCode(initialValue, (byte[]) array, fromIndex, length);
+ case T_BOOLEAN -> unsignedHashCode(initialValue, (byte[]) array, fromIndex, length);
case T_CHAR -> array instanceof byte[]
? utf16hashCode(initialValue, (byte[]) array, fromIndex, length)
: hashCode(initialValue, (char[]) array, fromIndex, length);
@@ -211,7 +211,7 @@ public static int vectorizedHashCode(Object array, int fromIndex, int length, in
};
}
- private static int signedHashCode(int result, byte[] a, int fromIndex, int length) {
+ private static int unsignedHashCode(int result, byte[] a, int fromIndex, int length) {
int end = fromIndex + length;
for (int i = fromIndex; i < end; i++) {
result = 31 * result + (a[i] & 0xff);
diff --git a/src/java.base/share/classes/sun/invoke/util/Wrapper.java b/src/java.base/share/classes/sun/invoke/util/Wrapper.java
index 76aede09487..fef9192932d 100644
--- a/src/java.base/share/classes/sun/invoke/util/Wrapper.java
+++ b/src/java.base/share/classes/sun/invoke/util/Wrapper.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2008, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -25,25 +25,27 @@
package sun.invoke.util;
-import java.util.Map;
import static sun.invoke.util.Wrapper.NumericClasses.*;
import jdk.internal.vm.annotation.DontInline;
+import java.lang.constant.ClassDesc;
+import java.lang.constant.ConstantDescs;
+
public enum Wrapper {
- // wrapperType simple primitiveType simple char emptyArray format numericClass superClass
- BOOLEAN( Boolean.class, "Boolean", boolean.class, "boolean", 'Z', new boolean[0], Format.unsigned( 1), 0, 0),
+ // wrapperType simple primitiveType simple char emptyArray format numericClass superClass classDescriptor
+ BOOLEAN( Boolean.class, "Boolean", boolean.class, "boolean", 'Z', new boolean[0], Format.unsigned( 1), 0, 0, ConstantDescs.CD_boolean),
// These must be in the order defined for widening primitive conversions in JLS 5.1.2
// Avoid boxing integral types here to defer initialization of internal caches
- BYTE ( Byte.class, "Byte", byte.class, "byte", 'B', new byte[0], Format.signed( 8), BYTE_CLASS, BYTE_SUPERCLASSES),
- SHORT ( Short.class, "Short", short.class, "short", 'S', new short[0], Format.signed( 16), SHORT_CLASS, SHORT_SUPERCLASSES),
- CHAR (Character.class, "Character", char.class, "char", 'C', new char[0], Format.unsigned(16), CHAR_CLASS, CHAR_SUPERCLASSES),
- INT ( Integer.class, "Integer", int.class, "int", 'I', new int[0], Format.signed( 32), INT_CLASS, INT_SUPERCLASSES),
- LONG ( Long.class, "Long", long.class, "long", 'J', new long[0], Format.signed( 64), LONG_CLASS, LONG_SUPERCLASSES),
- FLOAT ( Float.class, "Float", float.class, "float", 'F', new float[0], Format.floating(32), FLOAT_CLASS, FLOAT_SUPERCLASSES),
- DOUBLE ( Double.class, "Double", double.class, "double", 'D', new double[0], Format.floating(64), DOUBLE_CLASS, DOUBLE_CLASS),
- OBJECT ( Object.class, "Object", Object.class, "Object", 'L', new Object[0], Format.other( 1), 0, 0),
+ BYTE ( Byte.class, "Byte", byte.class, "byte", 'B', new byte[0], Format.signed( 8), BYTE_CLASS, BYTE_SUPERCLASSES, ConstantDescs.CD_byte),
+ SHORT ( Short.class, "Short", short.class, "short", 'S', new short[0], Format.signed( 16), SHORT_CLASS, SHORT_SUPERCLASSES, ConstantDescs.CD_short),
+ CHAR (Character.class, "Character", char.class, "char", 'C', new char[0], Format.unsigned(16), CHAR_CLASS, CHAR_SUPERCLASSES, ConstantDescs.CD_char),
+ INT ( Integer.class, "Integer", int.class, "int", 'I', new int[0], Format.signed( 32), INT_CLASS, INT_SUPERCLASSES, ConstantDescs.CD_int),
+ LONG ( Long.class, "Long", long.class, "long", 'J', new long[0], Format.signed( 64), LONG_CLASS, LONG_SUPERCLASSES, ConstantDescs.CD_long),
+ FLOAT ( Float.class, "Float", float.class, "float", 'F', new float[0], Format.floating(32), FLOAT_CLASS, FLOAT_SUPERCLASSES, ConstantDescs.CD_float),
+ DOUBLE ( Double.class, "Double", double.class, "double", 'D', new double[0], Format.floating(64), DOUBLE_CLASS, DOUBLE_CLASS, ConstantDescs.CD_double),
+ OBJECT ( Object.class, "Object", Object.class, "Object", 'L', new Object[0], Format.other( 1), 0, 0, ConstantDescs.CD_Object),
// VOID must be the last type, since it is "assignable" from any other type:
- VOID ( Void.class, "Void", void.class, "void", 'V', null, Format.other( 0), 0, 0),
+ VOID ( Void.class, "Void", void.class, "void", 'V', null, Format.other( 0), 0, 0, ConstantDescs.CD_void),
;
public static final int COUNT = 10;
@@ -58,8 +60,18 @@ public enum Wrapper {
private final int superClasses;
private final String wrapperSimpleName;
private final String primitiveSimpleName;
-
- private Wrapper(Class wtype, String wtypeName, Class ptype, String ptypeName, char tchar, Object emptyArray, int format, int numericClass, int superClasses) {
+ private final ClassDesc classDesc;
+
+ private Wrapper(Class wtype,
+ String wtypeName,
+ Class ptype,
+ String ptypeName,
+ char tchar,
+ Object emptyArray,
+ int format,
+ int numericClass,
+ int superClasses,
+ ClassDesc classDesc) {
this.wrapperType = wtype;
this.primitiveType = ptype;
this.basicTypeChar = tchar;
@@ -70,6 +82,7 @@ private Wrapper(Class wtype, String wtypeName, Class ptype, String ptypeNa
this.superClasses = superClasses;
this.wrapperSimpleName = wtypeName;
this.primitiveSimpleName = ptypeName;
+ this.classDesc = classDesc;
}
/** For debugging, give the details of this wrapper. */
@@ -376,6 +389,9 @@ public static Wrapper forBasicType(Class type) {
}
}
+ /** A nominal descriptor of the wrapped type */
+ public ClassDesc classDescriptor() { return classDesc; }
+
/** What is the primitive type wrapped by this wrapper? */
public Class primitiveType() { return primitiveType; }
diff --git a/src/java.base/share/classes/sun/nio/ch/FileChannelImpl.java b/src/java.base/share/classes/sun/nio/ch/FileChannelImpl.java
index ab386bb14a5..0b72ee6a7c2 100644
--- a/src/java.base/share/classes/sun/nio/ch/FileChannelImpl.java
+++ b/src/java.base/share/classes/sun/nio/ch/FileChannelImpl.java
@@ -50,6 +50,7 @@
import jdk.internal.access.JavaIOFileDescriptorAccess;
import jdk.internal.access.SharedSecrets;
+import jdk.internal.event.FileForceEvent;
import jdk.internal.foreign.MemorySessionImpl;
import jdk.internal.foreign.SegmentFactories;
import jdk.internal.misc.Blocker;
@@ -486,8 +487,7 @@ public FileChannel truncate(long newSize) throws IOException {
}
}
- @Override
- public void force(boolean metaData) throws IOException {
+ private void implForce(boolean metaData) throws IOException {
ensureOpen();
int rv = -1;
int ti = -1;
@@ -511,6 +511,17 @@ public void force(boolean metaData) throws IOException {
}
}
+ @Override
+ public void force(boolean metaData) throws IOException {
+ if (!FileForceEvent.enabled()) {
+ implForce(metaData);
+ return;
+ }
+ long start = FileForceEvent.timestamp();
+ implForce(metaData);
+ FileForceEvent.offer(start, path, metaData);
+ }
+
// Assume at first that the underlying kernel supports sendfile/equivalent;
// set this to true if we find out later that it doesn't
//
diff --git a/src/java.base/share/classes/sun/nio/ch/SimpleAsynchronousFileChannelImpl.java b/src/java.base/share/classes/sun/nio/ch/SimpleAsynchronousFileChannelImpl.java
index b41430c8d9d..5f3f91e7aff 100644
--- a/src/java.base/share/classes/sun/nio/ch/SimpleAsynchronousFileChannelImpl.java
+++ b/src/java.base/share/classes/sun/nio/ch/SimpleAsynchronousFileChannelImpl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2008, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -25,6 +25,8 @@
package sun.nio.ch;
+import jdk.internal.event.FileForceEvent;
+
import java.nio.channels.*;
import java.util.concurrent.*;
import java.nio.ByteBuffer;
@@ -50,19 +52,25 @@ private static class DefaultExecutorHolder {
// Used to make native read and write calls
private static final FileDispatcher nd = new FileDispatcherImpl();
+ // file path
+ private final String path;
+
// Thread-safe set of IDs of native threads, for signalling
private final NativeThreadSet threads = new NativeThreadSet(2);
SimpleAsynchronousFileChannelImpl(FileDescriptor fdObj,
+ String path,
boolean reading,
boolean writing,
ExecutorService executor)
{
super(fdObj, reading, writing, executor);
+ this.path = path;
}
public static AsynchronousFileChannel open(FileDescriptor fdo,
+ String path,
boolean reading,
boolean writing,
ThreadPool pool)
@@ -70,7 +78,7 @@ public static AsynchronousFileChannel open(FileDescriptor fdo,
// Executor is either default or based on pool parameters
ExecutorService executor = (pool == null) ?
DefaultExecutorHolder.defaultExecutor : pool.executor();
- return new SimpleAsynchronousFileChannelImpl(fdo, reading, writing, executor);
+ return new SimpleAsynchronousFileChannelImpl(fdo, path, reading, writing, executor);
}
@Override
@@ -151,8 +159,7 @@ public AsynchronousFileChannel truncate(long size) throws IOException {
}
}
- @Override
- public void force(boolean metaData) throws IOException {
+ private void implForce(boolean metaData) throws IOException {
int ti = threads.add();
try {
int n = 0;
@@ -169,6 +176,17 @@ public void force(boolean metaData) throws IOException {
}
}
+ @Override
+ public void force(boolean metaData) throws IOException {
+ if (!FileForceEvent.enabled()) {
+ implForce(metaData);
+ return;
+ }
+ long start = FileForceEvent.timestamp();
+ implForce(metaData);
+ FileForceEvent.offer(start, path, metaData);
+ }
+
@Override
Future implLock(final long position,
final long size,
diff --git a/src/java.base/share/legal/cldr.md b/src/java.base/share/legal/cldr.md
index e0d8102fb7f..97331fcba9f 100644
--- a/src/java.base/share/legal/cldr.md
+++ b/src/java.base/share/legal/cldr.md
@@ -1,14 +1,15 @@
-## Unicode Common Local Data Repository (CLDR) v44
+## Unicode Common Local Data Repository (CLDR) v45
### CLDR License
```
+
UNICODE LICENSE V3
COPYRIGHT AND PERMISSION NOTICE
-Copyright © 2019-2023 Unicode, Inc.
+Copyright © 1991-2024 Unicode, Inc.
NOTICE TO USER: Carefully read the following legal agreement. BY
DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
@@ -44,4 +45,56 @@ not be used in advertising or otherwise to promote the sale, use or other
dealings in these Data Files or Software without prior written
authorization of the copyright holder.
+SPDX-License-Identifier: Unicode-3.0
+
+————————————
+
+Unicode® Copyright and Terms of Use
+For the general privacy policy governing access to this site, see the Unicode Privacy Policy.
+
+Unicode Copyright
+Copyright © 1991-2024 Unicode, Inc. All rights reserved.
+Definitions
+Unicode Data Files ("DATA FILES") include all data files under the directories:
+https://www.unicode.org/Public/
+https://www.unicode.org/reports/
+https://www.unicode.org/ivd/data/
+
+Unicode Data Files do not include PDF online code charts under the directory:
+https://www.unicode.org/Public/
+
+Unicode Software ("SOFTWARE") includes any source code published in the Unicode Standard
+or any source code or compiled code under the directories:
+https://www.unicode.org/Public/PROGRAMS/
+https://www.unicode.org/Public/cldr/
+http://site.icu-project.org/download/
+Terms of Use
+Certain documents and files on this website contain a legend indicating that "Modification is permitted." Any person is hereby authorized, without fee, to modify such documents and files to create derivative works conforming to the Unicode® Standard, subject to Terms and Conditions herein.
+Any person is hereby authorized, without fee, to view, use, reproduce, and distribute all documents and files, subject to the Terms and Conditions herein.
+Further specifications of rights and restrictions pertaining to the use of the Unicode DATA FILES and SOFTWARE can be found in the Unicode Data Files and Software License.
+Each version of the Unicode Standard has further specifications of rights and restrictions of use. For the book editions (Unicode 5.0 and earlier), these are found on the back of the title page.
+The Unicode PDF online code charts carry specific restrictions. Those restrictions are incorporated as the first page of each PDF code chart.
+All other files, including online documentation of the core specification for Unicode 6.0 and later, are covered under these general Terms of Use.
+No license is granted to "mirror" the Unicode website where a fee is charged for access to the "mirror" site.
+Modification is not permitted with respect to this document. All copies of this document must be verbatim.
+Restricted Rights Legend
+Any technical data or software which is licensed to the United States of America, its agencies and/or instrumentalities under this Agreement is commercial technical data or commercial computer software developed exclusively at private expense as defined in FAR 2.101, or DFARS 252.227-7014 (June 1995), as applicable. For technical data, use, duplication, or disclosure by the Government is subject to restrictions as set forth in DFARS 202.227-7015 Technical Data, Commercial and Items (Nov 1995) and this Agreement. For Software, in accordance with FAR 12-212 or DFARS 227-7202, as applicable, use, duplication or disclosure by the Government is subject to the restrictions set forth in this Agreement.
+Warranties and Disclaimers
+This publication and/or website may include technical or typographical errors or other inaccuracies. Changes are periodically added to the information herein; these changes will be incorporated in new editions of the publication and/or website. Unicode, Inc. may make improvements and/or changes in the product(s) and/or program(s) described in this publication and/or website at any time.
+If this file has been purchased on magnetic or optical media from Unicode, Inc. the sole and exclusive remedy for any claim will be exchange of the defective media within ninety (90) days of original purchase.
+EXCEPT AS PROVIDED IN SECTION E.2, THIS PUBLICATION AND/OR SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND EITHER EXPRESS, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. UNICODE, INC. AND ITS LICENSORS ASSUME NO RESPONSIBILITY FOR ERRORS OR OMISSIONS IN THIS PUBLICATION AND/OR SOFTWARE OR OTHER DOCUMENTS WHICH ARE REFERENCED BY OR LINKED TO THIS PUBLICATION OR THE UNICODE WEBSITE.
+Waiver of Damages
+In no event shall Unicode, Inc. or its licensors be liable for any special, incidental, indirect or consequential damages of any kind, or any damages whatsoever, whether or not Unicode, Inc. was advised of the possibility of the damage, including, without limitation, those resulting from the following: loss of use, data or profits, in connection with the use, modification or distribution of this information or its derivatives.
+Trademarks & Logos
+The Unicode Word Mark and the Unicode Logo are trademarks of Unicode, Inc. “The Unicode Consortium” and “Unicode, Inc.” are trade names of Unicode, Inc. Use of the information and materials found on this website indicates your acknowledgement of Unicode, Inc.’s exclusive worldwide rights in the Unicode Word Mark, the Unicode Logo, and the Unicode trade names.
+The Unicode Consortium Name and Trademark Usage Policy (“Trademark Policy”) are incorporated herein by reference and you agree to abide by the provisions of the Trademark Policy, which may be changed from time to time in the sole discretion of Unicode, Inc.
+All third party trademarks referenced herein are the property of their respective owners.
+Miscellaneous
+Jurisdiction and Venue. This website is operated from a location in the State of California, United States of America. Unicode, Inc. makes no representation that the materials are appropriate for use in other locations. If you access this website from other locations, you are responsible for compliance with local laws. This Agreement, all use of this website and any claims and damages resulting from use of this website are governed solely by the laws of the State of California without regard to any principles which would apply the laws of a different jurisdiction. The user agrees that any disputes regarding this website shall be resolved solely in the courts located in Santa Clara County, California. The user agrees said courts have personal jurisdiction and agree to waive any right to transfer the dispute to any other forum.
+Modification by Unicode, Inc. Unicode, Inc. shall have the right to modify this Agreement at any time by posting it to this website. The user may not assign any part of this Agreement without Unicode, Inc.’s prior written consent.
+Taxes. The user agrees to pay any taxes arising from access to this website or use of the information herein, except for those based on Unicode’s net income.
+Severability. If any provision of this Agreement is declared invalid or unenforceable, the remaining provisions of this Agreement shall remain in effect.
+Entire Agreement. This Agreement constitutes the entire agreement between the parties.
+
+
```
diff --git a/src/java.base/share/native/libzip/zip_util.c b/src/java.base/share/native/libzip/zip_util.c
index a996b450ad4..8f2f19c66a2 100644
--- a/src/java.base/share/native/libzip/zip_util.c
+++ b/src/java.base/share/native/libzip/zip_util.c
@@ -437,7 +437,7 @@ hash(const char *s)
static unsigned int
hashN(const char *s, int length)
{
- int h = 0;
+ unsigned int h = 0;
while (length-- > 0)
h = 31*h + *s++;
return h;
diff --git a/src/java.base/unix/classes/sun/nio/fs/UnixChannelFactory.java b/src/java.base/unix/classes/sun/nio/fs/UnixChannelFactory.java
index 475b61036a2..8e5bf38882c 100644
--- a/src/java.base/unix/classes/sun/nio/fs/UnixChannelFactory.java
+++ b/src/java.base/unix/classes/sun/nio/fs/UnixChannelFactory.java
@@ -168,7 +168,7 @@ static AsynchronousFileChannel newAsynchronousFileChannel(UnixPath path,
// for now use simple implementation
FileDescriptor fdObj = open(-1, path, null, flags, mode);
- return SimpleAsynchronousFileChannelImpl.open(fdObj, flags.read, flags.write, pool);
+ return SimpleAsynchronousFileChannelImpl.open(fdObj, path.toString(), flags.read, flags.write, pool);
}
/**
diff --git a/src/java.base/unix/native/libjli/java_md.c b/src/java.base/unix/native/libjli/java_md.c
index 0d3249ab1d4..08afd9986ca 100644
--- a/src/java.base/unix/native/libjli/java_md.c
+++ b/src/java.base/unix/native/libjli/java_md.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -525,6 +525,8 @@ GetJREPath(char *path, jint pathsize, jboolean speculative)
char libjava[MAXPATHLEN];
struct stat s;
+ JLI_TraceLauncher("Attempt to get JRE path from launcher executable path\n");
+
if (GetApplicationHome(path, pathsize)) {
/* Is JRE co-located with the application? */
JLI_Snprintf(libjava, sizeof(libjava), "%s/lib/" JAVA_DLL, path);
@@ -532,20 +534,10 @@ GetJREPath(char *path, jint pathsize, jboolean speculative)
JLI_TraceLauncher("JRE path is %s\n", path);
return JNI_TRUE;
}
- /* ensure storage for path + /jre + NULL */
- if ((JLI_StrLen(path) + 4 + 1) > (size_t) pathsize) {
- JLI_TraceLauncher("Insufficient space to store JRE path\n");
- return JNI_FALSE;
- }
- /* Does the app ship a private JRE in /jre directory? */
- JLI_Snprintf(libjava, sizeof(libjava), "%s/jre/lib/" JAVA_DLL, path);
- if (access(libjava, F_OK) == 0) {
- JLI_StrCat(path, "/jre");
- JLI_TraceLauncher("JRE path is %s\n", path);
- return JNI_TRUE;
- }
}
+ JLI_TraceLauncher("Attempt to get JRE path from shared lib of the image\n");
+
if (GetApplicationHomeFromDll(path, pathsize)) {
JLI_Snprintf(libjava, sizeof(libjava), "%s/lib/" JAVA_DLL, path);
if (stat(libjava, &s) == 0) {
diff --git a/src/java.base/windows/classes/sun/nio/ch/WindowsAsynchronousFileChannelImpl.java b/src/java.base/windows/classes/sun/nio/ch/WindowsAsynchronousFileChannelImpl.java
index a1bacc1fae1..15ae425850e 100644
--- a/src/java.base/windows/classes/sun/nio/ch/WindowsAsynchronousFileChannelImpl.java
+++ b/src/java.base/windows/classes/sun/nio/ch/WindowsAsynchronousFileChannelImpl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2008, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -33,6 +33,7 @@
import java.io.FileDescriptor;
import jdk.internal.access.SharedSecrets;
import jdk.internal.access.JavaIOFileDescriptorAccess;
+import jdk.internal.event.FileForceEvent;
/**
* Windows implementation of AsynchronousFileChannel using overlapped I/O.
@@ -63,6 +64,9 @@ private static Iocp defaultIocp() {
// Used for force/truncate/size methods
private static final FileDispatcher nd = new FileDispatcherImpl();
+ // file path
+ private final String path;
+
// The handle is extracted for use in native methods invoked from this class.
private final long handle;
@@ -79,6 +83,7 @@ private static Iocp defaultIocp() {
private WindowsAsynchronousFileChannelImpl(FileDescriptor fdObj,
+ String path,
boolean reading,
boolean writing,
Iocp iocp,
@@ -86,6 +91,7 @@ private WindowsAsynchronousFileChannelImpl(FileDescriptor fdObj,
throws IOException
{
super(fdObj, reading, writing, iocp.executor());
+ this.path = path;
this.handle = fdAccess.getHandle(fdObj);
this.iocp = iocp;
this.isDefaultIocp = isDefaultIocp;
@@ -94,6 +100,7 @@ private WindowsAsynchronousFileChannelImpl(FileDescriptor fdObj,
}
public static AsynchronousFileChannel open(FileDescriptor fdo,
+ String path,
boolean reading,
boolean writing,
ThreadPool pool)
@@ -109,8 +116,7 @@ public static AsynchronousFileChannel open(FileDescriptor fdo,
isDefaultIocp = false;
}
try {
- return new
- WindowsAsynchronousFileChannelImpl(fdo, reading, writing, iocp, isDefaultIocp);
+ return new WindowsAsynchronousFileChannelImpl(fdo, path, reading, writing, iocp, isDefaultIocp);
} catch (IOException x) {
// error binding to port so need to close it (if created for this channel)
if (!isDefaultIocp)
@@ -196,8 +202,7 @@ public AsynchronousFileChannel truncate(long size) throws IOException {
return this;
}
- @Override
- public void force(boolean metaData) throws IOException {
+ private void implForce(boolean metaData) throws IOException {
try {
begin();
nd.force(fdObj, metaData);
@@ -206,6 +211,17 @@ public void force(boolean metaData) throws IOException {
}
}
+ @Override
+ public void force(boolean metaData) throws IOException {
+ if (!FileForceEvent.enabled()) {
+ implForce(metaData);
+ return;
+ }
+ long start = FileForceEvent.timestamp();
+ implForce(metaData);
+ FileForceEvent.offer(start, path, metaData);
+ }
+
// -- file locking --
/**
diff --git a/src/java.base/windows/classes/sun/nio/fs/WindowsChannelFactory.java b/src/java.base/windows/classes/sun/nio/fs/WindowsChannelFactory.java
index 3a14221d62a..59db82d3fab 100644
--- a/src/java.base/windows/classes/sun/nio/fs/WindowsChannelFactory.java
+++ b/src/java.base/windows/classes/sun/nio/fs/WindowsChannelFactory.java
@@ -212,7 +212,7 @@ static AsynchronousFileChannel newAsynchronousFileChannel(String pathForWindows,
// create the AsynchronousFileChannel
try {
- return WindowsAsynchronousFileChannelImpl.open(fdObj, flags.read, flags.write, pool);
+ return WindowsAsynchronousFileChannelImpl.open(fdObj, pathForWindows, flags.read, flags.write, pool);
} catch (IOException x) {
// IOException is thrown if the file handle cannot be associated
// with the completion port. All we can do is close the file.
diff --git a/src/java.base/windows/native/libjli/java_md.c b/src/java.base/windows/native/libjli/java_md.c
index 39930a38535..6ff155bcb9b 100644
--- a/src/java.base/windows/native/libjli/java_md.c
+++ b/src/java.base/windows/native/libjli/java_md.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -49,10 +49,6 @@ static jboolean GetJVMPath(const char *jrepath, const char *jvmtype,
char *jvmpath, jint jvmpathsize);
static jboolean GetJREPath(char *path, jint pathsize);
-#ifdef USE_REGISTRY_LOOKUP
-jboolean GetPublicJREHome(char *buf, jint bufsize);
-#endif
-
/* We supports warmup for UI stack that is performed in parallel
* to VM initialization.
* This helps to improve startup of UI application as warmup phase
@@ -300,6 +296,8 @@ GetJREPath(char *path, jint pathsize)
char javadll[MAXPATHLEN];
struct stat s;
+ JLI_TraceLauncher("Attempt to get JRE path from launcher executable path\n");
+
if (GetApplicationHome(path, pathsize)) {
/* Is JRE co-located with the application? */
JLI_Snprintf(javadll, sizeof(javadll), "%s\\bin\\" JAVA_DLL, path);
@@ -307,20 +305,10 @@ GetJREPath(char *path, jint pathsize)
JLI_TraceLauncher("JRE path is %s\n", path);
return JNI_TRUE;
}
- /* ensure storage for path + \jre + NULL */
- if ((JLI_StrLen(path) + 4 + 1) > (size_t) pathsize) {
- JLI_TraceLauncher("Insufficient space to store JRE path\n");
- return JNI_FALSE;
- }
- /* Does this app ship a private JRE in \jre directory? */
- JLI_Snprintf(javadll, sizeof (javadll), "%s\\jre\\bin\\" JAVA_DLL, path);
- if (stat(javadll, &s) == 0) {
- JLI_StrCat(path, "\\jre");
- JLI_TraceLauncher("JRE path is %s\n", path);
- return JNI_TRUE;
- }
}
+ JLI_TraceLauncher("Attempt to get JRE path from shared lib of the image\n");
+
/* Try getting path to JRE from path to JLI.DLL */
if (GetApplicationHomeFromDll(path, pathsize)) {
JLI_Snprintf(javadll, sizeof(javadll), "%s\\bin\\" JAVA_DLL, path);
@@ -330,14 +318,6 @@ GetJREPath(char *path, jint pathsize)
}
}
-#ifdef USE_REGISTRY_LOOKUP
- /* Lookup public JRE using Windows registry. */
- if (GetPublicJREHome(path, pathsize)) {
- JLI_TraceLauncher("JRE path is %s\n", path);
- return JNI_TRUE;
- }
-#endif
-
JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL);
return JNI_FALSE;
}
diff --git a/src/java.desktop/share/legal/libpng.md b/src/java.desktop/share/legal/libpng.md
index f420ccd94ed..cbffed81332 100644
--- a/src/java.desktop/share/legal/libpng.md
+++ b/src/java.desktop/share/legal/libpng.md
@@ -1,4 +1,4 @@
-## libpng v1.6.40
+## libpng v1.6.43
### libpng License
@@ -9,11 +9,11 @@ COPYRIGHT NOTICE, DISCLAIMER, and LICENSE
PNG Reference Library License version 2
---------------------------------------
-Copyright (c) 1995-2023 The PNG Reference Library Authors.
-Copyright (c) 2018-2023 Cosmin Truta
-Copyright (c) 1998-2018 Glenn Randers-Pehrson
-Copyright (c) 1996-1997 Andreas Dilger
-Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+Copyright (C) 1995-2024 The PNG Reference Library Authors.
+Copyright (C) 2018-2024 Cosmin Truta
+Copyright (C) 1998-2018 Glenn Randers-Pehrson
+Copyright (C) 1996-1997 Andreas Dilger
+Copyright (C) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
The software is supplied "as is", without warranty of any kind,
express or implied, including, without limitation, the warranties
@@ -157,7 +157,9 @@ PNG REFERENCE LIBRARY AUTHORS
This is the list of PNG Reference Library ("libpng") Contributing
Authors, for copyright and licensing purposes.
+ * Adam Richter
* Andreas Dilger
+ * Chris Blume
* Cosmin Truta
* Dave Martindale
* Eric S. Raymond
@@ -186,21 +188,28 @@ Authors, for copyright and licensing purposes.
* Vadim Barkov
* Willem van Schaik
* Zhijie Liang
+ * Apple Inc.
+ - Zixu Wang (王子旭)
* Arm Holdings
- - Richard Townsend
+ - Richard Townsend
* Google Inc.
- - Dan Field
- - Leon Scroggins III
- - Matt Sarett
- - Mike Klein
- - Sami Boukortt
- - Wan-Teh Chang
+ - Dan Field
+ - Leon Scroggins III
+ - Matt Sarett
+ - Mike Klein
+ - Sami Boukortt
+ - Wan-Teh Chang
+ * Loongson Technology Corporation Ltd.
+ - GuXiWei (顾希伟)
+ - JinBo (金波)
+ - ZhangLixia (张利霞)
The build projects, the build scripts, the test scripts, and other
-files in the "ci", "projects", "scripts" and "tests" directories, have
+files in the "projects", "scripts" and "tests" directories, have
other copyright owners, but are released under the libpng license.
-Some files in the "contrib" directory, and some tools-generated files
-that are distributed with libpng, have other copyright owners, and are
-released under other open source licenses.
+Some files in the "ci" and "contrib" directories, as well as some
+of the tools-generated files that are distributed with libpng, have
+other copyright owners, and are released under other open source
+licenses.
```
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/CHANGES b/src/java.desktop/share/native/libsplashscreen/libpng/CHANGES
index 2d8c585c0e7..441b57ecf1a 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/CHANGES
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/CHANGES
@@ -6129,6 +6129,73 @@ Version 1.6.40 [June 21, 2023]
Updated the configurations and the scripts for continuous integration.
Cleaned up the code, the build scripts, and the documentation.
+Version 1.6.41 [January 24, 2024]
+ Added SIMD-optimized code for the LoongArch LSX hardware.
+ (Contributed by GuXiWei, JinBo and ZhangLixia)
+ Fixed the run-time discovery of MIPS MSA hardware.
+ (Contributed by Sui Jingfeng)
+ Fixed an off-by-one error in the function png_do_check_palette_indexes(),
+ which failed to recognize errors that might have existed in the first
+ column of a broken palette-encoded image. This was a benign regression
+ accidentally introduced in libpng-1.6.33. No pixel was harmed.
+ (Contributed by Adam Richter; reviewed by John Bowler)
+ Fixed, improved and modernized the contrib/pngminus programs, i.e.,
+ png2pnm.c and pnm2png.c
+ Removed old and peculiar portability hacks that were meant to silence
+ warnings issued by gcc version 7.1 alone.
+ (Contributed by John Bowler)
+ Fixed and modernized the CMake file, and raised the minimum required
+ CMake version from 3.1 to 3.6.
+ (Contributed by Clinton Ingram, Timothy Lyanguzov, Tyler Kropp, et al.)
+ Allowed the configure script to disable the building of auxiliary tools
+ and tests, thus catching up with the CMake file.
+ (Contributed by Carlo Bramini)
+ Fixed a build issue on Mac.
+ (Contributed by Zixu Wang)
+ Moved the Autoconf macro files to scripts/autoconf.
+ Moved the CMake files (except for the main CMakeLists.txt) to
+ scripts/cmake and moved the list of their contributing authors to
+ scripts/cmake/AUTHORS.md
+ Updated the CI configurations and scripts.
+ Relicensed the CI scripts to the MIT License.
+ Improved the test coverage.
+ (Contributed by John Bowler)
+
+Version 1.6.42 [January 29, 2024]
+ Fixed the implementation of the macro function png_check_sig().
+ This was an API regression, introduced in libpng-1.6.41.
+ (Reported by Matthieu Darbois)
+ Fixed and updated the libpng manual.
+
+Version 1.6.43 [February 23, 2024]
+ Fixed the row width check in png_check_IHDR().
+ This corrected a bug that was specific to the 16-bit platforms,
+ and removed a spurious compiler warning from the 64-bit builds.
+ (Reported by Jacek Caban; fixed by John Bowler)
+ Added eXIf chunk support to the push-mode reader in pngpread.c.
+ (Contributed by Chris Blume)
+ Added contrib/pngexif for the benefit of the users who would like
+ to inspect the content of eXIf chunks.
+ Added contrib/conftest/basic.dfa, a basic build-time configuration.
+ (Contributed by John Bowler)
+ Fixed a preprocessor condition in pngread.c that broke build-time
+ configurations like contrib/conftest/pngcp.dfa.
+ (Contributed by John Bowler)
+ Added CMake build support for LoongArch LSX.
+ (Contributed by GuXiWei)
+ Fixed a CMake build error that occurred under a peculiar state of the
+ dependency tree. This was a regression introduced in libpng-1.6.41.
+ (Contributed by Dan Rosser)
+ Marked the installed libpng headers as system headers in CMake.
+ (Contributed by Benjamin Buch)
+ Updated the build support for RISCOS.
+ (Contributed by Cameron Cawley)
+ Updated the makefiles to allow cross-platform builds to initialize
+ conventional make variables like AR and ARFLAGS.
+ Added various improvements to the CI scripts in areas like version
+ consistency verification and text linting.
+ Added version consistency verification to pngtest.c also.
+
Send comments/corrections/commendations to png-mng-implement at lists.sf.net.
Subscription is required; visit
https://lists.sourceforge.net/lists/listinfo/png-mng-implement
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/LICENSE b/src/java.desktop/share/native/libsplashscreen/libpng/LICENSE
index 086d1c2fda6..25f298f0fcf 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/LICENSE
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/LICENSE
@@ -4,8 +4,8 @@ COPYRIGHT NOTICE, DISCLAIMER, and LICENSE
PNG Reference Library License version 2
---------------------------------------
- * Copyright (c) 1995-2023 The PNG Reference Library Authors.
- * Copyright (c) 2018-2023 Cosmin Truta.
+ * Copyright (c) 1995-2024 The PNG Reference Library Authors.
+ * Copyright (c) 2018-2024 Cosmin Truta.
* Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.
* Copyright (c) 1996-1997 Andreas Dilger.
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/README b/src/java.desktop/share/native/libsplashscreen/libpng/README
index dedd2c1639e..a6ca3ae9f94 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/README
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/README
@@ -1,4 +1,4 @@
-README for libpng version 1.6.40
+README for libpng version 1.6.43
================================
See the note about version numbers near the top of `png.h`.
@@ -142,10 +142,11 @@ Files included in this distribution
pngwrite.c => High-level write functions
pngwtran.c => Write data transformations
pngwutil.c => Write utility functions
- arm/ => Optimized code for the ARM platform
- intel/ => Optimized code for the INTEL-SSE2 platform
- mips/ => Optimized code for the MIPS platform
- powerpc/ => Optimized code for the PowerPC platform
+ arm/ => Optimized code for ARM Neon
+ intel/ => Optimized code for INTEL SSE2
+ loongarch/ => Optimized code for LoongArch LSX
+ mips/ => Optimized code for MIPS MSA and MIPS MMI
+ powerpc/ => Optimized code for PowerPC VSX
ci/ => Scripts for continuous integration
contrib/ => External contributions
arm-neon/ => Optimized code for the ARM-NEON platform
@@ -158,6 +159,7 @@ Files included in this distribution
libtests/ => Test programs
oss-fuzz/ => Files used by the OSS-Fuzz project for fuzz-testing
libpng
+ pngexif/ => Program to inspect the EXIF information in PNG files
pngminim/ => Minimal decoder, encoder, and progressive decoder
programs demonstrating the use of pngusr.dfa
pngminus/ => Simple pnm2png and png2pnm programs
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/UPDATING.txt b/src/java.desktop/share/native/libsplashscreen/libpng/UPDATING.txt
index 93c8f5bb703..88200db5d73 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/UPDATING.txt
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/UPDATING.txt
@@ -37,18 +37,21 @@ and instead just tweak the existing one.
First cd into the libpng folder and run the following script.
+ shopt -s nullglob
for f in *.c *.h;
- do
- # replace tabs with spaces
- expand ${f} > ${f}.tmp;
- mv ${f}.tmp $f;
-
- # fix line endings to LF
- sed -i -e 's/\r$//g' ${f};
-
- # remove trailing spaces
- sed -i -e 's/[ ]* $//g' ${f};
- done
+ do
+ # replace tabs with spaces
+ expand ${f} > ${f}.tmp
+ mv ${f}.tmp $f
+
+ # fix line endings to LF
+ sed -e 's/\r$//g' ${f} > ${f}.tmp
+ mv ${f}.tmp $f
+
+ # remove trailing spaces
+ sed -e 's/[ ]* $//g' ${f} > ${f}.tmp
+ mv ${f}.tmp $f
+ done
6) As with all native code, run it through the official build systems, in case
the updated code trigger any fatal warnings with the official compilers.
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/png.c b/src/java.desktop/share/native/libsplashscreen/libpng/png.c
index 91a92e5f718..232dff876c7 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/png.c
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/png.c
@@ -29,7 +29,7 @@
* However, the following notice accompanied the original version of this
* file and, per its terms, should not be removed:
*
- * Copyright (c) 2018-2023 Cosmin Truta
+ * Copyright (c) 2018-2024 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -42,27 +42,7 @@
#include "pngpriv.h"
/* Generate a compiler error if there is an old png.h in the search path. */
-typedef png_libpng_version_1_6_40 Your_png_h_is_not_version_1_6_40;
-
-#ifdef __GNUC__
-/* The version tests may need to be added to, but the problem warning has
- * consistently been fixed in GCC versions which obtain wide-spread release.
- * The problem is that many versions of GCC rearrange comparison expressions in
- * the optimizer in such a way that the results of the comparison will change
- * if signed integer overflow occurs. Such comparisons are not permitted in
- * ANSI C90, however GCC isn't clever enough to work out that that do not occur
- * below in png_ascii_from_fp and png_muldiv, so it produces a warning with
- * -Wextra. Unfortunately this is highly dependent on the optimizer and the
- * machine architecture so the warning comes and goes unpredictably and is
- * impossible to "fix", even were that a good idea.
- */
-#if __GNUC__ == 7 && __GNUC_MINOR__ == 1
-#define GCC_STRICT_OVERFLOW 1
-#endif /* GNU 7.1.x */
-#endif /* GNU */
-#ifndef GCC_STRICT_OVERFLOW
-#define GCC_STRICT_OVERFLOW 0
-#endif
+typedef png_libpng_version_1_6_43 Your_png_h_is_not_version_1_6_43;
/* Tells libpng that we have already handled the first "num_bytes" bytes
* of the PNG file signature. If the PNG data is embedded into another
@@ -101,21 +81,21 @@ png_set_sig_bytes(png_structrp png_ptr, int num_bytes)
int PNGAPI
png_sig_cmp(png_const_bytep sig, size_t start, size_t num_to_check)
{
- png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
+ static const png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
if (num_to_check > 8)
num_to_check = 8;
else if (num_to_check < 1)
- return (-1);
+ return -1;
if (start > 7)
- return (-1);
+ return -1;
if (start + num_to_check > 8)
num_to_check = 8 - start;
- return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check)));
+ return memcmp(&sig[start], &png_signature[start], num_to_check);
}
#endif /* READ */
@@ -475,7 +455,6 @@ png_info_init_3,(png_infopp ptr_ptr, size_t png_info_struct_size),
memset(info_ptr, 0, (sizeof *info_ptr));
}
-/* The following API is not called internally */
void PNGAPI
png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,
int freer, png_uint_32 mask)
@@ -714,9 +693,9 @@ png_voidp PNGAPI
png_get_io_ptr(png_const_structrp png_ptr)
{
if (png_ptr == NULL)
- return (NULL);
+ return NULL;
- return (png_ptr->io_ptr);
+ return png_ptr->io_ptr;
}
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
@@ -780,7 +759,7 @@ png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)
{
size_t pos = 0;
- char number_buf[5]; /* enough for a four-digit year */
+ char number_buf[5] = {0, 0, 0, 0, 0}; /* enough for a four-digit year */
# define APPEND_STRING(string) pos = png_safecat(out, 29, pos, (string))
# define APPEND_NUMBER(format, value)\
@@ -843,8 +822,8 @@ png_get_copyright(png_const_structrp png_ptr)
return PNG_STRING_COPYRIGHT
#else
return PNG_STRING_NEWLINE \
- "libpng version 1.6.40" PNG_STRING_NEWLINE \
- "Copyright (c) 2018-2023 Cosmin Truta" PNG_STRING_NEWLINE \
+ "libpng version 1.6.43" PNG_STRING_NEWLINE \
+ "Copyright (c) 2018-2024 Cosmin Truta" PNG_STRING_NEWLINE \
"Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson" \
PNG_STRING_NEWLINE \
"Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
@@ -1005,7 +984,7 @@ png_reset_zstream(png_structrp png_ptr)
return Z_STREAM_ERROR;
/* WARNING: this resets the window bits to the maximum! */
- return (inflateReset(&png_ptr->zstream));
+ return inflateReset(&png_ptr->zstream);
}
#endif /* READ */
@@ -1014,7 +993,7 @@ png_uint_32 PNGAPI
png_access_version_number(void)
{
/* Version of *.c files used when building libpng */
- return((png_uint_32)PNG_LIBPNG_VER);
+ return (png_uint_32)PNG_LIBPNG_VER;
}
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
@@ -1870,14 +1849,14 @@ png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
}
# ifdef PNG_WARNINGS_SUPPORTED
else
- {
- char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114 */
+ {
+ char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114 */
- pos = png_safecat(message, (sizeof message), pos,
- png_format_number(number, number+(sizeof number),
- PNG_NUMBER_FORMAT_x, value));
- pos = png_safecat(message, (sizeof message), pos, "h: "); /* +2 = 116 */
- }
+ pos = png_safecat(message, (sizeof message), pos,
+ png_format_number(number, number+(sizeof number),
+ PNG_NUMBER_FORMAT_x, value));
+ pos = png_safecat(message, (sizeof message), pos, "h: "); /* +2 = 116 */
+ }
# endif
/* The 'reason' is an arbitrary message, allow +79 maximum 195 */
pos = png_safecat(message, (sizeof message), pos, reason);
@@ -2560,17 +2539,6 @@ png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
#endif /* COLORSPACE */
-#ifdef __GNUC__
-/* This exists solely to work round a warning from GNU C. */
-static int /* PRIVATE */
-png_gt(size_t a, size_t b)
-{
- return a > b;
-}
-#else
-# define png_gt(a,b) ((a) > (b))
-#endif
-
void /* PRIVATE */
png_check_IHDR(png_const_structrp png_ptr,
png_uint_32 width, png_uint_32 height, int bit_depth,
@@ -2592,8 +2560,16 @@ png_check_IHDR(png_const_structrp png_ptr,
error = 1;
}
- if (png_gt(((width + 7) & (~7U)),
- ((PNG_SIZE_MAX
+ /* The bit mask on the first line below must be at least as big as a
+ * png_uint_32. "~7U" is not adequate on 16-bit systems because it will
+ * be an unsigned 16-bit value. Casting to (png_alloc_size_t) makes the
+ * type of the result at least as bit (in bits) as the RHS of the > operator
+ * which also avoids a common warning on 64-bit systems that the comparison
+ * of (png_uint_32) against the constant value on the RHS will always be
+ * false.
+ */
+ if (((width + 7) & ~(png_alloc_size_t)7) >
+ (((PNG_SIZE_MAX
- 48 /* big_row_buf hack */
- 1) /* filter byte */
/ 8) /* 8-byte RGBA pixels */
@@ -2919,14 +2895,6 @@ png_pow10(int power)
/* Function to format a floating point value in ASCII with a given
* precision.
*/
-#if GCC_STRICT_OVERFLOW
-#pragma GCC diagnostic push
-/* The problem arises below with exp_b10, which can never overflow because it
- * comes, originally, from frexp and is therefore limited to a range which is
- * typically +/-710 (log2(DBL_MAX)/log2(DBL_MIN)).
- */
-#pragma GCC diagnostic warning "-Wstrict-overflow=2"
-#endif /* GCC_STRICT_OVERFLOW */
void /* PRIVATE */
png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, size_t size,
double fp, unsigned int precision)
@@ -3248,10 +3216,6 @@ png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, size_t size,
/* Here on buffer too small. */
png_error(png_ptr, "ASCII conversion buffer too small");
}
-#if GCC_STRICT_OVERFLOW
-#pragma GCC diagnostic pop
-#endif /* GCC_STRICT_OVERFLOW */
-
# endif /* FLOATING_POINT */
# ifdef PNG_FIXED_POINT_SUPPORTED
@@ -3279,7 +3243,7 @@ png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii,
if (num <= 0x80000000) /* else overflowed */
{
unsigned int ndigits = 0, first = 16 /* flag value */;
- char digits[10];
+ char digits[10] = {0};
while (num)
{
@@ -3364,15 +3328,6 @@ png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text)
* the nearest .00001). Overflow and divide by zero are signalled in
* the result, a boolean - true on success, false on overflow.
*/
-#if GCC_STRICT_OVERFLOW /* from above */
-/* It is not obvious which comparison below gets optimized in such a way that
- * signed overflow would change the result; looking through the code does not
- * reveal any tests which have the form GCC complains about, so presumably the
- * optimizer is moving an add or subtract into the 'if' somewhere.
- */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic warning "-Wstrict-overflow=2"
-#endif /* GCC_STRICT_OVERFLOW */
int
png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
png_int_32 divisor)
@@ -3487,9 +3442,6 @@ png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
return 0;
}
-#if GCC_STRICT_OVERFLOW
-#pragma GCC diagnostic pop
-#endif /* GCC_STRICT_OVERFLOW */
#endif /* READ_GAMMA || INCH_CONVERSIONS */
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/png.h b/src/java.desktop/share/native/libsplashscreen/libpng/png.h
index 578841c9580..9f61a773c1d 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/png.h
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/png.h
@@ -29,9 +29,9 @@
* However, the following notice accompanied the original version of this
* file and, per its terms, should not be removed:
*
- * libpng version 1.6.40
+ * libpng version 1.6.43
*
- * Copyright (c) 2018-2023 Cosmin Truta
+ * Copyright (c) 2018-2024 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -43,7 +43,7 @@
* libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
* libpng versions 0.97, January 1998, through 1.6.35, July 2018:
* Glenn Randers-Pehrson
- * libpng versions 1.6.36, December 2018, through 1.6.40, June 2023:
+ * libpng versions 1.6.36, December 2018, through 1.6.43, February 2024:
* Cosmin Truta
* See also "Contributing Authors", below.
*/
@@ -55,8 +55,8 @@
* PNG Reference Library License version 2
* ---------------------------------------
*
- * * Copyright (c) 1995-2023 The PNG Reference Library Authors.
- * * Copyright (c) 2018-2023 Cosmin Truta.
+ * * Copyright (c) 1995-2024 The PNG Reference Library Authors.
+ * * Copyright (c) 2018-2024 Cosmin Truta.
* * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.
* * Copyright (c) 1996-1997 Andreas Dilger.
* * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -267,7 +267,7 @@
* ...
* 1.5.30 15 10530 15.so.15.30[.0]
* ...
- * 1.6.40 16 10640 16.so.16.40[.0]
+ * 1.6.43 16 10643 16.so.16.43[.0]
*
* Henceforth the source version will match the shared-library major and
* minor numbers; the shared-library major version number will be used for
@@ -283,9 +283,6 @@
* to the info_ptr or png_ptr members through png.h, and the compiled
* application is loaded with a different version of the library.
*
- * DLLNUM will change each time there are forward or backward changes
- * in binary compatibility (e.g., when a new feature is added).
- *
* See libpng.txt or libpng.3 for more information. The PNG specification
* is available as a W3C Recommendation and as an ISO/IEC Standard; see
*
-# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
- defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
- /* We need to check that hasn't already been included earlier
- * as it seems it doesn't agree with , yet we should really use
- * if possible.
- */
-# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
-# include
-# endif
-# else
-# include
-# endif
+# include
+
# if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
/* Amiga SAS/C: We must include builtin FPU functions when compiling using
* MATH=68881
@@ -1334,7 +1368,7 @@ PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop
row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
#endif
-#if PNG_MIPS_MSA_OPT > 0
+#if PNG_MIPS_MSA_IMPLEMENTATION == 1
PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_msa,(png_row_infop row_info,
png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_msa,(png_row_infop
@@ -1351,6 +1385,23 @@ PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_msa,(png_row_infop
row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
#endif
+#if PNG_MIPS_MMI_IMPLEMENTATION > 0
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_mmi,(png_row_infop row_info,
+ png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_mmi,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_mmi,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_mmi,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_mmi,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_mmi,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_mmi,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+#endif
+
#if PNG_POWERPC_VSX_OPT > 0
PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_vsx,(png_row_infop row_info,
png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
@@ -1383,6 +1434,23 @@ PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_sse2,(png_row_infop
row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
#endif
+#if PNG_LOONGARCH_LSX_IMPLEMENTATION == 1
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_lsx,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_lsx,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_lsx,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_lsx,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_lsx,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_lsx,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_lsx,(png_row_infop
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+#endif
+
/* Choose the best filter to use and filter the row data */
PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr,
png_row_infop row_info),PNG_EMPTY);
@@ -2122,17 +2190,27 @@ PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon,
(png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
#endif
-#if PNG_MIPS_MSA_OPT > 0
-PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_msa,
+#if PNG_MIPS_MSA_IMPLEMENTATION == 1
+PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_mips,
(png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
#endif
+# if PNG_MIPS_MMI_IMPLEMENTATION > 0
+PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_mips,
+ (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
+# endif
+
# if PNG_INTEL_SSE_IMPLEMENTATION > 0
PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_sse2,
(png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
# endif
#endif
+#if PNG_LOONGARCH_LSX_OPT > 0
+PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_lsx,
+ (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
+#endif
+
PNG_INTERNAL_FUNCTION(png_uint_32, png_check_keyword, (png_structrp png_ptr,
png_const_charp key, png_bytep new_key), PNG_EMPTY);
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/pngread.c b/src/java.desktop/share/native/libsplashscreen/libpng/pngread.c
index 3631e60f36b..e9e94477545 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/pngread.c
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/pngread.c
@@ -29,7 +29,7 @@
* However, the following notice accompanied the original version of this
* file and, per its terms, should not be removed:
*
- * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 2018-2024 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -596,7 +596,11 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
#endif
#ifdef PNG_READ_TRANSFORMS_SUPPORTED
- if (png_ptr->transformations)
+ if (png_ptr->transformations
+# ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
+ || png_ptr->num_palette_max >= 0
+# endif
+ )
png_do_read_transformations(png_ptr, &row_info);
#endif
@@ -813,7 +817,7 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
/* Report invalid palette index; added at libng-1.5.10 */
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
- png_ptr->num_palette_max > png_ptr->num_palette)
+ png_ptr->num_palette_max >= png_ptr->num_palette)
png_benign_error(png_ptr, "Read palette index exceeding num_palette");
#endif
@@ -1077,6 +1081,8 @@ void PNGAPI
png_read_png(png_structrp png_ptr, png_inforp info_ptr,
int transforms, voidp params)
{
+ png_debug(1, "in png_read_png");
+
if (png_ptr == NULL || info_ptr == NULL)
return;
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/pngrtran.c b/src/java.desktop/share/native/libsplashscreen/libpng/pngrtran.c
index 843eb5fff2a..a393de4b79d 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/pngrtran.c
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/pngrtran.c
@@ -29,7 +29,7 @@
* However, the following notice accompanied the original version of this
* file and, per its terms, should not be removed:
*
- * Copyright (c) 2018-2019 Cosmin Truta
+ * Copyright (c) 2018-2024 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -318,21 +318,20 @@ png_set_alpha_mode_fixed(png_structrp png_ptr, int mode,
int compose = 0;
png_fixed_point file_gamma;
- png_debug(1, "in png_set_alpha_mode");
+ png_debug(1, "in png_set_alpha_mode_fixed");
if (png_rtran_ok(png_ptr, 0) == 0)
return;
output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/);
- /* Validate the value to ensure it is in a reasonable range. The value
+ /* Validate the value to ensure it is in a reasonable range. The value
* is expected to be 1 or greater, but this range test allows for some
- * viewing correction values. The intent is to weed out users of this API
- * who use the inverse of the gamma value accidentally! Since some of these
- * values are reasonable this may have to be changed:
+ * viewing correction values. The intent is to weed out the API users
+ * who might use the inverse of the gamma value accidentally!
*
- * 1.6.x: changed from 0.07..3 to 0.01..100 (to accommodate the optimal 16-bit
- * gamma of 36, and its reciprocal.)
+ * In libpng 1.6.0, we changed from 0.07..3 to 0.01..100, to accommodate
+ * the optimal 16-bit gamma of 36 and its reciprocal.
*/
if (output_gamma < 1000 || output_gamma > 10000000)
png_error(png_ptr, "output gamma out of expected range");
@@ -469,7 +468,7 @@ png_set_quantize(png_structrp png_ptr, png_colorp palette,
int i;
png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr,
- (png_alloc_size_t)((png_uint_32)num_palette * (sizeof (png_byte))));
+ (png_alloc_size_t)num_palette);
for (i = 0; i < num_palette; i++)
png_ptr->quantize_index[i] = (png_byte)i;
}
@@ -486,7 +485,7 @@ png_set_quantize(png_structrp png_ptr, png_colorp palette,
/* Initialize an array to sort colors */
png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr,
- (png_alloc_size_t)((png_uint_32)num_palette * (sizeof (png_byte))));
+ (png_alloc_size_t)num_palette);
/* Initialize the quantize_sort array */
for (i = 0; i < num_palette; i++)
@@ -620,11 +619,9 @@ png_set_quantize(png_structrp png_ptr, png_colorp palette,
/* Initialize palette index arrays */
png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
- (png_alloc_size_t)((png_uint_32)num_palette *
- (sizeof (png_byte))));
+ (png_alloc_size_t)num_palette);
png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
- (png_alloc_size_t)((png_uint_32)num_palette *
- (sizeof (png_byte))));
+ (png_alloc_size_t)num_palette);
/* Initialize the sort array */
for (i = 0; i < num_palette; i++)
@@ -789,12 +786,11 @@ png_set_quantize(png_structrp png_ptr, png_colorp palette,
size_t num_entries = ((size_t)1 << total_bits);
png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr,
- (png_alloc_size_t)(num_entries * (sizeof (png_byte))));
+ (png_alloc_size_t)(num_entries));
- distance = (png_bytep)png_malloc(png_ptr, (png_alloc_size_t)(num_entries *
- (sizeof (png_byte))));
+ distance = (png_bytep)png_malloc(png_ptr, (png_alloc_size_t)num_entries);
- memset(distance, 0xff, num_entries * (sizeof (png_byte)));
+ memset(distance, 0xff, num_entries);
for (i = 0; i < num_palette; i++)
{
@@ -998,7 +994,7 @@ void PNGFAPI
png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action,
png_fixed_point red, png_fixed_point green)
{
- png_debug(1, "in png_set_rgb_to_gray");
+ png_debug(1, "in png_set_rgb_to_gray_fixed");
/* Need the IHDR here because of the check on color_type below. */
/* TODO: fix this */
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/pngrutil.c b/src/java.desktop/share/native/libsplashscreen/libpng/pngrutil.c
index 524297c5a10..5280140d12b 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/pngrutil.c
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/pngrutil.c
@@ -29,7 +29,7 @@
* However, the following notice accompanied the original version of this
* file and, per its terms, should not be removed:
*
- * Copyright (c) 2018-2022 Cosmin Truta
+ * Copyright (c) 2018-2024 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -54,7 +54,7 @@ png_get_uint_31(png_const_structrp png_ptr, png_const_bytep buf)
if (uval > PNG_UINT_31_MAX)
png_error(png_ptr, "PNG unsigned integer out of range");
- return (uval);
+ return uval;
}
#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_READ_cHRM_SUPPORTED)
@@ -168,7 +168,7 @@ png_read_sig(png_structrp png_ptr, png_inforp info_ptr)
if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check) != 0)
{
if (num_checked < 4 &&
- png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
+ png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4) != 0)
png_error(png_ptr, "Not a PNG file");
else
png_error(png_ptr, "PNG file corrupted by ASCII conversion");
@@ -199,7 +199,7 @@ png_read_chunk_header(png_structrp png_ptr)
/* Put the chunk name into png_ptr->chunk_name. */
png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(buf+4);
- png_debug2(0, "Reading %lx chunk, length = %lu",
+ png_debug2(0, "Reading chunk typeid = 0x%lx, length = %lu",
(unsigned long)png_ptr->chunk_name, (unsigned long)length);
/* Reset the crc and run it over the chunk name. */
@@ -266,10 +266,10 @@ png_crc_finish(png_structrp png_ptr, png_uint_32 skip)
else
png_chunk_error(png_ptr, "CRC error");
- return (1);
+ return 1;
}
- return (0);
+ return 0;
}
/* Compare the CRC stored in the PNG file with that calculated by libpng from
@@ -305,11 +305,11 @@ png_crc_error(png_structrp png_ptr)
if (need_crc != 0)
{
crc = png_get_uint_32(crc_bytes);
- return ((int)(crc != png_ptr->crc));
+ return crc != png_ptr->crc;
}
else
- return (0);
+ return 0;
}
#if defined(PNG_READ_iCCP_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) ||\
@@ -449,8 +449,7 @@ png_inflate_claim(png_structrp png_ptr, png_uint_32 owner)
png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
}
-#if ZLIB_VERNUM >= 0x1290 && \
- defined(PNG_SET_OPTION_SUPPORTED) && defined(PNG_IGNORE_ADLER32)
+#ifdef PNG_DISABLE_ADLER32_CHECK_SUPPORTED
if (((png_ptr->options >> PNG_IGNORE_ADLER32) & 3) == PNG_OPTION_ON)
/* Turn off validation of the ADLER32 checksum in IDAT chunks */
ret = inflateValidate(&png_ptr->zstream, 0);
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/pngset.c b/src/java.desktop/share/native/libsplashscreen/libpng/pngset.c
index 62612a02278..f53ab6fa1d1 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/pngset.c
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/pngset.c
@@ -29,7 +29,7 @@
* However, the following notice accompanied the original version of this
* file and, per its terms, should not be removed:
*
- * Copyright (c) 2018-2023 Cosmin Truta
+ * Copyright (c) 2018-2024 Cosmin Truta
* Copyright (c) 1998-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -791,11 +791,11 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
{
int i;
- png_debug1(1, "in %lx storage function", png_ptr == NULL ? 0xabadca11U :
- (unsigned long)png_ptr->chunk_name);
+ png_debug1(1, "in text storage function, chunk typeid = 0x%lx",
+ png_ptr == NULL ? 0xabadca11UL : (unsigned long)png_ptr->chunk_name);
if (png_ptr == NULL || info_ptr == NULL || num_text <= 0 || text_ptr == NULL)
- return(0);
+ return 0;
/* Make sure we have enough space in the "text" array in info_struct
* to hold all of the incoming text_ptr objects. This compare can't overflow
@@ -975,7 +975,7 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
png_debug1(3, "transferred text chunk %d", info_ptr->num_text);
}
- return(0);
+ return 0;
}
#endif
@@ -1091,6 +1091,8 @@ png_set_sPLT(png_const_structrp png_ptr,
{
png_sPLT_tp np;
+ png_debug1(1, "in %s storage function", "sPLT");
+
if (png_ptr == NULL || info_ptr == NULL || nentries <= 0 || entries == NULL)
return;
@@ -1565,7 +1567,7 @@ void PNGAPI
png_set_rows(png_const_structrp png_ptr, png_inforp info_ptr,
png_bytepp row_pointers)
{
- png_debug1(1, "in %s storage function", "rows");
+ png_debug(1, "in png_set_rows");
if (png_ptr == NULL || info_ptr == NULL)
return;
@@ -1584,6 +1586,8 @@ png_set_rows(png_const_structrp png_ptr, png_inforp info_ptr,
void PNGAPI
png_set_compression_buffer_size(png_structrp png_ptr, size_t size)
{
+ png_debug(1, "in png_set_compression_buffer_size");
+
if (png_ptr == NULL)
return;
@@ -1655,6 +1659,8 @@ void PNGAPI
png_set_user_limits(png_structrp png_ptr, png_uint_32 user_width_max,
png_uint_32 user_height_max)
{
+ png_debug(1, "in png_set_user_limits");
+
/* Images with dimensions larger than these limits will be
* rejected by png_set_IHDR(). To accept any PNG datastream
* regardless of dimensions, set both limits to 0x7fffffff.
@@ -1670,6 +1676,8 @@ png_set_user_limits(png_structrp png_ptr, png_uint_32 user_width_max,
void PNGAPI
png_set_chunk_cache_max(png_structrp png_ptr, png_uint_32 user_chunk_cache_max)
{
+ png_debug(1, "in png_set_chunk_cache_max");
+
if (png_ptr != NULL)
png_ptr->user_chunk_cache_max = user_chunk_cache_max;
}
@@ -1679,6 +1687,8 @@ void PNGAPI
png_set_chunk_malloc_max(png_structrp png_ptr,
png_alloc_size_t user_chunk_malloc_max)
{
+ png_debug(1, "in png_set_chunk_malloc_max");
+
if (png_ptr != NULL)
png_ptr->user_chunk_malloc_max = user_chunk_malloc_max;
}
diff --git a/src/java.desktop/share/native/libsplashscreen/libpng/pngtrans.c b/src/java.desktop/share/native/libsplashscreen/libpng/pngtrans.c
index 89a62191b6f..2350057e70e 100644
--- a/src/java.desktop/share/native/libsplashscreen/libpng/pngtrans.c
+++ b/src/java.desktop/share/native/libsplashscreen/libpng/pngtrans.c
@@ -29,7 +29,7 @@
* However, the following notice accompanied the original version of this
* file and, per its terms, should not be removed:
*
- * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2018-2024 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -131,10 +131,10 @@ png_set_interlace_handling(png_structrp png_ptr)
if (png_ptr != 0 && png_ptr->interlaced != 0)
{
png_ptr->transformations |= PNG_INTERLACE;
- return (7);
+ return 7;
}
- return (1);
+ return 1;
}
#endif
@@ -526,6 +526,8 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
png_bytep dp = row; /* destination pointer */
png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
+ png_debug(1, "in png_do_strip_channel");
+
/* At the start sp will point to the first byte to copy and dp to where
* it is copied to. ep always points just beyond the end of the row, so
* the loop simply copies (channels-1) channels until sp reaches ep.
@@ -726,6 +728,8 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
void /* PRIVATE */
png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
{
+ png_debug(1, "in png_do_check_palette_indexes");
+
if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
{
@@ -736,7 +740,7 @@ png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
* forms produced on either GCC or MSVC.
*/
int padding = PNG_PADBITS(row_info->pixel_depth, row_info->width);
- png_bytep rp = png_ptr->row_buf + row_info->rowbytes - 1;
+ png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
switch (row_info->bit_depth)
{
@@ -861,7 +865,7 @@ png_voidp PNGAPI
png_get_user_transform_ptr(png_const_structrp png_ptr)
{
if (png_ptr == NULL)
- return (NULL);
+ return NULL;
return png_ptr->user_transform_ptr;
}
diff --git a/src/java.sql/share/classes/java/sql/DatabaseMetaData.java b/src/java.sql/share/classes/java/sql/DatabaseMetaData.java
index 6f63c2989b8..f4cb8787b5f 100644
--- a/src/java.sql/share/classes/java/sql/DatabaseMetaData.java
+++ b/src/java.sql/share/classes/java/sql/DatabaseMetaData.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1996, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -1215,7 +1215,7 @@ boolean dataDefinitionIgnoredInTransactions()
* Only procedure descriptions matching the schema and
* procedure name criteria are returned. They are ordered by
* {@code PROCEDURE_CAT}, {@code PROCEDURE_SCHEM},
- * {@code PROCEDURE_NAME} and {@code SPECIFIC_ NAME}.
+ * {@code PROCEDURE_NAME} and {@code SPECIFIC_NAME}.
*
* Each procedure description has the following columns:
*
@@ -3289,7 +3289,7 @@ ResultSet getClientInfoProperties()
* function name criteria are returned. They are ordered by
* {@code FUNCTION_CAT}, {@code FUNCTION_SCHEM},
* {@code FUNCTION_NAME} and
- * {@code SPECIFIC_ NAME}.
+ * {@code SPECIFIC_NAME}.
*
* Each function description has the following columns:
*
@@ -3339,7 +3339,7 @@ ResultSet getFunctions(String catalog, String schemaPattern,
* parameter name criteria are returned. They are ordered by
* {@code FUNCTION_CAT}, {@code FUNCTION_SCHEM},
* {@code FUNCTION_NAME} and
- * {@code SPECIFIC_ NAME}. Within this, the return value,
+ * {@code SPECIFIC_NAME}. Within this, the return value,
* if any, is first. Next are the parameter descriptions in call
* order. The column descriptions follow in column number order.
*
@@ -3358,7 +3358,7 @@ ResultSet getFunctions(String catalog, String schemaPattern,
* - functionColumnIn - IN parameter
*
- functionColumnInOut - INOUT parameter
*
- functionColumnOut - OUT parameter
- *
- functionColumnReturn - function return value
+ *
- functionReturn - function return value
*
- functionColumnResult - Indicates that the parameter or column
* is a column in the {@code ResultSet}
*
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/api/JavacTrees.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/api/JavacTrees.java
index 081367fa26a..45c76071f8b 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/api/JavacTrees.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/api/JavacTrees.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -1059,6 +1059,11 @@ public String getText() {
return "";
}
+ @Override
+ public JCDiagnostic.DiagnosticPosition getPos() {
+ return null;
+ }
+
@Override
public int getSourcePos(int index) {
return offset + index;
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/DeferredLintHandler.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/DeferredLintHandler.java
index 94d121ad04d..9fba9b5318b 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/DeferredLintHandler.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/DeferredLintHandler.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -52,10 +52,15 @@ public static DeferredLintHandler instance(Context context) {
return instance;
}
+ /** The Lint to use when {@link #immediate(Lint)} is used,
+ * instead of {@link #setPos(DiagnosticPosition)}. */
+ private Lint immediateLint;
+
@SuppressWarnings("this-escape")
protected DeferredLintHandler(Context context) {
context.put(deferredLintHandlerKey, this);
this.currentPos = IMMEDIATE_POSITION;
+ immediateLint = Lint.instance(context);
}
/**An interface for deferred lint reporting - loggers passed to
@@ -63,7 +68,7 @@ protected DeferredLintHandler(Context context) {
* {@link #flush(DiagnosticPosition) } is invoked.
*/
public interface LintLogger {
- void report();
+ void report(Lint lint);
}
private DiagnosticPosition currentPos;
@@ -77,7 +82,7 @@ public interface LintLogger {
*/
public void report(LintLogger logger) {
if (currentPos == IMMEDIATE_POSITION) {
- logger.report();
+ logger.report(immediateLint);
} else {
ListBuffer
loggers = loggersQueue.get(currentPos);
if (loggers == null) {
@@ -89,11 +94,11 @@ public void report(LintLogger logger) {
/**Invoke all {@link LintLogger}s that were associated with the provided {@code pos}.
*/
- public void flush(DiagnosticPosition pos) {
+ public void flush(DiagnosticPosition pos, Lint lint) {
ListBuffer loggers = loggersQueue.get(pos);
if (loggers != null) {
for (LintLogger lintLogger : loggers) {
- lintLogger.report();
+ lintLogger.report(lint);
}
loggersQueue.remove(pos);
}
@@ -112,7 +117,8 @@ public DiagnosticPosition setPos(DiagnosticPosition currentPos) {
/**{@link LintLogger}s passed to subsequent invocations of
* {@link #report(LintLogger) } will be invoked immediately.
*/
- public DiagnosticPosition immediate() {
+ public DiagnosticPosition immediate(Lint lint) {
+ immediateLint = lint;
return setPos(IMMEDIATE_POSITION);
}
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Lint.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Lint.java
index 92b2a773ffa..d024dc75225 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Lint.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Lint.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -180,6 +180,12 @@ public enum LintCategory {
*/
CLASSFILE("classfile"),
+ /**
+ * Warn about"dangling" documentation comments,
+ * not attached to any declaration.
+ */
+ DANGLING_DOC_COMMENTS("dangling-doc-comments"),
+
/**
* Warn about use of deprecated items.
*/
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java
index 5acb4c384eb..702b51d3b96 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java
@@ -1120,6 +1120,7 @@ private String className(Symbol sym, boolean longform) {
s += String.valueOf(sym.hashCode());
return s;
} else if (longform) {
+ sym.apiComplete();
return sym.getQualifiedName().toString();
} else {
return sym.name.toString();
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Annotate.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Annotate.java
index 71c9d59cb27..40a2da35488 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Annotate.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Annotate.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -254,7 +254,7 @@ public void annotateLater(List annotations, Env local
DiagnosticPosition prevLintPos =
deferPos != null
? deferredLintHandler.setPos(deferPos)
- : deferredLintHandler.immediate();
+ : deferredLintHandler.immediate(lint);
Lint prevLint = deferPos != null ? null : chk.setLint(lint);
try {
if (s.hasAnnotations() && annotations.nonEmpty())
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java
index 0d6e39c8b06..d0f3ae7464a 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java
@@ -979,7 +979,7 @@ public void visitMethodDef(JCMethodDecl tree) {
env.info.ctorPrologue = false;
MethodSymbol prevMethod = chk.setMethod(m);
try {
- deferredLintHandler.flush(tree.pos());
+ deferredLintHandler.flush(tree.pos(), lint);
chk.checkDeprecatedAnnotation(tree.pos(), m);
@@ -1280,7 +1280,7 @@ public void visitVarDef(JCVariableDecl tree) {
try {
v.getConstValue(); // ensure compile-time constant initializer is evaluated
- deferredLintHandler.flush(tree.pos());
+ deferredLintHandler.flush(tree.pos(), lint);
chk.checkDeprecatedAnnotation(tree.pos(), v);
if (tree.init != null) {
@@ -5297,7 +5297,7 @@ private void attribWithLint(TypeSymbol sym, Consumer> attrib) {
JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
try {
- deferredLintHandler.flush(env.tree.pos());
+ deferredLintHandler.flush(env.tree.pos(), lint);
attrib.accept(env);
} finally {
log.useSource(prev);
@@ -5472,7 +5472,7 @@ void attribClass(ClassSymbol c) throws CompletionFailure {
}
}
- deferredLintHandler.flush(env.tree);
+ deferredLintHandler.flush(env.tree, env.info.lint);
env.info.returnResult = null;
// java.lang.Enum may not be subclassed by a non-enum
if (st.tsym == syms.enumSym &&
@@ -5522,7 +5522,7 @@ public void visitModuleDef(JCModuleDecl tree) {
chk.checkDeprecatedAnnotation(tree, msym);
try {
- deferredLintHandler.flush(tree.pos());
+ deferredLintHandler.flush(tree.pos(), lint);
} finally {
chk.setLint(prevLint);
}
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java
index 1e717b2b034..e909afc0bdf 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java
@@ -673,7 +673,7 @@ public void checkRedundantCast(Env env, final JCTypeCast tree) {
&& types.isSameType(tree.expr.type, tree.clazz.type)
&& !(ignoreAnnotatedCasts && TreeInfo.containsTypeAnnotation(tree.clazz))
&& !is292targetTypeCast(tree)) {
- deferredLintHandler.report(() -> {
+ deferredLintHandler.report(_l -> {
if (lint.isEnabled(LintCategory.CAST))
log.warning(LintCategory.CAST,
tree.pos(), Warnings.RedundantCast(tree.clazz.type));
@@ -1350,7 +1350,7 @@ && checkDisjoint(pos, flags,
private void warnOnExplicitStrictfp(DiagnosticPosition pos) {
DiagnosticPosition prevLintPos = deferredLintHandler.setPos(pos);
try {
- deferredLintHandler.report(() -> {
+ deferredLintHandler.report(_l -> {
if (lint.isEnabled(LintCategory.STRICTFP)) {
log.warning(LintCategory.STRICTFP,
pos, Warnings.Strictfp); }
@@ -3809,13 +3809,13 @@ void checkDeprecated(Supplier pos, final Symbol other, final
|| s.isDeprecated() && !other.isDeprecated())
&& (s.outermostClass() != other.outermostClass() || s.outermostClass() == null)
&& s.kind != Kind.PCK) {
- deferredLintHandler.report(() -> warnDeprecated(pos.get(), s));
+ deferredLintHandler.report(_l -> warnDeprecated(pos.get(), s));
}
}
void checkSunAPI(final DiagnosticPosition pos, final Symbol s) {
if ((s.flags() & PROPRIETARY) != 0) {
- deferredLintHandler.report(() -> {
+ deferredLintHandler.report(_l -> {
log.mandatoryWarning(pos, Warnings.SunProprietary(s));
});
}
@@ -3834,10 +3834,10 @@ void checkPreview(DiagnosticPosition pos, Symbol other, Symbol s) {
log.error(pos, Errors.IsPreview(s));
} else {
preview.markUsesPreview(pos);
- deferredLintHandler.report(() -> warnPreviewAPI(pos, Warnings.IsPreview(s)));
+ deferredLintHandler.report(_l -> warnPreviewAPI(pos, Warnings.IsPreview(s)));
}
} else {
- deferredLintHandler.report(() -> warnPreviewAPI(pos, Warnings.IsPreviewReflective(s)));
+ deferredLintHandler.report(_l -> warnPreviewAPI(pos, Warnings.IsPreviewReflective(s)));
}
}
if (preview.declaredUsingPreviewFeature(s)) {
@@ -3846,14 +3846,14 @@ void checkPreview(DiagnosticPosition pos, Symbol other, Symbol s) {
//If "s" is compiled from source, then there was an error for it already;
//if "s" is from classfile, there already was an error for the classfile.
preview.markUsesPreview(pos);
- deferredLintHandler.report(() -> warnDeclaredUsingPreview(pos, s));
+ deferredLintHandler.report(_l -> warnDeclaredUsingPreview(pos, s));
}
}
}
void checkRestricted(DiagnosticPosition pos, Symbol s) {
if (s.kind == MTH && (s.flags() & RESTRICTED) != 0) {
- deferredLintHandler.report(() -> warnRestrictedAPI(pos, s));
+ deferredLintHandler.report(_l -> warnRestrictedAPI(pos, s));
}
}
@@ -4102,7 +4102,7 @@ void checkDivZero(final DiagnosticPosition pos, Symbol operator, Type operand) {
int opc = ((OperatorSymbol)operator).opcode;
if (opc == ByteCodes.idiv || opc == ByteCodes.imod
|| opc == ByteCodes.ldiv || opc == ByteCodes.lmod) {
- deferredLintHandler.report(() -> warnDivZero(pos));
+ deferredLintHandler.report(_l -> warnDivZero(pos));
}
}
}
@@ -4115,7 +4115,7 @@ void checkDivZero(final DiagnosticPosition pos, Symbol operator, Type operand) {
*/
void checkLossOfPrecision(final DiagnosticPosition pos, Type found, Type req) {
if (found.isNumeric() && req.isNumeric() && !types.isAssignable(found, req)) {
- deferredLintHandler.report(() -> {
+ deferredLintHandler.report(_l -> {
if (lint.isEnabled(LintCategory.LOSSY_CONVERSIONS))
log.warning(LintCategory.LOSSY_CONVERSIONS,
pos, Warnings.PossibleLossOfPrecision(found, req));
@@ -4319,7 +4319,7 @@ void checkDefaultConstructor(ClassSymbol c, DiagnosticPosition pos) {
// Warning may be suppressed by
// annotations; check again for being
// enabled in the deferred context.
- deferredLintHandler.report(() -> {
+ deferredLintHandler.report(_l -> {
if (lint.isEnabled(LintCategory.MISSING_EXPLICIT_CTOR))
log.warning(LintCategory.MISSING_EXPLICIT_CTOR,
pos, Warnings.MissingExplicitCtor(c, pkg, modle));
@@ -4654,7 +4654,7 @@ private void checkVisible(DiagnosticPosition pos, Symbol what, PackageSymbol inP
void checkModuleExists(final DiagnosticPosition pos, ModuleSymbol msym) {
if (msym.kind != MDL) {
- deferredLintHandler.report(() -> {
+ deferredLintHandler.report(_l -> {
if (lint.isEnabled(LintCategory.MODULE))
log.warning(LintCategory.MODULE, pos, Warnings.ModuleNotFound(msym));
});
@@ -4664,7 +4664,7 @@ void checkModuleExists(final DiagnosticPosition pos, ModuleSymbol msym) {
void checkPackageExistsForOpens(final DiagnosticPosition pos, PackageSymbol packge) {
if (packge.members().isEmpty() &&
((packge.flags() & Flags.HAS_RESOURCE) == 0)) {
- deferredLintHandler.report(() -> {
+ deferredLintHandler.report(_l -> {
if (lint.isEnabled(LintCategory.OPENS))
log.warning(pos, Warnings.PackageEmptyOrNotFound(packge));
});
@@ -4673,7 +4673,7 @@ void checkPackageExistsForOpens(final DiagnosticPosition pos, PackageSymbol pack
void checkModuleRequires(final DiagnosticPosition pos, final RequiresDirective rd) {
if ((rd.module.flags() & Flags.AUTOMATIC_MODULE) != 0) {
- deferredLintHandler.report(() -> {
+ deferredLintHandler.report(_l -> {
if (rd.isTransitive() && lint.isEnabled(LintCategory.REQUIRES_TRANSITIVE_AUTOMATIC)) {
log.warning(pos, Warnings.RequiresTransitiveAutomatic);
} else if (lint.isEnabled(LintCategory.REQUIRES_AUTOMATIC)) {
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Flow.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Flow.java
index eda2772fb75..da008bc4b53 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Flow.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Flow.java
@@ -470,7 +470,8 @@ public void visitPackageDef(JCPackageDecl tree) {
protected void scanSyntheticBreak(TreeMaker make, JCTree swtch) {
if (swtch.hasTag(SWITCH_EXPRESSION)) {
- JCYield brk = make.at(Position.NOPOS).Yield(null);
+ JCYield brk = make.at(Position.NOPOS).Yield(make.Erroneous()
+ .setType(swtch.type));
brk.target = swtch;
scan(brk);
} else {
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TypeEnter.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TypeEnter.java
index af5f3dccdd6..9366e802b16 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TypeEnter.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TypeEnter.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -348,7 +348,7 @@ private void resolveImports(JCCompilationUnit tree, Env env) {
ImportFilter prevStaticImportFilter = staticImportFilter;
ImportFilter prevTypeImportFilter = typeImportFilter;
- DiagnosticPosition prevLintPos = deferredLintHandler.immediate();
+ DiagnosticPosition prevLintPos = deferredLintHandler.immediate(lint);
Lint prevLint = chk.setLint(lint);
Env prevEnv = this.env;
try {
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavaTokenizer.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavaTokenizer.java
index 88de2333069..403cb30921a 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavaTokenizer.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavaTokenizer.java
@@ -34,6 +34,8 @@
import com.sun.tools.javac.parser.Tokens.Comment.CommentStyle;
import com.sun.tools.javac.resources.CompilerProperties.Errors;
import com.sun.tools.javac.resources.CompilerProperties.Warnings;
+import com.sun.tools.javac.tree.EndPosTable;
+import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.util.*;
import com.sun.tools.javac.util.JCDiagnostic.*;
@@ -1207,6 +1209,8 @@ protected static class BasicComment extends PositionTrackingReader implements Co
*/
CommentStyle cs;
+ DiagnosticPosition pos;
+
/**
* true if comment contains @deprecated at beginning of a line.
*/
@@ -1228,6 +1232,12 @@ protected static class BasicComment extends PositionTrackingReader implements Co
protected BasicComment(CommentStyle cs, UnicodeReader reader, int pos, int endPos) {
super(reader, pos, endPos);
this.cs = cs;
+ this.pos = new SimpleDiagnosticPosition(pos) {
+ @Override
+ public int getEndPosition(EndPosTable endPosTable) {
+ return endPos;
+ }
+ };
}
/**
@@ -1239,6 +1249,10 @@ public String getText() {
return null;
}
+ public DiagnosticPosition getPos() {
+ return pos;
+ }
+
/**
* Return buffer position in original buffer mapped from buffer position in comment.
*
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java
index bc53b18b3a5..4eb7aa7c17d 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java
@@ -111,6 +111,12 @@ public class JavacParser implements Parser {
/** End position mappings container */
protected final AbstractEndPosTable endPosTable;
+ /** A map associating "other nearby documentation comments"
+ * with the preferred documentation comment for a declaration. */
+ protected Map> danglingComments = new HashMap<>();
+ /** Handler for deferred diagnostics. */
+ protected final DeferredLintHandler deferredLintHandler;
+
// Because of javac's limited lookahead, some contexts are ambiguous in
// the presence of type annotations even though they are not ambiguous
// in the absence of type annotations. Consider this code:
@@ -181,6 +187,7 @@ protected JavacParser(ParserFactory fac,
this.names = fac.names;
this.source = fac.source;
this.preview = fac.preview;
+ this.deferredLintHandler = fac.deferredLintHandler;
this.allowStringFolding = fac.options.getBoolean("allowStringFolding", true);
this.keepDocComments = keepDocComments;
this.parseModuleInfo = parseModuleInfo;
@@ -205,6 +212,7 @@ protected JavacParser(JavacParser parser,
this.names = parser.names;
this.source = parser.source;
this.preview = parser.preview;
+ this.deferredLintHandler = parser.deferredLintHandler;
this.allowStringFolding = parser.allowStringFolding;
this.keepDocComments = parser.keepDocComments;
this.parseModuleInfo = false;
@@ -551,16 +559,119 @@ protected void checkNoMods(int pos, long mods) {
*/
private final DocCommentTable docComments;
+ /** Record nearby documentation comments against the
+ * primary documentation comment for a declaration.
+ *
+ * Dangling documentation comments are handled as follows.
+ * 1. {@code Scanner} adds all doc comments to a queue of
+ * recent doc comments. The queue is flushed whenever
+ * it is known that the recent doc comments should be
+ * ignored and should not cause any warnings.
+ * 2. The primary documentation comment is the one obtained
+ * from the first token of any declaration.
+ * (using {@code token.getDocComment()}.
+ * 3. At the end of the "signature" of the declaration
+ * (that is, before any initialization or body for the
+ * declaration) any other "recent" comments are saved
+ * in a map using the primary comment as a key,
+ * using this method, {@code saveDanglingComments}.
+ * 4. When the tree node for the declaration is finally
+ * available, and the primary comment, if any,
+ * is "attached", (in {@link #attach}) any related
+ * dangling comments are also attached to the tree node
+ * by registering them using the {@link #deferredLintHandler}.
+ * 5. (Later) Warnings may be generated for the dangling
+ * comments, subject to the {@code -Xlint} and
+ * {@code @SuppressWarnings}.
+ *
+ * @param dc the primary documentation comment
+ */
+ private void saveDanglingDocComments(Comment dc) {
+ var recentComments = S.getDocComments();
+
+ switch (recentComments.size()) {
+ case 0:
+ // no recent comments
+ return;
+
+ case 1:
+ if (recentComments.peek() == dc) {
+ // no other recent comments
+ recentComments.remove();
+ return;
+ }
+ }
+
+ var lb = new ListBuffer();
+ while (!recentComments.isEmpty()) {
+ var c = recentComments.remove();
+ if (c != dc) {
+ lb.add(c);
+ }
+ }
+ danglingComments.put(dc, lb.toList());
+ }
+
/** Make an entry into docComments hashtable,
* provided flag keepDocComments is set and given doc comment is non-null.
+ * If there are any related "dangling comments", register
+ * diagnostics to be handled later, when @SuppressWarnings
+ * can be taken into account.
+ *
* @param tree The tree to be used as index in the hashtable
* @param dc The doc comment to associate with the tree, or null.
*/
protected void attach(JCTree tree, Comment dc) {
if (keepDocComments && dc != null) {
-// System.out.println("doc comment = ");System.out.println(dc);//DEBUG
docComments.putComment(tree, dc);
}
+ reportDanglingComments(tree, dc);
+ }
+
+ /** Reports all dangling comments associated with the
+ * primary comment for a declaration against the position
+ * of the tree node for a declaration.
+ *
+ * @param tree the tree node for the declaration
+ * @param dc the primary comment for the declaration
+ */
+ void reportDanglingComments(JCTree tree, Comment dc) {
+ var list = danglingComments.remove(dc);
+ if (list != null) {
+ var prevPos = deferredLintHandler.setPos(tree);
+ try {
+ list.forEach(this::reportDanglingDocComment);
+ } finally {
+ deferredLintHandler.setPos(prevPos);
+ }
+ }
+ }
+
+ /**
+ * Reports an individual dangling comment using the {@link #deferredLintHandler}.
+ * The comment may or not may generate an actual diagnostic, depending on
+ * the settings for {@code -Xlint} and/or {@code @SuppressWarnings}.
+ *
+ * @param c the comment
+ */
+ void reportDanglingDocComment(Comment c) {
+ var pos = c.getPos();
+ if (pos != null) {
+ deferredLintHandler.report(lint -> {
+ if (lint.isEnabled(Lint.LintCategory.DANGLING_DOC_COMMENTS)) {
+ log.warning(Lint.LintCategory.DANGLING_DOC_COMMENTS,
+ pos, Warnings.DanglingDocComment);
+ }
+ });
+ }
+ }
+
+ /**
+ * Ignores any recent documentation comments found by the scanner,
+ * such as those that cannot be associated with a nearby declaration.
+ */
+ private void ignoreDanglingComments() {
+ S.getDocComments().clear();
}
/* -------- source positions ------- */
@@ -2626,6 +2737,7 @@ JCNewClass classCreatorRest(int newpos,
List args = arguments();
JCClassDecl body = null;
if (token.kind == LBRACE) {
+ ignoreDanglingComments(); // ignore any comments from before the '{'
int pos = token.pos;
List defs = classInterfaceOrRecordBody(names.empty, false, false);
JCModifiers mods = F.at(Position.NOPOS).Modifiers(0);
@@ -2678,6 +2790,7 @@ JCExpression parExpression() {
*/
JCBlock block(int pos, long flags) {
accept(LBRACE);
+ ignoreDanglingComments(); // ignore any comments from before the '{'
List stats = blockStatements();
JCBlock t = F.at(pos).Block(flags, stats);
while (token.kind == CASE || token.kind == DEFAULT) {
@@ -2709,6 +2822,7 @@ List blockStatements() {
ListBuffer stats = new ListBuffer<>();
while (true) {
List stat = blockStatement();
+ ignoreDanglingComments(); // ignore comments not consumed by the statement
if (stat.isEmpty()) {
return stats.toList();
} else {
@@ -2780,7 +2894,7 @@ List blockStatement() {
return List.of(classOrRecordOrInterfaceOrEnumDeclaration(mods, dc));
} else {
JCExpression t = parseType(true);
- return localVariableDeclarations(mods, t);
+ return localVariableDeclarations(mods, t, dc);
}
}
case ABSTRACT: case STRICTFP: {
@@ -2866,8 +2980,8 @@ List blockStatement() {
}
}
}
+ dc = token.docComment();
if (isRecordStart() && allowRecords) {
- dc = token.docComment();
return List.of(recordDeclaration(F.at(pos).Modifiers(0), dc));
} else {
Token prevToken = token;
@@ -2880,7 +2994,7 @@ List blockStatement() {
pos = token.pos;
JCModifiers mods = F.at(Position.NOPOS).Modifiers(0);
F.at(pos);
- return localVariableDeclarations(mods, t);
+ return localVariableDeclarations(mods, t, dc);
} else {
// This Exec is an "ExpressionStatement"; it subsumes the terminating semicolon
t = checkExprStat(t);
@@ -2891,7 +3005,11 @@ List blockStatement() {
}
}
//where
- private List localVariableDeclarations(JCModifiers mods, JCExpression type) {
+ private List localVariableDeclarations(JCModifiers mods, JCExpression type, Comment dc) {
+ if (dc != null) {
+ // ignore a well-placed doc comment, but save any misplaced ones
+ saveDanglingDocComments(dc);
+ }
ListBuffer stats =
variableDeclarators(mods, type, new ListBuffer<>(), true);
// A "LocalVariableDeclarationStatement" subsumes the terminating semicolon
@@ -2919,6 +3037,7 @@ private List localVariableDeclarations(JCModifiers mods, JCExpressi
* | ";"
*/
public JCStatement parseSimpleStatement() {
+ ignoreDanglingComments(); // ignore comments before statement
int pos = token.pos;
switch (token.kind) {
case LBRACE:
@@ -3649,6 +3768,8 @@ JCVariableDecl variableDeclaratorRest(int pos, JCModifiers mods, JCExpression ty
name = names.empty;
}
+ saveDanglingDocComments(dc);
+
if (token.kind == EQ) {
nextToken();
init = variableInitializer();
@@ -4221,6 +4342,9 @@ protected JCClassDecl classDeclaration(JCModifiers mods, Comment dc) {
implementing = typeList();
}
List permitting = permitsClause(mods, "class");
+
+ saveDanglingDocComments(dc);
+
List defs = classInterfaceOrRecordBody(name, false, false);
JCClassDecl result = toP(F.at(pos).ClassDef(
mods, name, typarams, extending, implementing, permitting, defs));
@@ -4243,6 +4367,9 @@ protected JCClassDecl recordDeclaration(JCModifiers mods, Comment dc) {
nextToken();
implementing = typeList();
}
+
+ saveDanglingDocComments(dc);
+
List defs = classInterfaceOrRecordBody(name, false, true);
java.util.List fields = new ArrayList<>();
for (JCVariableDecl field : headerFields) {
@@ -4302,6 +4429,9 @@ protected JCClassDecl interfaceDeclaration(JCModifiers mods, Comment dc) {
extending = typeList();
}
List permitting = permitsClause(mods, "interface");
+
+ saveDanglingDocComments(dc);
+
List defs;
defs = classInterfaceOrRecordBody(name, true, false);
JCClassDecl result = toP(F.at(pos).ClassDef(
@@ -4347,6 +4477,8 @@ protected JCClassDecl enumDeclaration(JCModifiers mods, Comment dc) {
implementing = typeList();
}
+ saveDanglingDocComments(dc);
+
List defs = enumBody(name);
mods.flags |= Flags.ENUM;
JCClassDecl result = toP(F.at(pos).
@@ -4474,8 +4606,12 @@ JCTree enumeratorDeclaration(Name enumName) {
int identPos = token.pos;
Name name = ident();
int createPos = token.pos;
+
+ saveDanglingDocComments(dc);
+
List args = (token.kind == LPAREN)
? arguments() : List.nil();
+
JCClassDecl body = null;
if (token.kind == LBRACE) {
JCModifiers mods1 = F.at(Position.NOPOS).Modifiers(Flags.ENUM);
@@ -4580,6 +4716,7 @@ protected List classOrInterfaceOrRecordBodyDeclaration(JCModifiers mods,
} else if (isRecord && (mods.flags & Flags.STATIC) == 0) {
log.error(DiagnosticFlag.SYNTAX, token.pos, Errors.InstanceInitializerNotAllowedInRecords);
}
+ ignoreDanglingComments(); // no declaration with which dangling comments can be associated
return List.of(block(pos, mods.flags));
} else {
return constructorOrMethodOrFieldDeclaration(mods, className, isInterface, isRecord, dc);
@@ -4857,6 +4994,9 @@ protected JCTree methodDeclaratorRest(int pos,
thrown = qualidentList(true);
}
}
+
+ saveDanglingDocComments(dc);
+
JCBlock body = null;
JCExpression defaultValue;
if (token.kind == LBRACE) {
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Lexer.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Lexer.java
index 2223999bebe..bff4e027db7 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Lexer.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Lexer.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -25,6 +25,8 @@
package com.sun.tools.javac.parser;
+import java.util.Queue;
+
import com.sun.tools.javac.parser.Tokens.*;
import com.sun.tools.javac.util.Position.LineMap;
@@ -89,4 +91,16 @@ public interface Lexer {
* @return a LineMap
*/
LineMap getLineMap();
+
+ /**
+ * Returns a queue for the documentation comments encountered
+ * in a compilation unit.
+ *
+ * Comments may be added to this queue by the implementation;
+ * clients may remove them from the queue as they are analyzed.
+ *
+ * Note: all comments may also be associated with the following
+ * token.
+ */
+ Queue getDocComments();
}
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/ParserFactory.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/ParserFactory.java
index d27a785e363..3c07c382aa3 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/ParserFactory.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/ParserFactory.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -27,6 +27,8 @@
import java.util.Locale;
+import com.sun.tools.javac.code.DeferredLintHandler;
+import com.sun.tools.javac.code.Lint;
import com.sun.tools.javac.code.Preview;
import com.sun.tools.javac.code.Source;
import com.sun.tools.javac.tree.DocTreeMaker;
@@ -68,6 +70,7 @@ public static ParserFactory instance(Context context) {
final Options options;
final ScannerFactory scannerFactory;
final Locale locale;
+ final DeferredLintHandler deferredLintHandler;
@SuppressWarnings("this-escape")
protected ParserFactory(Context context) {
@@ -83,6 +86,7 @@ protected ParserFactory(Context context) {
this.options = Options.instance(context);
this.scannerFactory = ScannerFactory.instance(context);
this.locale = context.get(Locale.class);
+ this.deferredLintHandler = DeferredLintHandler.instance(context);
}
public JavacParser newParser(CharSequence input, boolean keepDocComments, boolean keepEndPos, boolean keepLineMap) {
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Scanner.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Scanner.java
index 3cfb8b9ddbe..a182c74b07b 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Scanner.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Scanner.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -26,8 +26,10 @@
package com.sun.tools.javac.parser;
import java.nio.*;
+import java.util.ArrayDeque;
import java.util.List;
import java.util.ArrayList;
+import java.util.Queue;
import com.sun.tools.javac.util.Position.LineMap;
import static com.sun.tools.javac.parser.Tokens.*;
@@ -58,6 +60,11 @@ public class Scanner implements Lexer {
private final JavaTokenizer tokenizer;
+ /** Queue of recently seen documentation comments.
+ * It is assumed the queue will typically be small.
+ */
+ private final Queue docComments = new ArrayDeque<>();
+
/**
* Create a scanner from the input array. This method might
* modify the array. To avoid copying the input array, ensure
@@ -115,6 +122,15 @@ public void nextToken() {
token = savedTokens.remove(0);
} else {
token = tokenizer.readToken();
+ if (token.comments != null) {
+ for (var c : token.comments) {
+ switch (c.getStyle()) {
+ case JAVADOC -> {
+ docComments.add(c);
+ }
+ }
+ }
+ }
}
}
@@ -129,6 +145,11 @@ public LineMap getLineMap() {
return tokenizer.getLineMap();
}
+ @Override
+ public Queue getDocComments() {
+ return docComments;
+ }
+
public int errPos() {
return tokenizer.errPos();
}
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Tokens.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Tokens.java
index b6be0a84b7d..a05d48d320b 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Tokens.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/Tokens.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -280,6 +280,7 @@ enum CommentStyle {
}
String getText();
+ JCDiagnostic.DiagnosticPosition getPos();
int getSourcePos(int index);
CommentStyle getStyle();
boolean isDeprecated();
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/VirtualParser.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/VirtualParser.java
index 1d716f75a90..f32c1bf4756 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/VirtualParser.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/VirtualParser.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -34,6 +34,7 @@
import com.sun.tools.javac.util.Position.LineMap;
import java.util.Optional;
+import java.util.Queue;
import java.util.function.Consumer;
import java.util.function.Function;
@@ -146,6 +147,11 @@ public Token split() {
return token;
}
+ @Override
+ public Queue getDocComments() {
+ return S.getDocComments();
+ }
+
@Override
public int errPos() {
return S.errPos();
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties
index 273c5bef7b4..26c16ebdc2c 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties
@@ -1869,6 +1869,9 @@ compiler.warn.lintOption=\
compiler.warn.constant.SVUID=\
serialVersionUID must be constant in class {0}
+compiler.warn.dangling.doc.comment=\
+ documentation comment is not attached to any declaration
+
# 0: path
compiler.warn.dir.path.element.not.found=\
bad path element "{0}": no such directory
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/javac.properties b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/javac.properties
index 7893d328afa..0566272ca1b 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/javac.properties
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/javac.properties
@@ -1,5 +1,5 @@
#
-# Copyright (c) 1999, 2022, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -189,6 +189,9 @@ javac.opt.Xlint.desc.cast=\
javac.opt.Xlint.desc.classfile=\
Warn about issues related to classfile contents.
+javac.opt.Xlint.desc.dangling-doc-comments=\
+ Warn about dangling documentation comments, not attached to any declaration.
+
javac.opt.Xlint.desc.missing-explicit-ctor=\
Warn about missing explicit constructors in public and protected classes in exported packages.
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/DocTreeMaker.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/DocTreeMaker.java
index afa590240e2..c729b6ff832 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/DocTreeMaker.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/tree/DocTreeMaker.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -218,6 +218,11 @@ public String getText() {
return null;
}
+ @Override
+ public JCDiagnostic.DiagnosticPosition getPos() {
+ return null;
+ }
+
@Override
public int getSourcePos(int index) {
return Position.NOPOS;
diff --git a/src/jdk.compiler/share/classes/module-info.java b/src/jdk.compiler/share/classes/module-info.java
index 9826b3f576b..9b12171ef6d 100644
--- a/src/jdk.compiler/share/classes/module-info.java
+++ b/src/jdk.compiler/share/classes/module-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -153,6 +153,8 @@
* from other files
*