Performance: Use local variables in FastReader.readUntil() hot loops

Copy member fields to locals before loops and write back after.
This allows the JVM to keep loop variables in CPU registers rather
than repeatedly loading/storing from heap memory.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jdereg

changelog.md

@@ -10,6 +10,7 @@
   * Reads characters into destination buffer until one of two delimiters is found
   * Delimiter character is left unconsumed for subsequent read
   * Enables bulk string parsing optimization in json-io's JsonParser
+  * Uses local variables instead of member fields in hot loops to enable register allocation
 
 #### 4.89.0 - 2026-01-31
 * **PERFORMANCE**: `FastReader.getLastSnippet()` now returns bounded 200-char context

src/main/java/com/cedarsoftware/util/FastReader.java

@@ -167,39 +167,57 @@ public int readUntil(char[] dest, int off, int maxLen, char delim1, char delim2)
 
         int totalRead = 0;
 
+        // Copy member variables to locals for faster loop access (avoids repeated field loads)
+        final char[] localPushbackBuffer = pushbackBuffer;
+        final int localPushbackBufferSize = pushbackBufferSize;
+        int localPushbackPosition = pushbackPosition;
+        final char[] localBuf = buf;
+        int localPosition = position;
+        int localLimit = limit;
+
         // First, drain any pushback buffer
-        while (pushbackPosition < pushbackBufferSize && totalRead < maxLen) {
-            char c = pushbackBuffer[pushbackPosition];
+        while (localPushbackPosition < localPushbackBufferSize && totalRead < maxLen) {
+            char c = localPushbackBuffer[localPushbackPosition];
             if (c == delim1 || c == delim2) {
                 // Found delimiter in pushback - don't consume it
+                pushbackPosition = localPushbackPosition;  // Write back before return
                 return totalRead > 0 ? totalRead : 0;
             }
             dest[off++] = c;
-            pushbackPosition++;
+            localPushbackPosition++;
             totalRead++;
         }
+        pushbackPosition = localPushbackPosition;  // Write back after pushback loop
 
         // Now read from main buffer
         while (totalRead < maxLen) {
+            // Write back position before fill() since fill() may modify position/limit
+            position = localPosition;
             fill();
-            if (limit == -1) {
+            // Re-read after fill() since it may have changed position and limit
+            localPosition = position;
+            localLimit = limit;
+
+            if (localLimit == -1) {
                 // EOF reached
                 return totalRead > 0 ? totalRead : -1;
             }
 
             // Scan current buffer for delimiters
-            while (position < limit && totalRead < maxLen) {
-                char c = buf[position];
+            while (localPosition < localLimit && totalRead < maxLen) {
+                char c = localBuf[localPosition];
                 if (c == delim1 || c == delim2) {
                     // Found delimiter - don't consume it
+                    position = localPosition;  // Write back before return
                     return totalRead;
                 }
                 dest[off++] = c;
-                position++;
+                localPosition++;
                 totalRead++;
             }
         }
 
+        position = localPosition;  // Write back after main loop
         return totalRead;
     }