parsanol 1.3.54-arm-linux → 1.3.57-arm-linux

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.54"
+  VERSION = "1.3.57"
 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
@@ -167,13 +168,88 @@ module Parsanol
         # 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
+          # rubocop:disable-next Lint/HashCompareByIdentity -- object_id keys mirror run_for's heavy flag
           (@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.
@@ -380,8 +456,7 @@ module Parsanol
         end
       end
 
-      # Wrapper branches (Entity/Scope) share body shapes by design.
-      # rubocop:disable-next Lint/DuplicateBranch
+      # rubocop:disable Lint/DuplicateBranch -- Wrapper branches (Entity/Scope) share body shapes by design
       def nullable?(atom, depth = 0)
         return false if depth > 10
 
@@ -397,12 +472,14 @@ module Parsanol
         when Parsanol::Atoms::Ignored then nullable?(atom.wrapped_atom, depth + 1)
         when Parsanol::Atoms::Lookahead then true
         when Parsanol::Atoms::Entity, Parsanol::Atoms::Scope
-          nullable_wrapped?( # rubocop:disable Lint/DuplicateBranch -- Entity/Scope differ only in accessor
+          # rubocop:disable Lint/DuplicateBranch -- Entity/Scope differ only in accessor
+          nullable_wrapped?(
             -> { atom.is_a?(Parsanol::Atoms::Entity) ? atom.parslet : atom.block.call }, depth
           )
         else false
         end
       end
+      # rubocop:enable Lint/DuplicateBranch
 
       # Entity and Scope wrap lazily-resolvable inners through different
       # accessors; the nullability logic is shared.
@@ -790,7 +867,7 @@ module Parsanol
         memo_stack = []
         trace = ENV["VM_TRACE"] ? [] : nil
 
-        # rubocop:disable-next Metrics/BlockLength -- the dispatch loop IS execute
+        # rubocop:disable Metrics/BlockLength -- the dispatch loop IS execute
         loop do
           steps += 1
           if steps > budget
@@ -977,12 +1054,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
@@ -1252,6 +1341,7 @@ module Parsanol
           else
             return BAIL
           end
+          # rubocop:enable Metrics/BlockLength
         end
       end
 

data/lib/parsanol.rb

@@ -39,11 +39,20 @@
 # Inspired by Parslet (MIT License).
 
 module Parsanol
+  # The PARG grammar language (text source -> checksummed artifact).
+  autoload :PARG, "parsanol/parg"
+
   # Hook to extend including classes with ClassMethods.
   def self.included(base)
     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

data/parsanol.gemspec

@@ -29,7 +29,9 @@ Gem::Specification.new do |spec|
   # Rust extension
   spec.extensions = ["ext/parsanol_native/extconf.rb"]
 
-  spec.files = Dir.glob("{lib,ext}/**/*") + %w[
+  spec.executables = %w[parsanol]
+  spec.bindir = "exe"
+  spec.files = Dir.glob("{lib,ext,exe}/**/*") + %w[
     HISTORY.txt
     LICENSE
     Rakefile

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.54
+  version: 1.3.57
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2026-09-24 00:00:00.000000000 Z
+date: 2026-09-30 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
@@ -16,7 +16,8 @@ description: A small Ruby library for constructing parsers in the PEG (Parsing E
   for improved performance.
 email:
 - open.source@ribose.com
-executables: []
+executables:
+- parsanol
 extensions: []
 extra_rdoc_files: []
 files:
@@ -24,6 +25,7 @@ files:
 - LICENSE
 - README.adoc
 - Rakefile
+- exe/parsanol
 - lib/parsanol.rb
 - lib/parsanol/3.2/parsanol_native.so
 - lib/parsanol/3.3/parsanol_native.so
@@ -91,6 +93,31 @@ files:
 - lib/parsanol/options.rb
 - lib/parsanol/options/zero_copy.rb
 - lib/parsanol/parallel.rb
+- lib/parsanol/parg.rb
+- lib/parsanol/parg/artifact.rb
+- lib/parsanol/parg/authoring.rb
+- lib/parsanol/parg/bindings.rb
+- lib/parsanol/parg/cli.rb
+- lib/parsanol/parg/compiler.rb
+- lib/parsanol/parg/derive.rb
+- lib/parsanol/parg/document.rb
+- lib/parsanol/parg/error.rb
+- lib/parsanol/parg/frontend.rb
+- lib/parsanol/parg/import.rb
+- lib/parsanol/parg/importers/abnf.rb
+- lib/parsanol/parg/importers/ebnf.rb
+- lib/parsanol/parg/importers/pest.rb
+- lib/parsanol/parg/imports.rb
+- lib/parsanol/parg/lexer.rb
+- lib/parsanol/parg/lints.rb
+- lib/parsanol/parg/lsp.rb
+- lib/parsanol/parg/lutaml.rb
+- lib/parsanol/parg/node.rb
+- lib/parsanol/parg/parser.rb
+- lib/parsanol/parg/preprocess.rb
+- lib/parsanol/parg/render.rb
+- lib/parsanol/parg/selfhost.rb
+- lib/parsanol/parg/visitor.rb
 - lib/parsanol/parser.rb
 - lib/parsanol/parslet.rb
 - lib/parsanol/pattern.rb