parsanol 1.3.11-aarch64-linux → 1.3.13-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4aed187d34b80f934b13f77ed2967b33625c97315dd5222382b3e701469863c6
-  data.tar.gz: 44b0f250d6d7a096a507c83db4993ff34db5cba69818409d96216faa97a5397f
+  metadata.gz: 505377abc4ee0881c63542fd97282e9a0ca5593cc2c33e07a2d7d633c971812e
+  data.tar.gz: 4d19be4d748835f54c4e9cc8ef8147c8b9ef5f80fb65e1539d3bcac93062cbe2
 SHA512:
-  metadata.gz: 21a32ac830df5952dc9fd33038aecac5b0e26ea9f8c97e80c81bba6bd6111744642973dd971d03d9493ca6d72f1c3da6835e5f8afd0c0575fbbee2852568d29e
-  data.tar.gz: b302062fc371a19c393a2ceb58cdb4eb70defefac240a3141bc22e123813e562fadca3c4d2f638684b5eef1a2b695a2f7ec88e998033ae832183be2662e78088
+  metadata.gz: b8ee108a7a194731eac0e33f659950c5210aadeb4ca1051c6e6e5910d711d2429f19a2bf57360b10fc444ec88ba221a0bb7932a316b8d5ed8943b1002243efac
+  data.tar.gz: 1b40341768f14294e00c24fba277a4ec187dafdab70e104c6fc6468df493d4fd07f871bc06bf972941796ad8ab01805eb095cecc26d74248004c1834631b18a3

data/lib/parsanol/atoms/context.rb

@@ -28,6 +28,9 @@ module Parsanol
         :default => 1000,
       }.freeze
 
+      # Number of observed backtrack events before packrat caching engages.
+      BACKTRACK_ACTIVATION_LIMIT = 64
+
       # Creates a new parsing context.
       #
       # @param error_reporter [#err, #err_at] error reporter instance
@@ -40,7 +43,7 @@ module Parsanol
                      adaptive_cache_threshold: nil,
                      parser_class: nil)
         # Core memoization cache: position -> { atom_id -> [result, advance] }
-        @memo = Hash.new { |h, k| h[k] = {} }
+        @memo = {}
 
         # Error reporting delegate
         @reporter = error_reporter
@@ -55,7 +58,7 @@ module Parsanol
         @evict_interval = 100
 
         # Object pools for reducing allocations
-        @array_pool = Parsanol::Pools::ArrayPool.new(size: 10_000)
+        @array_pool = Parsanol::Pools::ArrayPool.new(size: 10_000, preallocate: false)
         @buffer_pool = Parsanol::Pools::BufferPool.new(pool_size: 100)
 
         # Selective memoization tracking
@@ -85,7 +88,8 @@ module Parsanol
 
         @adaptive_threshold = threshold
         @input_len = nil
-        @caching_active = nil
+        @caching_active = false
+        @backtrack_events = 0
       end
 
       # Attempts to parse using memoization. Returns cached result if available,
@@ -100,21 +104,18 @@ module Parsanol
         # Skip caching for atoms that don't benefit from it
         return atom.try(src, self, must_consume_all) unless atom.cached?
 
-        # Determine if caching should be active (lazy initialization)
-        if @caching_active.nil?
-          total_len = src.bytepos + src.chars_left
-          @input_len = total_len
-          @caching_active = total_len >= @adaptive_threshold
-        end
-
-        # For small inputs, skip caching overhead
-        return atom.try(src, self, must_consume_all) unless @caching_active
-
         # Use interval-based caching if enabled
         return try_with_interval(atom, src, must_consume_all) if @use_intervals
 
+        # Adaptive activation: packrat memoization costs more than it saves
+        # on deterministic forward-only grammars, so start uncached and only
+        # engage once real backtracking (re-parsing behind the progress
+        # frontier) is observed.
+        return try_uncached_probe(atom, src, must_consume_all) unless @caching_active
+
         pos = src.bytepos
         key = atom.object_id
+        entry = @memo[pos]
 
         # Periodic cache eviction to prevent unbounded growth
         if pos > @furthest_pos
@@ -128,10 +129,10 @@ module Parsanol
           end
         end
 
-        # Check for cache hit
-        if @memo[pos].key?(key)
+        # Check for cache hit (avoid default-block Hash allocation per probe)
+        if entry&.key?(key)
           @hit_stats[key] += 1
-          outcome, delta = @memo[pos][key]
+          outcome, delta = entry[key]
           src.bytepos = pos + delta
           return outcome
         end
@@ -144,7 +145,7 @@ module Parsanol
         # Only cache if beneficial (heuristic)
         attempts = @hit_stats[key] + @miss_stats[key]
         if attempts <= @min_hits_for_cache || @hit_stats[key].positive?
-          @memo[pos][key] =
+          (@memo[pos] ||= {})[key] =
             [outcome,
              delta]
         end
@@ -327,6 +328,21 @@ module Parsanol
 
       private
 
+      # Executes an atom without memoization while watching for backtracking.
+      # A failed attempt at a position behind the progress frontier means work
+      # is being re-done; once that repeats, packrat caching engages.
+      def try_uncached_probe(atom, src, must_consume_all)
+        pos = src.bytepos
+        outcome = atom.try(src, self, must_consume_all)
+        if pos > @furthest_pos
+          @furthest_pos = pos
+        elsif !outcome[0] && pos < @furthest_pos
+          @backtrack_events += 1
+          @caching_active = true if @backtrack_events >= BACKTRACK_ACTIVATION_LIMIT
+        end
+        outcome
+      end
+
       # Lookup cached result (uses object_id for speed)
       def lookup(atom, pos)
         @memo[pos][atom.object_id]

data/lib/parsanol/native/serializer.rb

@@ -120,6 +120,7 @@ module Parsanol
           "atom" => serialize_atom(atom.parslet),
           "min" => atom.min,
           "max" => atom.max,
+          "tag" => atom.result_tag == :maybe ? "Maybe" : "Repetition",
         },
       }
     end

data/lib/parsanol/native/transformer.rb

@@ -28,10 +28,19 @@ module Parsanol
       # This is a class variable to share across all transformations
       @@symbol_cache = {}
 
-      def self.transform(ast)
+      # Symbol tags from native parser
+      SEQUENCE_SYM = :sequence
+      REPETITION_SYM = :repetition
+      MAYBE_SYM = :maybe
+      MAYBE_TAG = ":maybe"
+
+      # `named` mirrors CanFlatten#flatten's named flag: inside a Named
+      # result (.as), an absent maybe flattens to nil; unnamed it flattens
+      # to "".
+      def self.transform(ast, named: false)
         case ast
         when Array
-          transform_array(ast)
+          transform_array(ast, named: named)
         when Hash
           transform_hash(ast)
         else
@@ -52,11 +61,7 @@ module Parsanol
         @@symbol_cache[key] ||= key.to_sym
       end
 
-      # Symbol tags from native parser
-      SEQUENCE_SYM = :sequence
-      REPETITION_SYM = :repetition
-
-      def self.transform_array(arr)
+      def self.transform_array(arr, named: false)
         return EMPTY_ARRAY if arr.empty? # Match Parsanol Ruby mode behavior
 
         # Check if this is a tagged array from native parser
@@ -87,6 +92,16 @@ module Parsanol
             i += 1
           end
           flatten_repetition(items)
+        elsif [MAYBE_SYM, MAYBE_TAG].include?(first)
+          # Maybe flattens to nil-or-value (named) or ""-or-value (unnamed),
+          # never to an array
+          len = arr.length
+          if len == 1
+            named ? nil : EMPTY_STRING
+          else
+            flattened = transform(arr[1])
+            named ? flattened : (flattened || EMPTY_STRING)
+          end
         elsif first.is_a?(Symbol) || (first.is_a?(String) && first.start_with?(":"))
           # Other tagged arrays - pass through
           arr.map { |item| transform(item) }
@@ -115,7 +130,7 @@ module Parsanol
         sym_key = cached_symbol(key)
 
         # Transform the value
-        transformed = transform(value)
+        transformed = transform(value, named: true)
 
         # Check if value is a tagged repetition from native parser
         is_tagged_repetition = value.is_a?(Array) && !value.empty? &&
@@ -240,7 +255,7 @@ module Parsanol
           is_repetition = value.is_a?(Array) && !value.empty? &&
             value.first.is_a?(String) && value.first == REPETITION_TAG
 
-          transformed = transform(value)
+          transformed = transform(value, named: true)
 
           result[sym_key] = if is_repetition
                               if transformed.is_a?(Array)

data/lib/parsanol/native.rb

@@ -48,7 +48,11 @@ module Parsanol
         # Use _parse_raw which returns properly tagged Ruby arrays via transform_ast.
         # The batch format doesn't preserve :repetition/:sequence tags, so we use
         # the direct FFI path. Apply the Ruby transformer to handle tags correctly.
-        raw_ast = _parse_raw(grammar_json, input)
+        begin
+          raw_ast = _parse_raw(grammar_json, input)
+        rescue RuntimeError => e
+          raise_native_parse_error(e, grammar, input)
+        end
         BatchDecoder.decode_and_flatten(raw_ast, input, Parsanol::Slice)
       end
 
@@ -69,7 +73,11 @@ module Parsanol
                          Parser.serialize_grammar(grammar)
                        end
 
-        raw_ast = _parse_fresh_raw(grammar_json, input)
+        begin
+          raw_ast = _parse_fresh_raw(grammar_json, input)
+        rescue RuntimeError => e
+          raise_native_parse_error(e, grammar, input)
+        end
         BatchDecoder.decode_and_flatten(raw_ast, input, Parsanol::Slice)
       end
 
@@ -182,6 +190,22 @@ module Parsanol
         end
         stats
       end
+
+      # Translates a native backend failure into the Parsanol error protocol.
+      #
+      # When the grammar atom is at hand, reparses through the pure Ruby
+      # backend: a Ruby failure raises Parsanol::ParseFailed with the full
+      # cause-tree diagnostics, and a Ruby success recovers grammars the
+      # native serializer cannot express (e.g. custom atoms). For
+      # pre-serialized JSON grammars the native message is wrapped in a
+      # Parsanol::ParseFailed directly.
+      def raise_native_parse_error(error, grammar, input)
+        return grammar.parse(input) if grammar.respond_to?(:parse)
+
+        source = Parsanol::Source.new(input)
+        cause = Parsanol::Cause.new(error.message, source, source.bytepos)
+        raise Parsanol::ParseFailed.new(cause.to_s, cause)
+      end
     end
   end
 end

data/lib/parsanol/parser.rb

@@ -112,10 +112,18 @@ module Parsanol
       if mode_or_opts.is_a?(Hash) && !kwargs.key?(:mode)
         # Legacy API: parse(input, options={})
         merged = mode_or_opts.merge(kwargs)
-        super(input, merged)
+        if Parsanol::Native.available? && !merged.key?(:prefix) &&
+            !merged.key?(:reporter)
+          # Native backend by default; falls back to pure Ruby inside
+          # parse_native when the extension is missing.
+          parse_native(input, merged)
+        else
+          super(input, merged)
+        end
       else
         # New API: parse(input, mode:, **options)
-        mode = kwargs.delete(:mode) || :ruby
+        mode = kwargs.delete(:mode) ||
+          (Parsanol::Native.available? ? :native : :ruby)
         case mode
         when :ruby
           super(input, kwargs)
@@ -209,7 +217,8 @@ module Parsanol
       if Parsanol::Native.available?
         Parsanol::Native.parse(root, input)
       else
-        super
+        Parsanol::Atoms::Base.instance_method(:parse).bind_call(self, input,
+                                                                opts)
       end
     end
 

data/lib/parsanol/pools/buffer_pool.rb

@@ -151,7 +151,14 @@ module Parsanol
       # @return [Integer] Size class
       #
       def select_size_class(size)
-        SIZE_CLASSES.find { |sc| sc >= size } || next_power_of_2(size)
+        i = 0
+        n = SIZE_CLASSES.length
+        while i < n
+          return SIZE_CLASSES[i] if SIZE_CLASSES[i] >= size
+
+          i += 1
+        end
+        next_power_of_2(size)
       end
 
       # Find next power of 2 greater than or equal to n.

data/lib/parsanol/source.rb

@@ -53,7 +53,7 @@ module Parsanol
 
       # Object pools for memory efficiency
       # SlicePool: reduces Slice allocations during matching
-      @slice_pool = Parsanol::Pools::SlicePool.new(size: 5000)
+      @slice_pool = Parsanol::Pools::SlicePool.new(size: 5000, preallocate: false)
 
       # PositionPool: reduces Position allocations for error reporting
       @position_pool = Parsanol::Pools::PositionPool.new(size: 1000)

data/lib/parsanol/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.11
+  version: 1.3.13
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-04-15 00:00:00.000000000 Z
+date: 2026-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -151,6 +151,7 @@ files:
 - README.adoc
 - Rakefile
 - lib/parsanol.rb
+- lib/parsanol/3.2/parsanol_native.so
 - lib/parsanol/3.3/parsanol_native.so
 - lib/parsanol/3.4/parsanol_native.so
 - lib/parsanol/4.0/parsanol_native.so
@@ -261,7 +262,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.3'
+      version: '3.2'
   - - "<"
     - !ruby/object:Gem::Version
       version: 4.1.dev