Fix require expression parsing, non-blocking I/O, and 4-arg select

- Fix parser to handle require File::Spec->catfile(...) as an expression
  rather than treating File::Spec as a module name. This allows POE to
  dynamically load Time::HiRes via require.

- Add non-blocking I/O support for internal pipe handles: InternalPipeHandle
  now supports setBlocking/isBlocking, and sysread returns undef with
  EAGAIN (errno 11) when non-blocking and no data available.

- Fix IO::Handle::blocking() to properly delegate to the underlying handle
  blocking state, and fix argument passing (shift on glob copy issue).

- Add FileDescriptorTable for managing file descriptors and implement
  4-argument select() (pselect-style) for POE I/O multiplexing.

Generated with [Devin](https://cli.devin.ai/docs)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: fglock

src/main/java/org/perlonjava/core/Configuration.java

@@ -33,7 +33,7 @@ public final class Configuration {
      * Automatically populated by Gradle/Maven during build.
      * DO NOT EDIT MANUALLY - this value is replaced at build time.
      */
-    public static final String gitCommitId = "338bd4a90";
+    public static final String gitCommitId = "e0be7d89b";
 
     /**
      * Git commit date of the build (ISO format: YYYY-MM-DD).

src/main/java/org/perlonjava/frontend/parser/OperatorParser.java

@@ -1120,19 +1120,37 @@ static OperatorNode parseRequire(Parser parser) {
             // This avoids treating module names like "Encode" as subroutine calls when a sub
             // with the same name exists in the current package (e.g., sub Encode in Image::ExifTool)
             // But don't intercept quote-like operators like q(), qq(), etc.
+            //
+            // However, if the bareword is followed by `->`, it's a method call expression
+            // (e.g., `require File::Spec->catfile(...)`) and should be parsed as an expression.
+            int savedIndex = parser.tokenIndex;
             String moduleName = IdentifierParser.parseSubroutineIdentifier(parser);
             if (CompilerOptions.DEBUG_ENABLED) parser.ctx.logDebug("require module name `" + moduleName + "`");
             if (moduleName == null) {
                 throw new PerlCompilerException(parser.tokenIndex, "Syntax error", parser.ctx.errorUtil);
             }
 
-            // Check if module name starts with ::
-            if (moduleName.startsWith("::")) {
-                throw new PerlCompilerException(parser.tokenIndex, "Bareword in require must not start with a double-colon: \"" + moduleName + "\"", parser.ctx.errorUtil);
-            }
+            // Check if followed by `->` — if so, this is a method call, not a module name
+            LexerToken nextToken = peek(parser);
+            if (nextToken.type == OPERATOR && nextToken.text.equals("->")) {
+                // Restore position and fall through to expression parsing
+                parser.tokenIndex = savedIndex;
+                ListNode op = ListParser.parseZeroOrOneList(parser, 0);
+                if (op.elements.isEmpty()) {
+                    op.elements.add(scalarUnderscore(parser));
+                    operand = op;
+                } else {
+                    operand = op;
+                }
+            } else {
+                // Check if module name starts with ::
+                if (moduleName.startsWith("::")) {
+                    throw new PerlCompilerException(parser.tokenIndex, "Bareword in require must not start with a double-colon: \"" + moduleName + "\"", parser.ctx.errorUtil);
+                }
 
-            String fileName = NameNormalizer.moduleToFilename(moduleName);
-            operand = ListNode.makeList(new StringNode(fileName, parser.tokenIndex));
+                String fileName = NameNormalizer.moduleToFilename(moduleName);
+                operand = ListNode.makeList(new StringNode(fileName, parser.tokenIndex));
+            }
         } else {
             // Check for the specific pattern: :: followed by identifier (which is invalid for require)
             if (token.type == OPERATOR && token.text.equals("::")) {

src/main/java/org/perlonjava/runtime/io/FileDescriptorTable.java

@@ -0,0 +1,106 @@
+package org.perlonjava.runtime.io;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Maps simulated file descriptor numbers to IOHandle objects.
+ *
+ * <p>Java doesn't expose real POSIX file descriptors. This table assigns
+ * sequential integers starting from 3 (0, 1, 2 are reserved for
+ * stdin, stdout, stderr) and allows lookup by FD number.
+ *
+ * <p>Used by:
+ * <ul>
+ *   <li>{@code fileno()} — to return a consistent FD for each handle</li>
+ *   <li>4-arg {@code select()} — to map bit-vector bits back to handles</li>
+ * </ul>
+ *
+ * <p>Thread-safe: uses ConcurrentHashMap and AtomicInteger.
+ */
+public class FileDescriptorTable {
+
+    // Next FD number to assign.  0–2 are stdin/stdout/stderr.
+    private static final AtomicInteger nextFd = new AtomicInteger(3);
+
+    // FD number → IOHandle (for select() lookup)
+    private static final ConcurrentHashMap<Integer, IOHandle> fdToHandle = new ConcurrentHashMap<>();
+
+    // IOHandle identity → FD number (to avoid assigning multiple FDs to the same handle)
+    private static final ConcurrentHashMap<Integer, Integer> handleToFd = new ConcurrentHashMap<>();
+
+    /**
+     * Register an IOHandle and return its FD number.
+     * If the handle was already registered, returns the existing FD.
+     *
+     * @param handle the IOHandle to register
+     * @return the file descriptor number
+     */
+    public static int register(IOHandle handle) {
+        int identity = System.identityHashCode(handle);
+        Integer existing = handleToFd.get(identity);
+        if (existing != null) {
+            return existing;
+        }
+        int fd = nextFd.getAndIncrement();
+        fdToHandle.put(fd, handle);
+        handleToFd.put(identity, fd);
+        return fd;
+    }
+
+    /**
+     * Look up an IOHandle by its FD number.
+     *
+     * @param fd the file descriptor number
+     * @return the IOHandle, or null if not found
+     */
+    public static IOHandle getHandle(int fd) {
+        return fdToHandle.get(fd);
+    }
+
+    /**
+     * Remove a handle from the table (e.g., on close).
+     *
+     * @param fd the file descriptor number to remove
+     */
+    public static void unregister(int fd) {
+        IOHandle handle = fdToHandle.remove(fd);
+        if (handle != null) {
+            handleToFd.remove(System.identityHashCode(handle));
+        }
+    }
+
+    /**
+     * Check if a read-end handle has data available without blocking.
+     * Returns true if the handle is "ready for reading".
+     *
+     * @param handle the IOHandle to check
+     * @return true if data is available or handle is at EOF/closed
+     */
+    public static boolean isReadReady(IOHandle handle) {
+        if (handle instanceof InternalPipeHandle pipeHandle) {
+            return pipeHandle.hasDataAvailable();
+        }
+        if (handle instanceof StandardIO) {
+            // stdin: check System.in.available()
+            try {
+                return System.in.available() > 0;
+            } catch (Exception e) {
+                return false;
+            }
+        }
+        // For unknown handle types, report as ready to avoid blocking
+        return true;
+    }
+
+    /**
+     * Check if a write-end handle can accept writes without blocking.
+     *
+     * @param handle the IOHandle to check
+     * @return true if the handle can accept writes
+     */
+    public static boolean isWriteReady(IOHandle handle) {
+        // Pipes and most handles can always accept writes (they buffer internally)
+        return true;
+    }
+}

src/main/java/org/perlonjava/runtime/io/IOHandle.java

@@ -243,6 +243,26 @@ default RuntimeScalar flock(int operation) {
         return RuntimeIO.handleIOError("flock operation is not supported on this handle type.");
     }
 
+    /**
+     * Get the current blocking mode for this handle.
+     *
+     * @return true if the handle is in blocking mode (default), false if non-blocking
+     */
+    default boolean isBlocking() {
+        return true;
+    }
+
+    /**
+     * Set the blocking mode for this handle.
+     *
+     * @param blocking true for blocking mode, false for non-blocking
+     * @return true if the mode was successfully set
+     */
+    default boolean setBlocking(boolean blocking) {
+        // Default: only blocking mode is supported
+        return blocking;
+    }
+
     // System-level I/O operations
     default RuntimeScalar sysread(int length) {
         return RuntimeIO.handleIOError("sysread operation is not supported.");

src/main/java/org/perlonjava/runtime/io/InternalPipeHandle.java

@@ -25,11 +25,14 @@ public class InternalPipeHandle implements IOHandle {
     private final boolean isReader;
     private boolean isClosed = false;
     private boolean isEOF = false;
+    private final int fd;  // Simulated file descriptor number
+    private boolean blocking = true;  // Default: blocking mode
 
     private InternalPipeHandle(PipedInputStream inputStream, PipedOutputStream outputStream, boolean isReader) {
         this.inputStream = inputStream;
         this.outputStream = outputStream;
         this.isReader = isReader;
+        this.fd = FileDescriptorTable.register(this);
     }
 
     /**
@@ -130,6 +133,7 @@ public RuntimeScalar close() {
             }
             isClosed = true;
             isEOF = true;
+            FileDescriptorTable.unregister(fd);
             return scalarTrue;
         } catch (IOException e) {
             return handleIOException(e, "Close pipe failed");
@@ -173,7 +177,27 @@ public RuntimeScalar flush() {
 
     @Override
     public RuntimeScalar fileno() {
-        return RuntimeScalarCache.scalarUndef; // Internal pipes don't have file descriptors
+        return new RuntimeScalar(fd);
+    }
+
+    /**
+     * Check if this pipe handle has data available for reading without blocking.
+     * Used by the 4-arg select() implementation.
+     *
+     * @return true if data is available, the pipe is at EOF, or this is a write-end pipe
+     */
+    public boolean hasDataAvailable() {
+        if (!isReader) {
+            return false; // Write end is not "read-ready"
+        }
+        if (isClosed || isEOF) {
+            return true; // EOF/closed counts as "ready" (read returns 0/empty)
+        }
+        try {
+            return inputStream.available() > 0;
+        } catch (IOException e) {
+            return true; // Error counts as ready (will be detected on actual read)
+        }
     }
 
     @Override
@@ -204,6 +228,17 @@ public RuntimeScalar syswrite(String data) {
         }
     }
 
+    @Override
+    public boolean isBlocking() {
+        return blocking;
+    }
+
+    @Override
+    public boolean setBlocking(boolean blocking) {
+        this.blocking = blocking;
+        return true;
+    }
+
     @Override
     public RuntimeScalar sysread(int length) {
         if (!isReader) {
@@ -216,7 +251,31 @@ public RuntimeScalar sysread(int length) {
         }
 
         try {
-            // Always use polling for pipe reads to allow signal interruption
+            // Non-blocking mode: return immediately if no data available
+            if (!blocking) {
+                int available = inputStream.available();
+                if (available <= 0) {
+                    // Set $! to EAGAIN (Resource temporarily unavailable)
+                    getGlobalVariable("main::!").set(new RuntimeScalar(11)); // EAGAIN = 11 on most systems
+                    return new RuntimeScalar(); // undef
+                }
+                // Data available - read it
+                byte[] buffer = new byte[Math.min(length, available)];
+                int bytesRead = inputStream.read(buffer);
+
+                if (bytesRead == -1) {
+                    isEOF = true;
+                    return new RuntimeScalar("");
+                }
+
+                StringBuilder result = new StringBuilder(bytesRead);
+                for (int i = 0; i < bytesRead; i++) {
+                    result.append((char) (buffer[i] & 0xFF));
+                }
+                return new RuntimeScalar(result.toString());
+            }
+
+            // Blocking mode: poll with sleep for signal interruption
             while (true) {
                 if (Thread.interrupted()) {
                     PerlSignalQueue.checkPendingSignals();