8319324: FFM: Reformat javadocs

src/java.base/share/classes/java/lang/foreign/AddressLayout.java

@@ -35,16 +35,16 @@
 import java.util.Optional;
 
 /**
- * A value layout used to model the address of some region of memory.  The carrier
- * associated with an address layout is {@code MemorySegment.class}.  The size and
+ * A value layout used to model the address of some region of memory. The carrier
+ * associated with an address layout is {@code MemorySegment.class}. The size and
  * alignment of an address layout are platform-dependent (e.g. on a 64-bit platform,
  * the size and alignment of an address layout are set to 8 bytes).
  * <p>
  * An address layout may optionally feature a {@linkplain #targetLayout() target layout}.
  * An address layout with target layout {@code T} can be used to model the address of a
- * region of memory whose layout is {@code T}.  For instance, an address layout with
+ * region of memory whose layout is {@code T}. For instance, an address layout with
  * target layout {@link ValueLayout#JAVA_INT} can be used to model the address of a
- * region of memory that is 4 bytes long.  Specifying a target layout can be useful in
+ * region of memory that is 4 bytes long. Specifying a target layout can be useful in
  * the following situations:
  * <ul>
  *     <li>When accessing a memory segment that has been obtained by reading an address from
@@ -92,12 +92,12 @@ public sealed interface AddressLayout extends ValueLayout permits ValueLayouts.O
      * order as this address layout, but associated with the specified target layout.
      * The returned address layout allows raw addresses to be accessed as
      * {@linkplain MemorySegment memory segments} whose size is set to the size of the
-     * specified layout.  Moreover, if the accessed raw address is not compatible with
+     * specified layout. Moreover, if the accessed raw address is not compatible with
      * the alignment constraint in the provided layout, {@linkplain IllegalArgumentException}
      * will be thrown.
      * @apiNote
      * This method can also be used to create an address layout which, when used, creates
-     * native memory segments with maximal size (e.g. {@linkplain Long#MAX_VALUE}).  This
+     * native memory segments with maximal size (e.g. {@linkplain Long#MAX_VALUE}). This
      * can be done by using a target sequence layout with unspecified size, as follows:
      * {@snippet lang = java:
      * AddressLayout addressLayout   = ...

src/java.base/share/classes/java/lang/foreign/Arena.java

@@ -35,18 +35,18 @@
  * allocation and timely de-allocation.
  * <p>
  * An arena has a {@linkplain MemorySegment.Scope scope} - the <em>arena scope</em>.
- * All the segments allocated by the arena are associated with the arena scope.  As such,
+ * All the segments allocated by the arena are associated with the arena scope. As such,
  * the arena determines the temporal bounds of all the memory segments allocated by it.
  * <p>
  * Moreover, an arena also determines whether access to memory segments allocated by it
  * should be {@linkplain MemorySegment#isAccessibleBy(Thread) restricted} to specific
- * threads.  An arena is a {@link SegmentAllocator} and features several allocation
+ * threads. An arena is a {@link SegmentAllocator} and features several allocation
  * methods that can be used by clients to obtain native segments.
  * <p>
- * The simplest arena is the {@linkplain Arena#global() global arena}.  The global arena
- * features an <em>unbounded lifetime</em>.  The scope of the global arena is the global
- * scope.  As such, native segments allocated with the global arena are always accessible
- * and their backing regions of memory are never deallocated.  Moreover, memory segments
+ * The simplest arena is the {@linkplain Arena#global() global arena}. The global arena
+ * features an <em>unbounded lifetime</em>. The scope of the global arena is the global
+ * scope. As such, native segments allocated with the global arena are always accessible
+ * and their backing regions of memory are never deallocated. Moreover, memory segments
  * allocated with the global arena can be {@linkplain MemorySegment#isAccessibleBy(Thread) accessed}
  * from any thread.
  * {@snippet lang = java:
@@ -57,7 +57,7 @@
  * <p>
  * Alternatively, clients can obtain an {@linkplain Arena#ofAuto() automatic arena}, that
  * is an arena which features a <em>bounded lifetime</em> that is managed, automatically,
- * by the garbage collector.  The scope of an automatic arena is an automatic scope.  As
+ * by the garbage collector. The scope of an automatic arena is an automatic scope. As
  * such, the regions of memory backing memory segments allocated with the automatic arena
  * are deallocated at some unspecified time <em>after</em> the automatic arena (and all
  * the segments allocated by it) becomes <a href="../../../java/lang/ref/package.html#reachability">unreachable</a>,
@@ -72,10 +72,10 @@
  * <p>
  * Rather than leaving de-allocation in the hands of the Java runtime, clients will often
  * wish to exercise control over the timing of de-allocation for regions of memory that
- * back memory segments.  Two kinds of arenas support this, namely {@linkplain #ofConfined() confined}
- * and {@linkplain #ofShared() shared} arenas.  They both feature bounded lifetimes that
- * are managed manually.  For instance, when a confined arena is {@linkplain #close() closed}
- * successfully, its scope is {@linkplain Scope#isAlive() invalidated}.  As a result, all
+ * back memory segments. Two kinds of arenas support this, namely {@linkplain #ofConfined() confined}
+ * and {@linkplain #ofShared() shared} arenas. They both feature bounded lifetimes that
+ * are managed manually. For instance, when a confined arena is {@linkplain #close() closed}
+ * successfully, its scope is {@linkplain Scope#isAlive() invalidated}. As a result, all
  * the memory segments allocated by the arena can no longer be accessed, and their
  * regions of memory are deallocated:
  *
@@ -89,7 +89,7 @@
  *}
  *
  * Memory segments allocated with a {@linkplain #ofConfined() confined arena} can only be
- * accessed (and closed) by the thread that created the arena.  If access to a memory
+ * accessed (and closed) by the thread that created the arena. If access to a memory
  * segment from multiple threads is required, clients can allocate segments in a
  * {@linkplain #ofShared() shared arena} instead.
  * <p>
@@ -128,37 +128,37 @@
  * <h2 id = "thread-confinement">Safety and thread-confinement</h2>
  *
  * Arenas provide strong temporal safety guarantees: a memory segment allocated by an
- * arena cannot be accessed <em>after</em> the arena has been closed.  The cost of
+ * arena cannot be accessed <em>after</em> the arena has been closed. The cost of
  * providing this guarantee varies based on the number of threads that have access to the
- * memory segments allocated by the arena.  For instance, if an arena is always created
+ * memory segments allocated by the arena. For instance, if an arena is always created
  * and closed by one thread, and the memory segments allocated by the arena are always
  * accessed by that same thread, then ensuring correctness is trivial.
  * <p>
  * Conversely, if an arena allocates segments that can be accessed by multiple threads,
  * or if the arena can be closed by a thread other than the accessing thread, then
- * ensuring correctness is much more complex.  For example, a segment allocated with the
+ * ensuring correctness is much more complex. For example, a segment allocated with the
  * arena might be accessed <em>while</em> another thread attempts, concurrently, to close
- * the arena.  To provide the strong temporal safety guarantee without forcing every
+ * the arena. To provide the strong temporal safety guarantee without forcing every
  * client, even simple ones, to incur a performance impact, arenas are divided into
  * <em>thread-confined</em> arenas, and <em>shared</em> arenas.
  * <p>
- * Confined arenas, support strong thread-confinement guarantees.  Upon creation, they are
+ * Confined arenas, support strong thread-confinement guarantees. Upon creation, they are
  * assigned an <em>owner thread</em>, typically the thread which initiated the creation
- * operation.  The segments created by a confined arena can only be
+ * operation. The segments created by a confined arena can only be
  * {@linkplain MemorySegment#isAccessibleBy(Thread) accessed} by the owner thread.
  * Moreover, any attempt to close the confined arena from a thread other than the owner
  * thread will fail with a {@link WrongThreadException}.
  * <p>
- * Shared arenas, on the other hand, have no owner thread.  The segments created by a
+ * Shared arenas, on the other hand, have no owner thread. The segments created by a
  * shared arena can be {@linkplain MemorySegment#isAccessibleBy(Thread) accessed} by
- * any thread.  This might be useful when multiple threads need to access the same memory
- * segment concurrently (e.g. in the case of parallel processing).  Moreover, a shared
+ * any thread. This might be useful when multiple threads need to access the same memory
+ * segment concurrently (e.g. in the case of parallel processing). Moreover, a shared
  * arena can be closed by any thread.
  *
  * <h2 id = "custom-arenas">Custom arenas</h2>
  *
  * Clients can define custom arenas to implement more efficient allocation strategies,
- * or to have better control over when (and by whom) an arena can be closed.  As an
+ * or to have better control over when (and by whom) an arena can be closed. As an
  * example, the following code defines a <em>slicing arena</em> that behaves like a
  * confined arena (i.e., single-threaded access), but internally uses a
  * {@linkplain SegmentAllocator#slicingAllocator(MemorySegment) slicing allocator} to
@@ -226,7 +226,7 @@ static Arena ofAuto() {
     }
 
     /**
-     * Obtains the global arena.  Segments allocated with the global arena can be
+     * Obtains the global arena. Segments allocated with the global arena can be
      * {@linkplain MemorySegment#isAccessibleBy(Thread) accessed} by any thread.
      * Calling {@link #close()} on the returned arena will result in an {@link UnsupportedOperationException}.
      *
@@ -296,11 +296,11 @@ static Arena ofShared() {
     /**
      * Closes this arena. If this method completes normally, the arena scope is no longer
      * {@linkplain Scope#isAlive() alive}, and all the memory segments associated with it
-     * can no longer be accessed.  Furthermore, any off-heap region of memory backing the
+     * can no longer be accessed. Furthermore, any off-heap region of memory backing the
      * segments obtained from this arena are also released.
      *
      * @apiNote This operation is not idempotent; that is, closing an already closed arena
-     *          <em>always</em> results in an exception being thrown.  This reflects a
+     *          <em>always</em> results in an exception being thrown. This reflects a
      *          deliberate design choice: failure to close an arena might reveal a bug
      *          in the underlying application logic.
      *

src/java.base/share/classes/java/lang/foreign/FunctionDescriptor.java

@@ -34,7 +34,7 @@
 import jdk.internal.foreign.FunctionDescriptorImpl;
 
 /**
- * A function descriptor models the signature of a foreign function.  A function
+ * A function descriptor models the signature of a foreign function. A function
  * descriptor is made up of zero or more argument layouts, and zero or one return layout.
  * A function descriptor is used to create
  * {@linkplain Linker#downcallHandle(MemorySegment, FunctionDescriptor, Linker.Option...) downcall method handles} and
@@ -109,7 +109,7 @@ public sealed interface FunctionDescriptor permits FunctionDescriptorImpl {
      * </ul>
      *
      * @apiNote A function descriptor cannot, by construction, contain any padding
-     *          layouts.  As such, it is not necessary to specify how padding layout
+     *          layouts. As such, it is not necessary to specify how padding layout
      *          should be mapped to carrier types.
      *
      * @return the method type consisting of the carrier types of the layouts in this
@@ -135,7 +135,7 @@ static FunctionDescriptor of(MemoryLayout resLayout, MemoryLayout... argLayouts)
 
     /**
      * Creates a function descriptor with the given argument layouts and no return
-     * layout.  This is useful to model functions that return no values.
+     * layout. This is useful to model functions that return no values.
      *
      * @param argLayouts the argument layouts.
      * @throws IllegalArgumentException if one of the layouts in {@code argLayouts}

src/java.base/share/classes/java/lang/foreign/GroupLayout.java

@@ -29,7 +29,7 @@
 
 /**
  * A compound layout that is an aggregation of multiple, heterogeneous
- * <em>member layouts</em>.  There are two ways in which member layouts can be combined:
+ * <em>member layouts</em>. There are two ways in which member layouts can be combined:
  * if member layouts are laid out one after the other, the resulting group layout is a
  * {@linkplain StructLayout struct layout}; conversely, if all member layouts are laid
  * out at the same starting offset, the resulting group layout is a

src/java.base/share/classes/java/lang/foreign/PaddingLayout.java

@@ -28,7 +28,7 @@
 import jdk.internal.foreign.layout.PaddingLayoutImpl;
 
 /**
- * A padding layout.  A padding layout specifies the size of extra space which is
+ * A padding layout. A padding layout specifies the size of extra space which is
  * typically not accessed by applications, and is typically used for aligning member
  * layouts around word boundaries.
  *

src/java.base/share/classes/java/lang/foreign/SegmentAllocator.java

@@ -38,7 +38,7 @@
 /**
  * An object that may be used to allocate {@linkplain MemorySegment memory segments}.
  * Clients implementing this interface must implement the {@link #allocate(long, long)}
- * method.  A segment allocator defines several methods which can be useful to create
+ * method. A segment allocator defines several methods which can be useful to create
  * segments from several kinds of Java values such as primitives and arrays.
  * <p>
  * {@code SegmentAllocator} is a {@linkplain FunctionalInterface functional interface}.
@@ -60,16 +60,16 @@
  * <p>
  * Passing a segment allocator to an API can be especially useful in circumstances where
  * a client wants to communicate <em>where</em> the results of a certain operation
- * (performed by the API) should be stored, as a memory segment.  For instance,
+ * (performed by the API) should be stored, as a memory segment. For instance,
  * {@linkplain Linker#downcallHandle(FunctionDescriptor, Linker.Option...) downcall method handles}
  * can accept an additional {@link SegmentAllocator} parameter if the underlying
- * foreign function is known to return a struct by-value.  Effectively, the allocator
+ * foreign function is known to return a struct by-value. Effectively, the allocator
  * parameter tells the linker where to store the return value of the foreign function.
  *
  * @apiNote Unless otherwise specified, the {@link #allocate(long, long)} method is
- *          not thread-safe.  Furthermore, memory segments allocated by a segment
+ *          not thread-safe. Furthermore, memory segments allocated by a segment
  *          allocator can be associated with different lifetimes, and can even be backed
- *          by overlapping regions of memory.  For these reasons, clients should
+ *          by overlapping regions of memory. For these reasons, clients should
  *          generally only interact with a segment allocator they own.
  * <p>
  * Clients should consider using an {@linkplain Arena arena} instead, which, provides
@@ -104,12 +104,12 @@ default MemorySegment allocateFrom(String str) {
      * and storing the result into a memory segment.
      * <p>
      * This method always replaces malformed-input and unmappable-character
-     * sequences with this charset's default replacement byte array.  The
+     * sequences with this charset's default replacement byte array. The
      * {@link java.nio.charset.CharsetEncoder} class should be used when more
      * control over the encoding process is required.
      * <p>
      * If the given string contains any {@code '\0'} characters, they will be
-     * copied as well.  This means that, depending on the method used to read
+     * copied as well. This means that, depending on the method used to read
      * the string, such as {@link MemorySegment#getString(long)}, the string
      * will appear truncated when read again.
      *
@@ -126,7 +126,7 @@ default MemorySegment allocateFrom(String str) {
      *     <li>{@code B} is the size, in bytes, of the string encoded using the
      *         provided charset (e.g. {@code str.getBytes(charset).length});</li>
      *     <li>{@code N} is the size (in bytes) of the terminator char according to the
-     *         provided charset.  For instance, this is 1 for {@link StandardCharsets#US_ASCII}
+     *         provided charset. For instance, this is 1 for {@link StandardCharsets#US_ASCII}
      *         and 2 for {@link StandardCharsets#UTF_16}.</li>
      * </ul>
      */
@@ -157,7 +157,7 @@ default MemorySegment allocateFrom(String str, Charset charset) {
      * {@return a new memory segment initialized with the provided byte value}
      * <p>
      * The size of the allocated memory segment is the
-     * {@linkplain MemoryLayout#byteSize() size} of the given layout.  The given value is
+     * {@linkplain MemoryLayout#byteSize() size} of the given layout. The given value is
      * written into the segment according to the byte order and alignment constraint of
      * the given layout.
      *
@@ -207,7 +207,7 @@ default MemorySegment allocateFrom(ValueLayout.OfChar layout, char value) {
      * {@return a new memory segment initialized with the provided short value}
      * <p>
      * The size of the allocated memory segment is the
-     * {@linkplain MemoryLayout#byteSize() size} of the given layout.  The given value is
+     * {@linkplain MemoryLayout#byteSize() size} of the given layout. The given value is
      * written into the segment according to the byte order and alignment constraint of
      * the given layout.
      *
@@ -232,7 +232,7 @@ default MemorySegment allocateFrom(ValueLayout.OfShort layout, short value) {
      * {@return a new memory segment initialized with the provided int value}
      * <p>
      * The size of the allocated memory segment is the
-     * {@linkplain MemoryLayout#byteSize() size} of the given layout.  The given value is
+     * {@linkplain MemoryLayout#byteSize() size} of the given layout. The given value is
      * written into the segment according to the byte order and alignment constraint of
      * the given layout.
      *
@@ -257,7 +257,7 @@ default MemorySegment allocateFrom(ValueLayout.OfInt layout, int value) {
      * {@return a new memory segment initialized with the provided float value}
      * <p>
      * The size of the allocated memory segment is the
-     * {@linkplain MemoryLayout#byteSize() size} of the given layout.  The given value is
+     * {@linkplain MemoryLayout#byteSize() size} of the given layout. The given value is
      * written into the segment according to the byte order and alignment constraint of
      * the given layout.
      *
@@ -282,7 +282,7 @@ default MemorySegment allocateFrom(ValueLayout.OfFloat layout, float value) {
      * {@return a new memory segment initialized with the provided long value}
      * <p>
      * The size of the allocated memory segment is the
-     * {@linkplain MemoryLayout#byteSize() size} of the given layout.  The given value is
+     * {@linkplain MemoryLayout#byteSize() size} of the given layout. The given value is
      * written into the segment according to the byte order and alignment constraint of
      * the given layout.
      *
@@ -307,7 +307,7 @@ default MemorySegment allocateFrom(ValueLayout.OfLong layout, long value) {
      * {@return a new memory segment initialized with the provided double value}
      * <p>
      * The size of the allocated memory segment is the
-     * {@linkplain MemoryLayout#byteSize() size} of the given layout.  The given value is
+     * {@linkplain MemoryLayout#byteSize() size} of the given layout. The given value is
      * written into the segment according to the byte order and alignment constraint of
      * the given layout.
      *
@@ -336,7 +336,7 @@ default MemorySegment allocateFrom(ValueLayout.OfDouble layout, double value) {
      * (see {@link ValueLayout#ADDRESS}).
      * <p>
      * The size of the allocated memory segment is the
-     * {@linkplain MemoryLayout#byteSize() size} of the given layout.  The given value is
+     * {@linkplain MemoryLayout#byteSize() size} of the given layout. The given value is
      * written into the segment according to the byte order and alignment constraint of
      * the given layout.
      *
@@ -364,7 +364,7 @@ default MemorySegment allocateFrom(AddressLayout layout, MemorySegment value) {
      * {@return a new memory segment initialized with the contents of the provided segment}
      * <p>
      * The size of the allocated memory segment is the
-     * {@code elementLayout.byteSize() * elementCount}.  The contents of the
+     * {@code elementLayout.byteSize() * elementCount}. The contents of the
      * source segment is copied into the result segment element by element, according
      * to the byte order and alignment constraint of the given element layout.
      *
@@ -409,7 +409,7 @@ default MemorySegment allocateFrom(ValueLayout elementLayout, MemorySegment sour
      *          byte array}
      * <p>
      * The size of the allocated memory segment is
-     * {@code elementLayout.byteSize() * elements.length}.  The contents of the
+     * {@code elementLayout.byteSize() * elements.length}. The contents of the
      * source array is copied into the result segment element by element, according
      * to the byte order and alignment constraint of the given element layout.
      *
@@ -436,7 +436,7 @@ default MemorySegment allocateFrom(ValueLayout.OfByte elementLayout, byte... ele
      *          short array}
      * <p>
      * The size of the allocated memory segment is
-     * {@code elementLayout.byteSize() * elements.length}.  The contents of the
+     * {@code elementLayout.byteSize() * elements.length}. The contents of the
      * source array is copied into the result segment element by element, according
      * to the byte order and alignment constraint of the given element layout.
      *
@@ -463,7 +463,7 @@ default MemorySegment allocateFrom(ValueLayout.OfShort elementLayout, short... e
      *          char array}
      * <p>
      * The size of the allocated memory segment is
-     * {@code elementLayout.byteSize() * elements.length}.  The contents of the
+     * {@code elementLayout.byteSize() * elements.length}. The contents of the
      * source array is copied into the result segment element by element, according
      * to the byte order and alignment constraint of the given element layout.
      *
@@ -490,7 +490,7 @@ default MemorySegment allocateFrom(ValueLayout.OfChar elementLayout, char... ele
      *          int array}
      * <p>
      * The size of the allocated memory segment is
-     * {@code elementLayout.byteSize() * elements.length}.  The contents of the
+     * {@code elementLayout.byteSize() * elements.length}. The contents of the
      * source array is copied into the result segment element by element, according
      * to the byte order and alignment constraint of the given element layout.
      *
@@ -517,7 +517,7 @@ default MemorySegment allocateFrom(ValueLayout.OfInt elementLayout, int... eleme
      *          float array}
      * <p>
      * The size of the allocated memory segment is
-     * {@code elementLayout.byteSize() * elements.length}.  The contents of
+     * {@code elementLayout.byteSize() * elements.length}. The contents of
      * the source array is copied into the result segment element by element, according
      * to the byte order and alignment constraint of the given element layout.
      *
@@ -544,7 +544,7 @@ default MemorySegment allocateFrom(ValueLayout.OfFloat elementLayout, float... e
      *          long array}
      * <p>
      * The size of the allocated memory segment is
-     * {@code elementLayout.byteSize() * elements.length}.  The contents of
+     * {@code elementLayout.byteSize() * elements.length}. The contents of
      * the source array is copied into the result segment element by element, according
      * to the byte order and alignment constraint of the given element layout.
      *
@@ -571,7 +571,7 @@ default MemorySegment allocateFrom(ValueLayout.OfLong elementLayout, long... ele
      *          double array}
      * <p>
      * The size of the allocated memory segment is
-     * {@code elementLayout.byteSize() * elements.length}.  The contents of
+     * {@code elementLayout.byteSize() * elements.length}. The contents of
      * the source array is copied into the result segment element by element, according
      * to the byte order and alignment constraint of the given element layout.
      *
@@ -655,7 +655,7 @@ default MemorySegment allocate(long byteSize) {
 
     /**
      * Returns a segment allocator which responds to allocation requests by returning
-     * consecutive slices obtained from the provided segment.  Each new allocation
+     * consecutive slices obtained from the provided segment. Each new allocation
      * request will return a new slice starting at the current offset (modulo additional
      * padding to satisfy alignment constraint), with given size.
      * <p>
@@ -674,7 +674,7 @@ static SegmentAllocator slicingAllocator(MemorySegment segment) {
 
     /**
      * Returns a segment allocator which responds to allocation requests by recycling a
-     * single segment.  Each new allocation request will return a new slice starting at
+     * single segment. Each new allocation request will return a new slice starting at
      * the segment offset {@code 0}, hence the name <em>prefix allocator</em>.
      * <p>
      * Equivalent to (but likely more efficient than) the following code:

src/java.base/share/classes/java/lang/foreign/SequenceLayout.java

@@ -29,10 +29,10 @@
 
 /**
  * A compound layout that denotes a homogeneous repetition of a given
- * <em>element layout</em>.  The repetition count is said to be the sequence layout's
- * <em>element count</em>.  A sequence layout can be thought of as a struct layout where
+ * <em>element layout</em>. The repetition count is said to be the sequence layout's
+ * <em>element count</em>. A sequence layout can be thought of as a struct layout where
  * the sequence layout's element layout is repeated a number of times that is equal to
- * the sequence layout's element count.  In other words this layout:
+ * the sequence layout's element count. In other words this layout:
  *
  * {@snippet lang=java :
  * MemoryLayout.sequenceLayout(3, ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN));
@@ -78,10 +78,10 @@ public sealed interface SequenceLayout extends MemoryLayout permits SequenceLayo
 
     /**
      * Rearranges the elements in this sequence layout into a multi-dimensional sequence
-     * layout.  The resulting layout is a sequence layout where element layouts in the
+     * layout. The resulting layout is a sequence layout where element layouts in the
      * {@linkplain #flatten() flattened projection} of this sequence layout are
      * rearranged into one or more nested sequence layouts according to the provided
-     * element counts.  This transformation preserves the layout size;
+     * element counts. This transformation preserves the layout size;
      * that is, multiplying the provided element counts must yield the same element count
      * as the flattened projection of this sequence layout.
      * <p>
@@ -117,7 +117,7 @@ public sealed interface SequenceLayout extends MemoryLayout permits SequenceLayo
     SequenceLayout reshape(long... elementCounts);
 
     /**
-     * Returns a flattened sequence layout.  The element layout of the returned
+     * Returns a flattened sequence layout. The element layout of the returned
      * sequence layout is the first non-sequence layout found by inspecting
      * (recursively, if needed) the element layout of this sequence layout:
      * {@snippet lang=java :
@@ -131,7 +131,7 @@ public sealed interface SequenceLayout extends MemoryLayout permits SequenceLayo
      * <p>
      * This transformation preserves the layout size; nested sequence layout in this
      * sequence layout will be dropped and their element counts will be incorporated
-     * into that of the returned sequence layout.  For instance, given a
+     * into that of the returned sequence layout. For instance, given a
      * sequence layout of the kind:
      * {@snippet lang=java :
      * var seq = MemoryLayout.sequenceLayout(4, MemoryLayout.sequenceLayout(3, ValueLayout.JAVA_INT));

src/java.base/share/classes/java/lang/foreign/SymbolLookup.java

@@ -51,7 +51,7 @@
  * and returns the address of the symbol in that library.
  * <p>
  * The address of a symbol is modelled as a zero-length
- * {@linkplain MemorySegment memory segment}.  The segment can be used in different ways:
+ * {@linkplain MemorySegment memory segment}. The segment can be used in different ways:
  * <ul>
  *     <li>It can be passed to a {@link Linker} to create a downcall method handle, which
  *         can then be used to call the foreign function at the segment's address.</li>
@@ -69,8 +69,8 @@
  *
  * The factory methods {@link #libraryLookup(String, Arena)} and
  * {@link #libraryLookup(Path, Arena)} create a symbol lookup for a library known to
- * the operating system.  The library is specified by either its name or a path.
- * The library is loaded if not already loaded.  The symbol lookup, which is known as a
+ * the operating system. The library is specified by either its name or a path.
+ * The library is loaded if not already loaded. The symbol lookup, which is known as a
  * <em>library lookup</em>, and its lifetime is controlled by an {@linkplain Arena arena}.
  * For instance, if the provided arena is a confined arena, the library associated with
  * the symbol lookup is unloaded when the confined arena is {@linkplain Arena#close() closed}:
@@ -85,7 +85,7 @@
  * <p>
  * If a library was previously loaded through JNI, i.e., by {@link System#load(String)}
  * or {@link System#loadLibrary(String)}, then the library was also associated with
- * a particular class loader.  The factory method {@link #loaderLookup()} creates
+ * a particular class loader. The factory method {@link #loaderLookup()} creates
  * a symbol lookup for all the libraries associated with the caller's class loader:
  *
  * {@snippet lang=java :
@@ -96,7 +96,7 @@
  * }
  *
  * This symbol lookup, which is known as a <em>loader lookup</em>, is dynamic with
- * respect to the libraries associated with the class loader.  If other libraries are
+ * respect to the libraries associated with the class loader. If other libraries are
  * subsequently loaded through JNI and associated with the class loader, then the loader
  * lookup will expose their symbols automatically.
  * <p>
@@ -121,9 +121,9 @@
  *
  * <p>
  * Finally, each {@link Linker} provides a symbol lookup for libraries that are commonly
- * used on the OS and processor combination supported by that {@link Linker}.  This
+ * used on the OS and processor combination supported by that {@link Linker}. This
  * symbol lookup, which is known as a <em>default lookup</em>, helps clients to quickly
- * find addresses of well-known symbols.  For example, a {@link Linker} for Linux/x64
+ * find addresses of well-known symbols. For example, a {@link Linker} for Linux/x64
  * might choose to expose symbols in {@code libc} through the default lookup:
  *
  * {@snippet lang = java:
@@ -159,7 +159,7 @@ public interface SymbolLookup {
      *         .or(SymbolLookup.loaderLookup());
      *}
      * The above code creates a symbol lookup that first searches for symbols in
-     * the "foo" library.  If no symbol is found in "foo" then "bar" is searched.
+     * the "foo" library. If no symbol is found in "foo" then "bar" is searched.
      * Finally, if a symbol is not found in neither "foo" nor "bar", the
      * {@linkplain SymbolLookup#loaderLookup() loader lookup} is used.
      *
@@ -180,15 +180,15 @@ default SymbolLookup or(SymbolLookup other) {
      * {@link System#loadLibrary(String)} from code in a class defined by {@code CL}.
      * If that code makes further invocations of {@link System#load(String)} or
      * {@link System#loadLibrary(String)} then more libraries are loaded and associated
-     * with {@code CL}.  The symbol lookup returned by this method is always current: it
+     * with {@code CL}. The symbol lookup returned by this method is always current: it
      * reflects all the libraries associated with the relevant class loader, even if they
      * were loaded after this method returned.
      * <p>
      * Libraries associated with a class loader are unloaded when the class loader becomes
-     * <a href="../../../java/lang/ref/package.html#reachability">unreachable</a>.  The
+     * <a href="../../../java/lang/ref/package.html#reachability">unreachable</a>. The
      * symbol lookup returned by this method is associated with an automatic
      * {@linkplain MemorySegment.Scope scope} which keeps the caller's class loader
-     * reachable.  Therefore, libraries associated with the caller's class loader are
+     * reachable. Therefore, libraries associated with the caller's class loader are
      * kept loaded (and their symbols available) as long as a loader lookup for that
      * class loader, or any of the segments obtained by it, is reachable.
      * <p>
@@ -231,14 +231,14 @@ static SymbolLookup loaderLookup() {
 
     /**
      * Loads a library with the given name (if not already loaded) and creates a symbol
-     * lookup for symbols in that library.  The lifetime of the returned library lookup
-     * is controlled by the provided arena.  For instance, if the provided arena is a
+     * lookup for symbols in that library. The lifetime of the returned library lookup
+     * is controlled by the provided arena. For instance, if the provided arena is a
      * confined arena, the library associated with the returned lookup will be unloaded
      * when the provided confined arena is {@linkplain Arena#close() closed}.
      *
-     * @implNote The process of resolving a library name is OS-specific.  For instance,
+     * @implNote The process of resolving a library name is OS-specific. For instance,
      *           in a POSIX-compliant OS, the library name is resolved according to the
-     *           specification of the {@code dlopen} function for that OS.  In Windows,
+     *           specification of the {@code dlopen} function for that OS. In Windows,
      *           the library name is resolved according to the specification of the
      *           {@code LoadLibrary} function.
      *
@@ -265,8 +265,8 @@ static SymbolLookup libraryLookup(String name, Arena arena) {
 
     /**
      * Loads a library from the given path (if not already loaded) and creates a symbol
-     * lookup for symbols in that library.  The lifetime of the returned library lookup
-     * is controlled by the provided arena.  For instance, if the provided arena is a
+     * lookup for symbols in that library. The lifetime of the returned library lookup
+     * is controlled by the provided arena. For instance, if the provided arena is a
      * confined arena, the library associated with the returned lookup will be unloaded
      * when the provided confined arena is {@linkplain Arena#close() closed}.
      *

src/java.base/share/classes/java/lang/foreign/ValueLayout.java

@@ -30,7 +30,7 @@
 import jdk.internal.foreign.layout.ValueLayouts;
 
 /**
- * A layout that models values of basic data types.  Examples of values modelled by a
+ * A layout that models values of basic data types. Examples of values modelled by a
  * value layout are <em>integral</em> values (either signed or unsigned),
  * <em>floating-point</em> values and <em>address</em> values.
  * <p>

src/java.base/share/classes/java/lang/foreign/package-info.java

@@ -31,11 +31,11 @@
  * <p>
  * The main abstraction introduced to support foreign memory access is
  * {@link java.lang.foreign.MemorySegment}, which models a contiguous region of memory,
- * residing either inside or outside the Java heap.  Memory segments are typically
+ * residing either inside or outside the Java heap. Memory segments are typically
  * allocated using an {@link java.lang.foreign.Arena}, which controls the lifetime of the
- * regions of memory backing the segments it allocates.  The contents of a memory segment
+ * regions of memory backing the segments it allocates. The contents of a memory segment
  * can be described using a {@link java.lang.foreign.MemoryLayout memory layout}, which
- * provides basic operations to query sizes, offsets and alignment constraints.  Memory
+ * provides basic operations to query sizes, offsets and alignment constraints. Memory
  * layouts also provide an alternate, more abstract way, to
  * <a href=MemorySegment.html#segment-deref>access memory segments</a> using
  * {@linkplain java.lang.foreign.MemoryLayout#varHandle(java.lang.foreign.MemoryLayout.PathElement...) var handles},
@@ -57,10 +57,10 @@
  * This code creates a <em>native</em> memory segment, that is, a memory segment backed
  * by off-heap memory; the size of the segment is 40 bytes, enough to store 10 values of
  * the primitive type {@code int}.   The native segment is allocated using a
- * {@linkplain java.lang.foreign.Arena#ofConfined() confined arena}.  As such, access to
+ * {@linkplain java.lang.foreign.Arena#ofConfined() confined arena}. As such, access to
  * the native segment is restricted to the current thread (the thread that created the
- * arena).  Moreover, when the arena is closed, the native segment is invalidated, and
- * its backing region of memory is deallocated.  Note the use of the <em>try-with-resources</em>
+ * arena). Moreover, when the arena is closed, the native segment is invalidated, and
+ * its backing region of memory is deallocated. Note the use of the <em>try-with-resources</em>
  * construct: this idiom ensures that the off-heap region of memory backing the native
  * segment will be released at the end of the block, according to the semantics described
  * in Section {@jls 14.20.3} of <cite>The Java Language Specification</cite>.
@@ -76,7 +76,7 @@
  * Additionally, to prevent a region of memory from being accessed <em>after</em> it has
  * been deallocated (i.e. <em>use-after-free</em>), a segment is also validated
  * (upon access) to make sure that the arena from which it has been obtained has not
- * been closed.  We call this guarantee <em>temporal safety</em>.
+ * been closed. We call this guarantee <em>temporal safety</em>.
  * <p>
  * Together, spatial and temporal safety ensure that each memory access operation either
  * succeeds - and accesses a valid location within the region of memory backing the
@@ -86,7 +86,7 @@
  *
  * The key abstractions introduced to support foreign function access are
  * {@link java.lang.foreign.SymbolLookup}, {@link java.lang.foreign.FunctionDescriptor} and
- * {@link java.lang.foreign.Linker}.  The first is used to look up symbols inside
+ * {@link java.lang.foreign.Linker}. The first is used to look up symbols inside
  * libraries; the second is used to model the signature of foreign functions, while the
  * third is used to link foreign functions as {@link java.lang.invoke.MethodHandle}
  * instances, so that clients can perform foreign function calls directly in Java,
@@ -117,7 +117,7 @@
  * {@linkplain java.lang.foreign.Linker#downcallHandle(FunctionDescriptor, Linker.Option...) obtained}.
  * To complete the linking successfully, we must provide a
  * {@link java.lang.foreign.FunctionDescriptor} instance, describing the signature of the
- * {@code strlen} function.  From this information, the linker will uniquely determine
+ * {@code strlen} function. From this information, the linker will uniquely determine
  * the sequence of steps which will turn the method handle invocation (here performed
  * using {@link java.lang.invoke.MethodHandle#invokeExact(java.lang.Object...)})
  * into a foreign function call, according to the rules specified by the ABI of the
@@ -130,33 +130,33 @@
  *
  * <h2 id="restricted">Restricted methods</h2>
  *
- * Some methods in this package are considered <em>restricted</em>.  Restricted methods
+ * Some methods in this package are considered <em>restricted</em>. Restricted methods
  * are typically used to bind native foreign data and/or functions to first-class
- * Java API elements which can then be used directly by clients.  For instance the
+ * Java API elements which can then be used directly by clients. For instance the
  * restricted method {@link java.lang.foreign.MemorySegment#reinterpret(long)} can be
  * used to create a fresh segment with the same address and temporal bounds, but with
- * the provided size.  This can be useful to resize memory segments obtained when
+ * the provided size. This can be useful to resize memory segments obtained when
  * interacting with native functions.
  * <p>
  * Binding foreign data and/or functions is generally unsafe and, if done incorrectly,
  * can result in VM crashes, or memory corruption when the bound Java API element is
- * accessed.  For instance, incorrectly resizing a native memory segment using
+ * accessed. For instance, incorrectly resizing a native memory segment using
  * {@link java.lang.foreign.MemorySegment#reinterpret(long)} can lead to a JVM crash, or,
  * worse, lead to silent memory corruption when attempting to access the resized segment.
  * For these reasons, it is crucial for code that calls a restricted method to never pass
  * arguments that might cause incorrect binding of foreign data and/or functions to a
  * Java API.
  * <p>
  * Given the potential danger of restricted methods, the Java runtime issues a warning on
- * the standard error stream every time a restricted method is invoked.  Such warnings
- * can be disabled by granting access to restricted methods to selected modules.  This
+ * the standard error stream every time a restricted method is invoked. Such warnings
+ * can be disabled by granting access to restricted methods to selected modules. This
  * can be done either via implementation-specific command line options, or
  * programmatically, e.g. by calling
  * {@link java.lang.ModuleLayer.Controller#enableNativeAccess(java.lang.Module)}.
  * <p>
  * For every class in this package, unless specified otherwise, any method arguments of
  * reference type must not be {@code null}, and any null argument will elicit a
- * {@code NullPointerException}.  This fact is not individually documented for methods of
+ * {@code NullPointerException}. This fact is not individually documented for methods of
  * this API.
  *
  * @apiNote Usual memory model guarantees (see {@jls 17.4}) do not apply when accessing
@@ -166,7 +166,7 @@
  * In the reference implementation, access to restricted methods can be granted to
  * specific modules using the command line option {@code --enable-native-access=M1,M2, ... Mn},
  * where {@code M1}, {@code M2}, {@code ... Mn} are module names (for the unnamed module,
- * the special value {@code ALL-UNNAMED} can be used).  If this option is specified,
+ * the special value {@code ALL-UNNAMED} can be used). If this option is specified,
  * access to restricted methods is only granted to the modules listed by that option.
  * If this option is not specified, access to restricted methods is enabled for all
  * modules, but access to restricted methods will result in runtime warnings.