Fix style

Author: Pavel Marek

com.oracle.truffle.r.ffi.impl/src/com/oracle/truffle/r/ffi/impl/llvm/TruffleLLVM_Context.java

@@ -145,7 +145,7 @@ public Object callNativeFunction(Object nativeFunc, Type nativeFuncType, String
         Object ret;
         try {
             ret = interop.execute(nativeFunc, wrappedArgs);
-        } catch(InteropException e) {
+        } catch (InteropException e) {
             throw RInternalError.shouldNotReachHere(e);
         }
         ret = FFIUnwrapNodeGen.getUncached().execute(ret);

com.oracle.truffle.r.ffi.impl/src/com/oracle/truffle/r/ffi/impl/nfi/TruffleNFI_Context.java

@@ -410,7 +410,7 @@ public Object callNativeFunction(Object nativeFunc, Type nativeFuncType, String
         Object ret;
         try {
             ret = interop.execute(boundNativeFunc, wrappedArgs);
-        } catch(InteropException e) {
+        } catch (InteropException e) {
             throw RInternalError.shouldNotReachHere(e);
         }
         ret = FFIUnwrapNodeGen.getUncached().execute(ret);

com.oracle.truffle.r.library/src/com/oracle/truffle/r/library/graphics/RGraphics.java

@@ -22,7 +22,6 @@
  */
 package com.oracle.truffle.r.library.graphics;
 
-
 import static com.oracle.truffle.r.runtime.context.FastROptions.LoadPackagesNativeCode;
 import com.oracle.truffle.r.runtime.context.RContext;
 import com.oracle.truffle.r.runtime.ffi.CallRFFI;

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/context/GlobalNativeVarContext.java

@@ -1,9 +1,7 @@
 package com.oracle.truffle.r.runtime.context;
 
 import com.oracle.truffle.api.CompilerDirectives;
-import com.oracle.truffle.api.TruffleLogger;
 import com.oracle.truffle.api.interop.InteropLibrary;
-import com.oracle.truffle.api.interop.InvalidArrayIndexException;
 import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.interop.UnknownKeyException;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
@@ -12,13 +10,10 @@
 import com.oracle.truffle.api.library.ExportMessage;
 import com.oracle.truffle.r.runtime.Collections;
 import com.oracle.truffle.r.runtime.RInternalError;
-import com.oracle.truffle.r.runtime.RLogger;
 import com.oracle.truffle.r.runtime.ffi.RFFIFactory;
 
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.logging.Level;
 
 public class GlobalNativeVarContext implements RContext.ContextState {
     private static final Collections.ArrayListObj<GlobalVarDescriptor> globalNativeVarDescriptors = new Collections.ArrayListObj<>(64);
@@ -41,6 +36,7 @@ public static GlobalNativeVarContext newContextState(RContext context) {
     /**
      * Allocates descriptor structure for native global var.
      */
+    @CompilerDirectives.TruffleBoundary
     public GlobalVarDescriptor allocGlobalVarDescr() {
         var descr = new GlobalVarDescriptor();
         globalNativeVarDescriptors.add(descr);
@@ -82,6 +78,7 @@ public void beforeFinalize(RContext context) {
 
     /**
      * Removes {@code context} from all teh global native variable descriptors.
+     * 
      * @param context Context used as the key for global native variable descriptors.
      */
     @Override
@@ -116,7 +113,7 @@ public void callAllDestructors(RContext context, InteropLibrary interop) {
                 throw RInternalError.shouldNotReachHere(e);
             }
             Object ret = context.getRFFI().callNativeFunction(destructor.nativeFunc, destructor.nativeFuncType, Destructor.SIGNATURE,
-                    new Object[]{ptrForDestructorNative}, whichArgToWrap);
+                            new Object[]{ptrForDestructorNative}, whichArgToWrap);
             assert interop.isNull(ret);
         }
     }
@@ -231,16 +228,16 @@ public String toString() {
     }
 
     /**
-     * Represents a native function callback that is called during the context finalization.
-     * Needed for native array global variables for which there was heap memory allocated.
+     * Represents a native function callback that is called during the context finalization. Needed
+     * for native array global variables for which there was heap memory allocated.
      */
     private static final class Destructor {
         static final String SIGNATURE = "(pointer): void";
 
         final Object globalVarDescr;
         /**
-         * The signature of the native function is {@code void dtor(void *ptr)}, where {@code ptr} is the
-         * underlying pointer fetched via {@code FASTR_GlobalVarGetPtr}.
+         * The signature of the native function is {@code void dtor(void *ptr)}, where {@code ptr}
+         * is the underlying pointer fetched via {@code FASTR_GlobalVarGetPtr}.
          */
         final Object nativeFunc;
         final RFFIFactory.Type nativeFuncType;

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/context/PackagePatching.java

@@ -74,7 +74,8 @@ public class PackagePatching {
                     new Patch("Rf_KillAllDevices\\s*\\(\\s*\\)", ""),
                     // This patch was first introduced because compilation of testthat 3.0.1 failed
                     // on systems
-                    // with newer glibc (for example glibc version on Ubuntu >= 22.04) , as described in
+                    // with newer glibc (for example glibc version on Ubuntu >= 22.04) , as
+                    // described in
                     // https://github.com/r-lib/testthat/issues/1373.
                     // In newer glibc, SIGSTKSZ is no longer a constexpr, so it cannot be used in
                     // C++ in static array declaration.

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/context/RContext.java

@@ -248,8 +248,9 @@ default void beforeDispose(RContext context) {
         }
 
         /**
-         * Called before context finalization ({@code com.oracle.truffle.api.TruffleLanguage#finalizeContext(Object)}).
-         * Note that context finalization happens before context disposal, and generally, it should be safe to
+         * Called before context finalization
+         * ({@code com.oracle.truffle.api.TruffleLanguage#finalizeContext(Object)}). Note that
+         * context finalization happens before context disposal, and generally, it should be safe to
          * call native functions in the context finalization.
          */
         default void beforeFinalize(RContext context) {
@@ -648,7 +649,8 @@ public static RContext create(TruffleRLanguage language, Env env, Instrumenter i
     public void finalizeContext() {
         if (state.contains(State.INITIALIZED)) {
             // Engine deactive must be called from finalizeContext, because we need to call some
-            // native functions from there, and for that, we need the context not to be in the disposal.
+            // native functions from there, and for that, we need the context not to be in the
+            // disposal.
             if (!embedded) {
                 engine.deactivate();
             }

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ffi/FFIWrap.java

@@ -105,10 +105,12 @@ public Object[] wrapUncached(Object[] args) {
         }
 
         /**
-         * Materializes and wraps some (or all) arguments with {@link com.oracle.truffle.r.runtime.data.NativeDataAccess.NativeMirror}.
+         * Materializes and wraps some (or all) arguments with
+         * {@link com.oracle.truffle.r.runtime.data.NativeDataAccess.NativeMirror}.
+         * 
          * @param args Arguments to wrap
-         * @param whichArgToWrap If {@code whichArgToWrap[i] == true}, {@code args[i]} will be wrapped.
-         *                       If {@code whichArgToWrap} is null, all arguments are wrapped.
+         * @param whichArgToWrap If {@code whichArgToWrap[i] == true}, {@code args[i]} will be
+         *            wrapped. If {@code whichArgToWrap} is null, all arguments are wrapped.
          */
         public Object[] wrapSomeUncached(Object[] args, boolean[] whichArgToWrap) {
             assert materialized.length == args.length;
@@ -130,10 +132,12 @@ public Object[] wrapAll(Object[] args, FFIMaterializeNode[] ffiMateralizeNodes,
         }
 
         /**
-         * Materializes and wraps some (or all) arguments with {@link com.oracle.truffle.r.runtime.data.NativeDataAccess.NativeMirror}.
+         * Materializes and wraps some (or all) arguments with
+         * {@link com.oracle.truffle.r.runtime.data.NativeDataAccess.NativeMirror}.
+         * 
          * @param args Arguments to wrap
-         * @param whichArgToWrap If {@code whichArgToWrap[i] == true}, {@code args[i]} will be wrapped.
-         *                       If {@code whichArgToWrap} is null, all arguments are wrapped.
+         * @param whichArgToWrap If {@code whichArgToWrap[i] == true}, {@code args[i]} will be
+         *            wrapped. If {@code whichArgToWrap} is null, all arguments are wrapped.
          */
         @ExplodeLoop
         public Object[] wrapSome(Object[] args, FFIMaterializeNode[] ffiMaterializeNodes, FFIToNativeMirrorNode[] ffiToNativeMirrorNodes, boolean[] whichArgToWrap) {

com.oracle.truffle.r.runtime/src/com/oracle/truffle/r/runtime/ffi/RFFIContext.java

@@ -144,17 +144,18 @@ public final void registerReferenceUsedInNative(Object obj, ConditionProfile nop
 
     /**
      * Calls a native function in slow-path. This method is a simpler alternative to
-     * {@link com.oracle.truffle.r.runtime.ffi.DownCallNodeFactory.DownCallNode} machinery.
-     * Use it once the native function is not known during FastR build, i.e., whenever you
-     * cannot use {@link NativeFunction}.
+     * {@link com.oracle.truffle.r.runtime.ffi.DownCallNodeFactory.DownCallNode} machinery. Use it
+     * once the native function is not known during FastR build, i.e., whenever you cannot use
+     * {@link NativeFunction}.
      *
-     * @param nativeFunc     (Truffle) object representing the native function to be called.
-     * @param nativeFuncType Type of the native function - can be either {@code LLVM} or {@code NFI}.
-     * @param signature      Signature of the function. Makes sense only for {@code NFI} function type.
-     * @param args           Arguments passed to the native function, potentially processed with
-     *                       {@link FFIWrap.FFIDownCallWrap}, based on {@code whichArgToWrap}.
-     * @param whichArgToWrap If {@code whichArgToWrap[i] == true}, then element at {@code args[i]} will
-     *                       be wrapped with {@link FFIWrap.FFIDownCallWrap}.
+     * @param nativeFunc (Truffle) object representing the native function to be called.
+     * @param nativeFuncType Type of the native function - can be either {@code LLVM} or
+     *            {@code NFI}.
+     * @param signature Signature of the function. Makes sense only for {@code NFI} function type.
+     * @param args Arguments passed to the native function, potentially processed with
+     *            {@link FFIWrap.FFIDownCallWrap}, based on {@code whichArgToWrap}.
+     * @param whichArgToWrap If {@code whichArgToWrap[i] == true}, then element at {@code args[i]}
+     *            will be wrapped with {@link FFIWrap.FFIDownCallWrap}.
      * @return Return value directly from the native function, processed with {@link FFIUnwrapNode}.
      */
     public Object callNativeFunction(Object nativeFunc, RFFIFactory.Type nativeFuncType, String signature, Object[] args, boolean[] whichArgToWrap) {