parsanol 1.3.53-aarch64-linux → 1.3.56-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78cdeee79e9f782adaf7fbf1a179a3544d7586824fc58f92b380f7ad8867e050
-  data.tar.gz: f5052cd53addef5e182fa256dff390ad1242199bedf59c7ee19b998b648b42e7
+  metadata.gz: 06407307b9391eecc790b0d6364e2643ee15a1cee425233af4e66c119cde1c5e
+  data.tar.gz: 39627457a04894edc05c20599906995061ec110a6153197c3dd7b03a05b9e327
 SHA512:
-  metadata.gz: 49a0178ef44d9b294afe7274219d130fc9a53350f4d0af505b527a2eac2c94c60803334a378239466bc4950649a71999338bddab81e76b97372d84e15057becd
-  data.tar.gz: b935fc4ed2ebecae8960d3f35f5ba142dea1e24c6b9927cb7f50b6d9b16713ae58db6de5b99010c8c4431b26385b398563b6ac30be8d098a043e9a0831dc27c1
+  metadata.gz: 20e45402ce4f15e0d0f711498627f2c6c0b3f78723806a84b3ac2be1e37868bdeb817c7c5c196622e4eb4f0f662971b9cd87b50d48ac04bfa57578d424ca11b7
+  data.tar.gz: b63db5788cce9c5ecb96a08b1c3301a97a5f1862039ff3c968b453b724088c055be887652f59933db9bd2c3499e6e46b9b8ec11666c3caa67c2fc6798791098a

data/lib/parsanol/3.2/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.2/parsanol_native.so
-size: 34576408 bytes
-sha256: 5b8639e8add801e38778fc09193751011ee6b3fd7db507b9ac630ca8aa06046c
+size: 34626704 bytes
+sha256: 0976c692128d3f93b042159f46dc09f21e93d48e98e2004712c31f001ce6ab6b

data/lib/parsanol/3.3/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.3/parsanol_native.so
-size: 34819592 bytes
-sha256: 9697c96e0b02cdc86ed015e415b22d1e87f7f645008f81d4472b1f21b4154612
+size: 34861544 bytes
+sha256: c0e30ff6b7cdfd74a0d7dd07b2aaa0b4381585e02162bcb04ce786eee748726a

data/lib/parsanol/3.4/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.4/parsanol_native.so
-size: 34807048 bytes
-sha256: 43ef924415edbbafe3891e295ace6b289ef9ee3e744d6e84a75894538e7482a0
+size: 34857328 bytes
+sha256: 2380c24bf2c89e71dcf7521934b5e5bc57366fe0c00106d8aed715eaddbabd99

data/lib/parsanol/4.0/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/4.0/parsanol_native.so
-size: 34817024 bytes
-sha256: d70917dabf06b21743261e8b70ceea32e2bd8795f3604b86cc40bdacacd9e2ad
+size: 34867336 bytes
+sha256: f43381689aa3e99ff0c2bedd7611874e370344947576335c34a8a4cec2153cd7

data/lib/parsanol/atoms/base.rb

@@ -208,7 +208,7 @@ module Parsanol
 
       # Converts raw input to Source if needed.
       def normalize_input(source)
-        source.respond_to?(:line_and_column) ? source : Parsanol::Source.new(source)
+        source.is_a?(Parsanol::Source) ? source : Parsanol::Source.new(source)
       end
 
       # Detects if we're in a Parser context.

data/lib/parsanol/atoms/cut.rb

@@ -42,7 +42,7 @@ module Parsanol
         # 1. Mark the current position as a cut point
         # 2. Empty the backtrack stack (we won't backtrack past here)
         # 3. Aggressively evict cache entries before this position
-        context.cut!(source.bytepos) if context.respond_to?(:cut!)
+        context.cut!(source.bytepos)
 
         [success, value]
       end

data/lib/parsanol/atoms/repetition.rb

@@ -66,7 +66,7 @@ module Parsanol
       # @return [Array(Boolean, Object)] result
       def try(source, context, consume_all)
         # Check for tree memoization support
-        if context.respond_to?(:use_tree_memoization?) && context.use_tree_memoization?
+        if context.use_tree_memoization?
           return with_tree_cache(source, context, consume_all)
         end
 
@@ -183,6 +183,7 @@ module Parsanol
         last_failure = nil
 
         loop do
+          iteration_start = source.bytepos
           success, value = @parslet.apply(source, context, false)
 
           unless success
@@ -193,6 +194,11 @@ module Parsanol
           occurrence += 1
           result[occurrence] = value
 
+          # A body match that consumes nothing cannot make progress;
+          # looping again would re-match empty forever. Count the empty
+          # match, then stop — the min check below applies as usual.
+          break if source.bytepos == iteration_start
+
           break if @max && occurrence >= @max
         end
 
@@ -254,6 +260,7 @@ module Parsanol
         last_failure = nil
 
         loop do
+          iteration_start = source.bytepos
           success, value = @parslet.apply(source, context, false)
 
           unless success
@@ -265,6 +272,10 @@ module Parsanol
           result[occurrence] = value
           positions << source.bytepos
 
+          # Zero-width body match: count it, stop iterating (the min
+          # check below applies as usual) — mirrors try_general.
+          break if source.bytepos == iteration_start
+
           break if @max && occurrence >= @max
         end
 
@@ -287,7 +298,7 @@ module Parsanol
           context.store_tree_memo(cache_key, start_pos,
                                   result[1, occurrence], end_pos)
         end
-        context.release_array(positions) if context.respond_to?(:release_array)
+        context.release_array(positions)
 
         # Check minimum
         if occurrence < @min

data/lib/parsanol/cause.rb

@@ -74,7 +74,7 @@ module Parsanol
       line_num, col_num = @source.line_and_column(@position)
 
       formatted_msg = @message.map do |msg|
-        msg.respond_to?(:to_slice) ? msg.content.inspect : msg.to_s
+        msg.is_a?(Parsanol::Slice) ? msg.content.inspect : msg.to_s
       end.join
 
       "#{formatted_msg} at line #{line_num} char #{col_num}#{@parsing_label}."

data/lib/parsanol/error_reporter/contextual.rb

@@ -72,7 +72,7 @@ module Parsanol
         cause = super
 
         # Apply label if the atom has one
-        if atom.respond_to?(:label) && (lbl = atom.label)
+        if atom.is_a?(Parsanol::Atoms::Base) && (lbl = atom.label)
           maybe_update_label(lbl, src.pos.bytepos)
           cause.set_label(@active_label_text)
         end

data/lib/parsanol/lazy_result.rb

@@ -103,6 +103,15 @@ module Parsanol
 
     alias kind_of? is_a?
 
+    # The delegated interface: Array's full class contract (including
+    # Enumerable), computed once against the type rather than probed on
+    # instances.
+    ARRAY_METHODS = (
+      Array.instance_methods(true) + Enumerable.instance_methods + [:to_ary]
+    ).freeze
+
+    private_constant :ARRAY_METHODS
+
     # Respond to array methods.
     #
     # @param method [Symbol] Method name
@@ -110,7 +119,7 @@ module Parsanol
     # @return [Boolean] true if responds
     #
     def respond_to?(method, include_private = false)
-      super || to_a.respond_to?(method, include_private)
+      super || ARRAY_METHODS.include?(method)
     end
 
     # Delegate unknown methods to materialized array.
@@ -121,7 +130,7 @@ module Parsanol
     # @return [Object] Result of method call
     #
     def method_missing(method, ...)
-      if to_a.respond_to?(method)
+      if ARRAY_METHODS.include?(method)
         to_a.public_send(method, ...)
       else
         super
@@ -135,7 +144,7 @@ module Parsanol
     # @return [Boolean] true if method is supported
     #
     def respond_to_missing?(method, include_private = false)
-      to_a.respond_to?(method, include_private) || super
+      ARRAY_METHODS.include?(method) || super
     end
 
     # Compare with another object.

data/lib/parsanol/native/transformer.rb

@@ -391,15 +391,19 @@ module Parsanol
           return left.is_a?(Hash) ? left.merge(right) : left + right
         end
 
-        if left.respond_to?(:to_str) && right.respond_to?(:to_str)
-          return right if right.respond_to?(:to_slice)
-          return left if left.respond_to?(:to_slice)
-
-          return left.to_str + right.to_str
+        # String-like = String or Slice (both implement to_str). When
+        # only ONE side is string-like, the OTHER side wins — the
+        # original duck-typed priority, preserved exactly.
+        left_stringlike = left.is_a?(String) || left.is_a?(Parsanol::Slice)
+        right_stringlike = right.is_a?(String) || right.is_a?(Parsanol::Slice)
+        if left_stringlike && right_stringlike
+          return right if right.is_a?(Parsanol::Slice)
+          return left if left.is_a?(Parsanol::Slice)
+
+          return left + right
         end
-
-        return left if right.respond_to?(:to_str)
-        return right if left.respond_to?(:to_str)
+        return left if right_stringlike
+        return right if left_stringlike
 
         return left + [right] if right.is_a?(Hash)
         return [left] + right if left.is_a?(Hash)

data/lib/parsanol/native.rb

@@ -216,7 +216,9 @@ module Parsanol
         # cause from that directly — the failure path never needs a
         # reporter reparse. The single interpreter pass below stays only
         # to recover inputs from grammars native cannot express.
-        if grammar.respond_to?(:parse) && (m = error.message.match(NATIVE_POS_MARKER))
+        parsanol_grammar =
+          grammar.is_a?(Parsanol::Atoms::Base) || grammar.is_a?(Parsanol::Parser)
+        if parsanol_grammar && (m = error.message.match(NATIVE_POS_MARKER))
           source = Parsanol::Source.new(input)
           success, value = grammar.run_with_context(source, nil, true)
           return grammar.finalize_result(value) if success
@@ -227,7 +229,7 @@ module Parsanol
           raise Parsanol::ParseFailed.new(cause.to_s, cause)
         end
 
-        if grammar.respond_to?(:parse)
+        if parsanol_grammar
           # No native diagnostics (e.g. incomplete-input errors): one
           # interpreter pass with the reporter attached — a success
           # recovers the tree, a failure raises the cause tree.

data/lib/parsanol/parser.rb

@@ -255,7 +255,7 @@ module Parsanol
     # already produced. The full per-atom event stream of the Ruby
     # engine remains available via an explicit `mode: :ruby`.
     def feed_native_reporter(reporter, input, error)
-      return unless reporter.respond_to?(:err_at)
+      return unless reporter.is_a?(Parsanol::ErrorReporter::Base)
 
       source = Parsanol::Source.new(input)
       cause = error.parse_failure_cause

data/lib/parsanol/pattern.rb

@@ -90,7 +90,7 @@ module Parsanol
       return true if pattern_val === target
 
       # Check if pattern is a binding expression (like simple(:x))
-      if pattern_val.respond_to?(:can_bind?) && pattern_val.can_bind?(target)
+      if pattern_val.is_a?(Parsanol::Pattern::SubtreeBind) && pattern_val.can_bind?(target)
         return capture_binding(target, pattern_val, captured)
       end
 

data/lib/parsanol/pool.rb

@@ -119,7 +119,7 @@ module Parsanol
       end
 
       # Reset object state if it supports the protocol
-      obj.reset! if obj.respond_to?(:reset!)
+      obj.reset! if obj.is_a?(Parsanol::Resettable)
 
       @stats[:released] += 1
       @available.push(obj)

data/lib/parsanol/rope.rb

@@ -67,7 +67,7 @@ module Parsanol
     #
     # @return [Integer] The sum of all segment sizes
     def size
-      @segments.sum { |s| s.respond_to?(:size) ? s.size : s.to_s.size }
+      @segments.sum(&:size)
     end
 
     # Creates a rope from an existing string.

data/lib/parsanol/slice.rb

@@ -142,18 +142,16 @@ module Parsanol
 
     # Unified line/column computation:
     # - String input: compute from input string
-    # - LineCache: delegate to cache
+    # - Source / LineCache: delegate
     def line_and_column_at(pos)
-      if @input.respond_to?(:line_and_column)
-        # LineCache or duck-typed object
-        @input.line_and_column(pos)
-      else
-        # String input
+      if @input.is_a?(String)
         prefix = @input.byteslice(0, pos) || ""
         line = 1 + prefix.count("\n")
         last_nl = prefix.rindex("\n")
         column = last_nl ? pos - last_nl : pos + 1
         [line, column]
+      else
+        @input.line_and_column(pos)
       end
     end
   end

data/lib/parsanol/source/line_cache.rb

@@ -34,7 +34,7 @@ module Parsanol
       def line_and_column(position)
         scan_buffer_once
 
-        position = position.bytepos if position.respond_to?(:bytepos)
+        position = position.bytepos if position.is_a?(Parsanol::Source)
 
         line_idx = @breaks.lower_bound_index(position)
 

data/lib/parsanol/source.rb

@@ -33,9 +33,9 @@ module Parsanol
     # @raise [ArgumentError] if input doesn't respond to to_str
     #
     def initialize(input)
-      unless input.respond_to?(:to_str)
+      unless input.is_a?(String)
         raise ArgumentError,
-              "Source requires a string-like object (responds to to_str)"
+              "Source requires a String (got #{input.class})"
       end
 
       @raw_string = input.to_str

data/lib/parsanol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parsanol
-  VERSION = "1.3.53"
+  VERSION = "1.3.56"
 end

data/lib/parsanol/vm.rb

@@ -149,6 +149,7 @@ module Parsanol
       def compile_with_inline(atom, inline)
         root = atom.is_a?(Parsanol::Parser) ? atom.root : atom
         compiler = Compiler.new(inline: inline)
+        validate_alternatives(root)
         return nil unless compiler.compile_atom(root, true)
 
         # HALT terminates the MAIN program; subroutines follow it so the
@@ -156,9 +157,99 @@ module Parsanol
         compiler.ops << [HALT, nil, nil, nil]
         return nil unless compiler.append_subroutines
 
+        # Terminal failures jump to pc = FAIL without testing the pc
+        # register on the hot path; the dispatch case instead lands on
+        # this dedicated instruction (the last slot in the flat program),
+        # whose opcode is FAIL itself.
+        compiler.ops << [FAIL, nil, nil, nil]
+
+        # Structure-seeded memoization: a grammar containing repeat/maybe
+        # starts memoized on its very first parse (fresh parser instances
+        # included — the seed is recomputed at every compile), so the
+        # cold-start never pays the doomed unmemoized exploration.
+        if compiler.backtracking_prone
+          # rubocop:disable-next Lint/HashCompareByIdentity -- object_id keys match run_for's heavy flag; would otherwise pin every grammar alive
+          (@heavy ||= {})[root.object_id] = true
+        end
+
         compiler.to_program
       end
 
+      def validate_choice_branches(atom)
+        atom.alternatives.each_with_index do |branch, idx|
+          walk_branch = branch
+          next if idx == atom.alternatives.size - 1
+
+          # Entities resolve lazily and may be recursive; resolve
+          # through the wrapper for the nullability check only.
+          while walk_branch.is_a?(Parsanol::Atoms::Entity) ||
+              walk_branch.is_a?(Parsanol::Atoms::Named)
+            walk_branch = begin
+              walk_branch.parslet
+            rescue StandardError
+              nil
+            end
+            break if walk_branch.nil?
+          end
+          next if walk_branch.nil?
+          next unless Compiler.new.nullable?(walk_branch)
+
+          raise Parsanol::GrammarError,
+                "wrong grammar: alternative branch #{idx} " \
+                "(#{branch.inspect}) can match empty input and is not " \
+                "the last branch — ordered choice commits to its empty " \
+                "match, so #{atom.alternatives.size - idx - 1} later " \
+                "branch(es) can never match at positions where it " \
+                "matches empty. Reorder branches so empty-matchable " \
+                "ones come last, or make the branch non-empty."
+        end
+      end
+
+      # Grammar validation, run once per compile: an ordered-choice
+      # branch that can match empty input while not being last commits
+      # to its empty match and permanently shadows every later branch —
+      # the grammar is wrong, and inputs it would mis-parse fail with a
+      # baffling cause. Raise before any input is seen.
+      def validate_alternatives(root)
+        visited = {}.compare_by_identity
+        walk = lambda do |atom, depth|
+          next if atom.nil? || depth > 20
+          next if visited[atom]
+
+          visited[atom] = true
+          case atom
+          when Parsanol::Atoms::Alternative
+            validate_choice_branches(atom)
+            atom.alternatives.each { |c| walk.call(c, depth + 1) }
+          when Parsanol::Atoms::Sequence
+            atom.parslets.each { |c| walk.call(c, depth + 1) }
+          when Parsanol::Atoms::Repetition, Parsanol::Atoms::Named
+            walk.call(atom.parslet, depth + 1)
+          when Parsanol::Atoms::Lookahead
+            walk.call(atom.bound_parslet, depth + 1)
+          when Parsanol::Atoms::Ignored
+            walk.call(atom.wrapped_atom, depth + 1)
+          when Parsanol::Atoms::Entity
+            begin
+              walk.call(atom.parslet, depth + 1)
+            rescue Parsanol::GrammarError
+              raise
+            rescue StandardError
+              # Lazily resolved / recursive entity that cannot resolve
+              # outside a parse: skip this branch of the walk.
+              nil
+            end
+          when Parsanol::Atoms::Scope
+            begin
+              walk.call(atom.block.call, depth + 1)
+            rescue StandardError
+              nil
+            end
+          end
+        end
+        walk.call(root, 0)
+      end
+
       # Executes a compiled program. Returns [true, value] on success;
       # [false, nil] on failure or budget exhaustion — callers fall back
       # to the interpreter, which reproduces exact diagnostics.
@@ -248,9 +339,10 @@ module Parsanol
         @inline = inline
         @subs = {}      # [obj_id, flag] => pc or :pending
         @pending = {}   # [obj_id, flag] => [[call_idx, body], ...]
+        @backtracking_prone = false
       end
 
-      attr_reader :ops
+      attr_reader :ops, :backtracking_prone
 
       def to_program
         return :oversize if @ops.size > MAX_PROGRAM
@@ -608,6 +700,11 @@ module Parsanol
       # * unbounded-plus of a single terminal (non-spine sites) -> greedy
       #   RUN_* op
       def compile_repetition(atom, consume_all)
+        # Any repetition (repeat, maybe, repeat(0)) can re-explore the
+        # same rule+position pairs when a later sibling fails; grammars
+        # containing one memoize from the first parse instead of waiting
+        # for the naive pass to prove the need.
+        @backtracking_prone = true
         min = atom.min
         max = atom.max
         return nil if max&.zero?
@@ -737,6 +834,10 @@ module Parsanol
       def execute # rubocop:disable Metrics/MethodLength, Metrics/BlockLength, Metrics/BlockNesting -- single dispatch loop; hot path
         ops = @ops
         input = @input
+        # Dedicated FAIL landing instruction appended after HALT and the
+        # subroutines: `pc = fail_pc` dispatches straight into when-FAIL
+        # on the next cycle, no sentinel comparison per step.
+        fail_pc = ops.size - 4
         bytes = input.unpack("C*")
         # Regexp#match?(str, pos) searches FORWARD from pos (unanchored);
         # StringScanner#match? is position-anchored, matching the
@@ -800,7 +901,7 @@ module Parsanol
               pos += ops[pc + 3]
               pc += 4
             else
-              pc = FAIL
+              pc = fail_pc
             end
           when RE
             b = bytes[pos]
@@ -819,7 +920,7 @@ module Parsanol
               pos += w
               pc += 4
             else
-              pc = FAIL
+              pc = fail_pc
             end
           when ANY
             if pos < n
@@ -829,7 +930,7 @@ module Parsanol
               pos += w
               pc += 4
             else
-              pc = FAIL
+              pc = fail_pc
             end
           when SEQ_BEGIN
             rstack << SEQ_MARK
@@ -878,7 +979,7 @@ module Parsanol
                   # PENDING — re-entry at the same rule+position (left
                   # recursion); the interpreter loops forever here, so
                   # failing this path keeps the VM bounded.
-                  pc = FAIL
+                  pc = fail_pc
                   next
                 end
                 # Memo hit: replay the subroutine's stack effect without
@@ -926,7 +1027,7 @@ module Parsanol
             rlen = bt[-BT_STRIDE + 2]
             rstack.slice!(rlen..) if rstack.size > rlen
             bt.pop(BT_STRIDE)
-            pc = FAIL
+            pc = fail_pc
           when DROP
             rstack.pop
             rstack << nil
@@ -952,12 +1053,24 @@ module Parsanol
             count = frames[cbase]
             return BAIL if count.nil?
 
+            old_end = frames[cbase + 1]
             count += 1
             frames[cbase] = count
             frames[cbase + 1] = pos
             max = ops[pc + 3]
             pc = if max && count >= max
                    ops[pc + 2] # exit
+                 elsif pos == old_end
+                   # Zero-width body match: count it, stop iterating.
+                   # Mirrors Repetition#try_general: success with the
+                   # prefix when min is met, failure of the repetition
+                   # otherwise.
+                   if count >= frames[cbase + 3]
+                     ops[pc + 2] # exit
+                   else
+                     frames.slice!(cbase..)
+                     fail_pc
+                   end
                  else
                    ops[pc + 1] # test
                  end
@@ -967,7 +1080,7 @@ module Parsanol
 
             if ops[pc + 2] == 1 && pos != n
               frames.slice!(cbase..)
-              pc = FAIL
+              pc = fail_pc
             else
               rbase = frames[cbase + 2]
               values = rstack.pop(rstack.size - rbase)
@@ -980,7 +1093,7 @@ module Parsanol
             table = ops[pc + 1]
             b = pos < n ? bytes[pos] : -1
             target = b == -1 ? -1 : table[b]
-            pc = target >= 0 ? target : FAIL
+            pc = target >= 0 ? target : fail_pc
           when SEQ_SIMPLE
             kids = ops[pc + 1]
             kn = kids.size
@@ -1115,7 +1228,7 @@ module Parsanol
               ki += 4
             end
             if failed
-              pc = FAIL
+              pc = fail_pc
             else
               rstack << values
               pc += 4
@@ -1180,7 +1293,7 @@ module Parsanol
               pos += w
             end
             if min && values.size - 1 < min
-              pc = FAIL
+              pc = fail_pc
             else
               rstack << values
               pc += 4
@@ -1206,14 +1319,14 @@ module Parsanol
               pos += ln
             end
             if min && values.size - 1 < min
-              pc = FAIL
+              pc = fail_pc
             else
               rstack << values
               pc += 4
             end
           when HALT
             if @consume_all && pos != n
-              pc = FAIL
+              pc = fail_pc
               next
             end
             value = VM.materialize(rstack[0], input)

data/lib/parsanol.rb

@@ -44,6 +44,12 @@ module Parsanol
     base.extend(ClassMethods)
   end
 
+  # Raised when the GRAMMAR itself is malformed — detected before any
+  # input is parsed. The canonical case: an ordered-choice branch that
+  # can match empty input while not being last, which commits to its
+  # empty match and permanently shadows every later branch.
+  class GrammarError < StandardError; end
+
   # Exception raised when parsing fails. Contains detailed error information
   # in the #parse_failure_cause attribute.
   class ParseFailed < StandardError

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.53
+  version: 1.3.56
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-09-23 00:00:00.000000000 Z
+date: 2026-09-24 00:00:00.000000000 Z
 dependencies: []
 description: A small Ruby library for constructing parsers in the PEG (Parsing Expression
   Grammar) fashion. Parsanol provides Parslet-compatible API with additional features