parsanol 1.3.114-arm-linux → 1.3.116-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ccfe53145a4fbf2af4f7c2cc47071231be0016d8047e9bb0f75386738ff0480
-  data.tar.gz: 395d7bccac544d4842b29e5764d1198816ab823e1f9defdc3874009395caaa24
+  metadata.gz: 53a5e42c7662bba04ee275b1679b942f05064c09ded4a8d0108b7fa1a4a6ca6a
+  data.tar.gz: 7c14ce10502509c398b7303dab5cb11962a6ff8a4b8108ed94fb23aa88f7bbce
 SHA512:
-  metadata.gz: b1436b7af7ea025b302e14fc14970c42252c75f5aa6a2252f1701862ebca604ccc05349a39fdbd77b09fef78c7e633b9a6ff15c3f22e3a36845f49133a84eb7a
-  data.tar.gz: 188fe5c41d516ab6f3372ca339d0c313b0460e912e122a9e32ed5f8b948deb743c3a38f406997dddbb97cc9e3a5a7a25587640273eb44c97dde75d518d24ad6b
+  metadata.gz: 1d49c7d42d94edc62d2e7503650bc59d8d2e40c6f067aed05fe154bea4a24a90b2aea6c096110f7cc3b8517dfda73a22c21fdb6c272783df35517a6b57d9da09
+  data.tar.gz: b1373d5e437f0ed0e3caccebea3658bed5ba52036eb56ec65c1a4f1fd98026428b565047178032a4f607e34e7735fe3664f9c826421bb11ba8111a22702c0dd3

data/README.adoc

@@ -31,6 +31,17 @@ While maintaining full API compatibility with Parslet, Parsanol features a compl
 * <<debug-tools,Debug Tools>> - Tracing and grammar visualization
 * <<benchmarking,Benchmarking>> - Built-in performance testing tools
 
+== Releases
+
+parsanol is one product on **four runtimes**: **rs** (crates.io +
+`@parsanol/wasm` + release binaries), **ruby** (rubygems), **python**
+(PyPI, `parsanol`), and **typescript** (npm, `parsanol` — the
+wasm-backed runtime). **Every engine update releases all four
+together**; a release that ships some runtimes and not the rest is
+incomplete. If the runtime you use lags the latest grammar-language
+features, check the other registries' changelogs and the release train
+on the https://github.com/parsanol/parsanol-ruby/actions[Release workflow].
+
 == Installation
 
 Add this line to your application's Gemfile:

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: 39082700 bytes
-sha256: d252dd306fb0dcb4726ed8a1deb826cecfc1ca8bf5528603f50ac20058e0aea9
+size: 39369156 bytes
+sha256: f4664338d4a5f66572c33e06d923912d35f98bce860d2dcc8379f065622c6e29

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: 39267920 bytes
-sha256: 4f500faf69c8b85dff0055043e37d08bdb897cabd0bc814ce1a5a7f31db0fad4
+size: 39554396 bytes
+sha256: b8cc982625b2a18b7dd699d3da005cccf219e5fdb40a6530080547d10fb6a457

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: 39262108 bytes
-sha256: b24c02b2f5d0848c59dba33cf4751107b1799ec8f96c961c3952114e96eb10f7
+size: 39548524 bytes
+sha256: 355d9d4cfaa75f673c7b565296ad4abd101a5a71f9b2c2bb6d4b3b387be8d3fb

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: 39271824 bytes
-sha256: 3bc6176aec3d4bb697ce024b174ddeca6a4b50a297bdd84492a277205e46efed
+size: 39558200 bytes
+sha256: d14cb28779b08d3916683b1c66f7e9f25d29891d9622fab2643724d095d246d7

data/lib/parsanol/atoms/alternative.rb

@@ -117,7 +117,9 @@ module Parsanol
         # The reporting pass (the re-parse after a failure) must try every
         # branch so the failure cause tree stays complete; the literal index
         # only prunes the fast non-reporting pass.
-        unless context.reporting?
+        # Legacy memo answers depend on attempted branches, including a
+        # prefix success in a branch that later fails its literal suffix.
+        unless context.reporting? || context.parslet_compatible?
           indexed = candidate_indexes(source)
           if indexed
             return try_selected(indexed, options, source, context, consume_all)

data/lib/parsanol/atoms/base.rb

@@ -27,17 +27,27 @@ module Parsanol
       # @param options [Hash] parsing options
       # @option options [Parsanol::ErrorReporter] :reporter error collector
       # @option options [Boolean] :prefix allow partial parse (default: false)
+      # @option options [Symbol] :compatibility :strict (default), or :parslet
+      #   for legacy consume-all memo decisions on the Ruby interpreter
       # @return [Object] the parsed result
       # @raise [Parsanol::ParseFailed] on parse failure
       def parse(source, options = {})
         must_consume_all = !options[:prefix]
+        compatibility = options.fetch(:compatibility, :strict)
+        unless %i[strict parslet].include?(compatibility)
+          raise ArgumentError, "Unknown compatibility policy: #{compatibility}"
+        end
+
+        context_options = compatibility == :strict ? {} : { compatibility: compatibility }
 
         # Compiled-VM fast path: String input, full-consumption semantics.
         # On failure (or unsupported grammar / budget exhaustion) fall
         # through to the interpreter, which also produces the exact
         # cause-tree diagnostics. run_for memoizes heavy-backtracking
         # grammars transparently.
-        if must_consume_all && source.is_a?(String) &&
+        # The VM implements strict memo semantics. The opt-in legacy policy
+        # is currently supported by the Ruby interpreter only.
+        if compatibility == :strict && must_consume_all && source.is_a?(String) &&
             (program = VM.program_for(self))
           begin
             result = VM.run_for(self, program, source, true)
@@ -62,12 +72,12 @@ module Parsanol
         input = normalize_input(source)
 
         # Initial parse attempt (no error collection)
-        success, value = run_with_context(input, nil, must_consume_all)
+        success, value = run_with_context(input, nil, must_consume_all, **context_options)
         return finalize_result(value) if success
 
         # Reparse with error reporting for diagnostics
         report_detailed_error(input, must_consume_all, options[:reporter],
-                              value)
+                              value, **context_options)
       end
 
       # Creates a new parsing context and executes the atom.
@@ -76,10 +86,11 @@ module Parsanol
       # @param reporter [Object, nil] error reporter
       # @param consume_all [Boolean] require complete consumption
       # @return [Array(Boolean, Object)] outcome tuple
-      def run_with_context(input, reporter, consume_all)
+      def run_with_context(input, reporter, consume_all, compatibility: :strict)
         parser_class = detect_parser_class
         context = Parsanol::Atoms::Context.new(reporter,
-                                               parser_class: parser_class)
+                                               parser_class: parser_class,
+                                               compatibility: compatibility)
         apply(input, context, consume_all)
       end
 
@@ -242,10 +253,12 @@ module Parsanol
       # consumer's file:line:col degrades to "line 1 char 1" when the
       # interpreter raises the outermost sequence instead. Explicit
       # reporters (Tree for full cause trees) are honored unchanged.
-      def report_detailed_error(input, consume_all, reporter, _initial_error)
+      def report_detailed_error(input, consume_all, reporter, _initial_error, compatibility: :strict)
         input.bytepos = 0
-        error_reporter = reporter || Parsanol::ErrorReporter::Deepest.new
-        success, cause = run_with_context(input, error_reporter, consume_all)
+        error_reporter = reporter ||
+          (compatibility == :parslet ? Parsanol::ErrorReporter::Tree.new : Parsanol::ErrorReporter::Deepest.new)
+        context_options = compatibility == :strict ? {} : { compatibility: compatibility }
+        success, cause = run_with_context(input, error_reporter, consume_all, **context_options)
 
         # Second parse should also fail
         raise "Invariant violation: parse succeeded during error reporting" if success

data/lib/parsanol/atoms/context.rb

@@ -44,11 +44,24 @@ module Parsanol
       # @param interval_cache: [Boolean] enable GPeg-style interval caching
       # @param adaptive_cache_threshold: [Integer, nil] minimum input size for caching
       # @param parser_class: [Class, nil] parser class for threshold selection
+      # @param compatibility: [Symbol] :strict or opt-in :parslet. Legacy
+      #   decisions use eager, parse-lifetime memo entries; mutable capture
+      #   and dynamic evaluations still retain their cache barriers.
       #
       def initialize(error_reporter = Parsanol::ErrorReporter::Tree.new,
                      interval_cache: false,
                      adaptive_cache_threshold: nil,
-                     parser_class: nil)
+                     parser_class: nil,
+                     compatibility: :strict)
+        unless %i[strict parslet].include?(compatibility)
+          raise ArgumentError, "Unknown compatibility policy: #{compatibility}"
+        end
+
+        @parslet_compatibility = compatibility == :parslet
+        if @parslet_compatibility && interval_cache
+          raise NotImplementedError, "Parslet compatibility does not yet support interval caching"
+        end
+
         # Core memoization cache: position -> { atom_id -> [result, advance] }
         # Auto-vivifying sub-hashes: a probe-phase position can reach the
         # active-path lookup before any entry exists at that position
@@ -84,11 +97,6 @@ module Parsanol
         @array_pool = Parsanol::Pools::ArrayPool.new(size: 10_000, preallocate: false)
         @buffer_pool = Parsanol::Pools::BufferPool.new(pool_size: 100)
 
-        # Selective memoization tracking
-        @hit_stats = Hash.new(0)
-        @miss_stats = Hash.new(0)
-        @min_hits_for_cache = 2
-
         # Optional GPeg-style interval caching
         @use_intervals = interval_cache
         if @use_intervals
@@ -117,7 +125,7 @@ module Parsanol
 
         @adaptive_threshold = threshold
         @input_len = nil
-        @caching_active = false
+        @caching_active = @parslet_compatibility
         @backtrack_events = 0
 
         # Monotonic counter of cache-unsafe events (dynamic-atom evaluations
@@ -132,6 +140,10 @@ module Parsanol
       # @return [Integer] monotonic count of cache-unsafe events so far
       attr_reader :cache_unsafe_events
 
+      def parslet_compatible?
+        @parslet_compatibility
+      end
+
       # Records that mutable parse state was read or written (dynamic atom
       # evaluated, capture stored). Called by atoms; results computed across
       # such events are excluded from memoization.
@@ -152,7 +164,11 @@ module Parsanol
       #
       def try_with_cache(atom, src, must_consume_all)
         # Skip caching for atoms that don't benefit from it
-        return atom.try(src, self, must_consume_all) unless atom.cached?
+        legacy_pure = @parslet_compatibility &&
+          (atom.instance_of?(Parsanol::Atoms::Entity) ||
+           atom.instance_of?(Parsanol::Atoms::Str) || atom.instance_of?(Parsanol::Atoms::Re))
+        cacheable = atom.cached? || legacy_pure
+        return atom.try(src, self, must_consume_all) unless cacheable
 
         # Use interval-based caching if enabled
         return try_with_interval(atom, src, must_consume_all) if @use_intervals
@@ -171,7 +187,9 @@ module Parsanol
           @furthest_pos = pos
           @evict_counter += 1
 
-          if @evict_counter >= @evict_interval
+          # Legacy prefix decisions remain observable on later backtracking;
+          # retain them for this parse rather than silently re-evaluating.
+          if !@parslet_compatibility && @evict_counter >= @evict_interval
             @evict_counter = 0
             cutoff = pos - @evict_threshold
             @memo.delete_if { |p, _| p < cutoff }
@@ -182,26 +200,21 @@ module Parsanol
         # prefix-success fallback for ordered choice)
         cached_key = cached_entry_key(@memo[pos], atom, must_consume_all)
         if cached_key
-          @hit_stats[cached_key] += 1
           outcome, delta = @memo[pos][cached_key]
           src.bytepos = pos + delta
           return outcome
         end
 
         # Cache miss - execute and store
-        @miss_stats[key] += 1
         unsafe_before = @cache_unsafe_events
         outcome = atom.try(src, self, must_consume_all)
         delta = src.bytepos - pos
 
-        # Never store results spanning cache-unsafe events (dynamic
-        # blocks, capture writes); keep the beneficial-attempts
-        # heuristic to avoid one-shot memo pollution.
-        if storable_outcome?(key, outcome, unsafe_before)
-          attempts = @hit_stats[key] + @miss_stats[key]
-          if attempts <= @min_hits_for_cache || @hit_stats[key].positive?
-            (@memo[pos] ||= {})[key] = [outcome, delta]
-          end
+        # Once backtracking activates memoization, retain every safe answer.
+        # An atom-wide attempts limit suppresses its entries at later positions
+        # and can leave recursive alternatives with exponential repeated work.
+        if @cache_unsafe_events == unsafe_before
+          (@memo[pos] ||= {})[key] = [outcome, delta]
         end
 
         outcome
@@ -217,23 +230,21 @@ module Parsanol
       def try_with_interval(atom, src, must_consume_all)
         pos = src.bytepos
         key = scoped_cache_key(atom, must_consume_all)
-        cached_key, cached = cached_interval_entry(atom, pos,
-                                                   must_consume_all)
+        _cached_key, cached = cached_interval_entry(atom, pos,
+                                                    must_consume_all)
 
         if cached
-          @hit_stats[cached_key] += 1
           outcome, delta = cached
           src.bytepos = pos + delta
           return outcome
         end
 
-        @miss_stats[key] += 1
         unsafe_before = @cache_unsafe_events
         outcome = atom.try(src, self, must_consume_all)
         delta = src.bytepos - pos
         end_pos = pos + delta
 
-        if storable_outcome?(key, outcome, unsafe_before)
+        if @cache_unsafe_events == unsafe_before
           @interval_trees[key].insert(pos, end_pos, [outcome, delta])
         end
 
@@ -533,6 +544,8 @@ module Parsanol
       end
 
       def scoped_cache_key(atom, must_consume_all)
+        return shared_cache_key(atom) if @parslet_compatibility
+
         must_consume_all ? strict_cache_key(atom) : shared_cache_key(atom)
       end
 
@@ -554,17 +567,6 @@ module Parsanol
         !must_consume_all && share_prefix_success_cache?(atom)
       end
 
-      # An outcome may be memoized only when no cache-unsafe event (dynamic
-      # evaluation, capture write) happened while computing it, and the
-      # attempts heuristic deems the entry worthwhile.
-      def storable_outcome?(key, outcome, unsafe_before)
-        return false unless @cache_unsafe_events == unsafe_before
-
-        outcome.first ||
-          @hit_stats[key] + @miss_stats[key] <= @min_hits_for_cache ||
-          @hit_stats[key].positive?
-      end
-
       def successful_prefix_entry?(entry)
         entry && entry[0].is_a?(Array) && entry[0].first == true
       end

data/lib/parsanol/atoms/repetition.rb

@@ -74,6 +74,8 @@ module Parsanol
       # @param consume_all [Boolean] require full consumption
       # @return [Array(Boolean, Object)] result
       def try(source, context, consume_all)
+        return try_compatible(source, context, consume_all) if context.parslet_compatible?
+
         # Check for tree memoization support
         if context.use_tree_memoization?
           return with_tree_cache(source, context, consume_all)
@@ -119,6 +121,37 @@ module Parsanol
         first
       end
 
+      # Legacy repetition checks all children as prefixes. A bounded success
+      # returns before the outer consume-all guard; an exhausted optional
+      # failure checks consume-all inside #try. Their raw memo answers differ.
+      def try_compatible(source, context, consume_all)
+        start_pos = source.bytepos
+        result = [@result_tag]
+        count = 0
+        failure = nil
+        loop do
+          previous = source.bytepos
+          success, value = @parslet.apply(source, context, false)
+          unless success
+            failure = value
+            source.bytepos = previous
+            break
+          end
+
+          count += 1
+          result << value
+          return ok(result) if @max && count >= @max
+          # Retain the current engine's protection against empty loops.
+          break if source.bytepos == previous
+        end
+        return context.err_at(self, source, min_error, start_pos, [failure]) if count < @min
+        if consume_all && source.chars_left.positive?
+          return context.err(self, source, @extra_error, [failure])
+        end
+
+        ok(result)
+      end
+
       # Optional match (0 or 1)
       def try_maybe(source, context, _consume_all)
         success, value = @parslet.apply(source, context, false)

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 35442920 bytes
-sha256: 0a129844ae8acce2330a6b009be2fc9d918a6f46d53f744429ae02b9bf039aea
+size: 35690876 bytes
+sha256: d0d818ff4c6c0f68706b94d0bcee7bb2dca07ce492439b729bf42fbc83e50cc9

data/lib/parsanol/native/parser.rb

@@ -57,9 +57,9 @@ module Parsanol
         #
         # @param grammar [Parsanol::Atoms::Base] Ruby grammar or JSON string
         # @param input [String] Input string to parse
-        def parse(grammar, input)
+        def parse(grammar, input, **)
           # Delegate to Parsanol::Native.parse for consistency
-          Parsanol::Native.parse(grammar, input)
+          Parsanol::Native.parse(grammar, input, **)
         end
 
         # Parse input with a Ruby grammar, returning the parslet-shaped
@@ -84,8 +84,13 @@ module Parsanol
         # Resolve a Rust-side handle for the grammar, registering it once.
         # Per-call cost is the memoized structure-hash lookup plus one Hash
         # access — no JSON marshal, no re-hash inside Rust.
-        def grammar_handle(root_atom)
-          cache_key = grammar_cache_key(root_atom)
+        def grammar_handle(root_atom, compatibility: :strict)
+          root_atom = root_atom.root if root_atom.is_a?(::Parsanol::Parser)
+          legacy = compatibility == :parslet
+          # Legacy decisions depend on the exact shared-node graph. The
+          # strict structure hash deliberately omits repeated-node targets.
+          # Retaining the root in this bounded key also prevents id recycling.
+          cache_key = legacy ? [:parslet, root_atom] : grammar_cache_key(root_atom)
           handle = HANDLE_CACHE[cache_key]
           if handle
             # Refresh recency: reinsertion moves the entry to the end,
@@ -94,7 +99,8 @@ module Parsanol
             return handle
           end
 
-          handle = Native._register_grammar(grammar_json(root_atom))
+          json = legacy ? GrammarSerializer.serialize(root_atom) : grammar_json(root_atom)
+          handle = Native._register_grammar(json)
           HANDLE_CACHE[cache_key] = handle
           trim_caches
           handle

data/lib/parsanol/native.rb

@@ -58,9 +58,24 @@ module Parsanol
       #   result = Parsanol::Native.parse(str('hello').as(:greeting), "hello\nworld")
       #   result[:greeting].line_and_column  # => [1, 1]
       #
-      def parse(grammar, input)
+      def parse(grammar, input, compatibility: :strict)
+        unless %i[strict parslet].include?(compatibility)
+          raise ArgumentError, "Unknown compatibility policy: #{compatibility}"
+        end
         raise LoadError, "Native parser not available" unless available?
 
+        if compatibility == :parslet
+          unless Parser.extension_loaded? && respond_to?(:_parse_handle_with_compatibility)
+            raise NotImplementedError,
+                  "Native Parslet compatibility requires an extension with _parse_handle_with_compatibility"
+          end
+          if grammar.is_a?(String)
+            raise NotImplementedError, "Native Parslet compatibility requires grammar atoms, not JSON"
+          end
+
+          return parse_compatible_atom_grammar(grammar, input)
+        end
+
         # ffi-gem tier (JRuby/TruffleRuby/no-binary MRI): same contract,
         # batch-decoded results, single reporter-pass error fallback.
         return Ffi.parse(grammar, input) unless Parser.extension_loaded?
@@ -366,6 +381,35 @@ module Parsanol
         end
       end
 
+      # Compatibility failures are authoritative native refusals. Unlike the
+      # legacy strict helper, this path never reparses or accepts in Ruby.
+      def parse_compatible_atom_grammar(grammar, input)
+        handle = Parser.grammar_handle(grammar, compatibility: :parslet)
+        raw = begin
+          _parse_handle_with_compatibility(handle, input, "parslet")
+        rescue ArgumentError
+          Parser.invalidate_handle(handle)
+          begin
+            _parse_handle_with_compatibility(
+              Parser.grammar_handle(grammar, compatibility: :parslet), input, "parslet"
+            )
+          rescue RuntimeError => e
+            raise_compatible_parse_error(e, input)
+          end
+        rescue RuntimeError => e
+          raise_compatible_parse_error(e, input)
+        end
+        BatchDecoder.decode_and_flatten(raw, input, Parsanol::Slice)
+      end
+
+      def raise_compatible_parse_error(error, input)
+        message = error.message
+        position = message[NATIVE_POS_MARKER, 1].to_i
+        cause = Parsanol::Cause.new(message.sub(NATIVE_POS_MARKER, ""),
+                                    Parsanol::Source.new(input), position)
+        raise Parsanol::ParseFailed.new(cause.to_s, cause), cause: nil
+      end
+
       # Reference-walker path (TODO.sota/8 B1): the plain recursive
       # relation — no VM, no memo tables, no fused scans, no terminal
       # fast paths. Deliberately slow; the cross-engine differential

data/lib/parsanol/parg/frontend.rb

@@ -20,9 +20,24 @@ module Parsanol
       ENTRY_LINE = /\Aentry\s+(\w+)\s*:\s*(\w+)/
       USE_LINE = /\Ause\s+(\w+)/
       GRAMMAR_LINE = /\Agrammar\s+(\w+)\s+version\s+"([^"]+)"/
+      # The capture-edition tail: the canonical numeric spelling or the
+      # quoted aliases (ruby#361); `mode` stays the deprecated keyword.
+      EDITION_TAIL = /
+        \s+(?:edition\s+(?:"(?<quoted>[^"]+)"|(?<number>\d+))|mode\s+"(?<mode>[^"]+)")
+      /x
+      GLUE_LINE = /\Aglue\s+([a-z_][a-z0-9_]*(?:\s+[a-z_][a-z0-9_]*)*)\s*\z/
 
       module_function
 
+      # Brace depth for the line-oriented collection: braces inside
+      # string literals are grammar data — test pins quote whole
+      # language forms, including deliberately malformed ones whose
+      # unbalanced braces would push the section depth off (ruby#369).
+      def brace_delta(line)
+        bare = line.gsub(/"(?:[^"\\]|\\.)*"/, "")
+        bare.scan("{").count - bare.scan("}").count
+      end
+
       def parse(source)
         SelfHost.validate(source) unless SelfHost.available? && !SelfHost.valid?(source)
 
@@ -43,7 +58,17 @@ module Parsanol
           end
           next if stripped.empty? || stripped.start_with?("#")
 
-          if state[:section]
+          if state[:rule_depth]&.positive?
+            # A brace-form rule body spans lines (ruby#311): keep
+            # appending until its braces balance.
+            state[:rule_lines][state[:rule_depth_name]] << line
+            state[:rule_depth] += brace_delta(line)
+            if state[:rule_depth].zero?
+              merge_rule(document, state[:rule_lines][state[:rule_depth_name]])
+              state[:rule_depth] = nil
+              state[:rule_depth_name] = nil
+            end
+          elsif state[:section]
             advance_section(document, state, line, deferred, preprocess_texts)
           else
             route_top_level(document, stripped, line, state,
@@ -59,7 +84,7 @@ module Parsanol
       # Consumes one line inside a deferred/closed-by-brace section.
       def advance_section(document, state, line, deferred, preprocess_texts)
         section = state[:section]
-        state[:depth] += line.scan("{").count - line.scan("}").count
+        state[:depth] += brace_delta(line)
         if state[:depth].positive?
           preprocess_texts.last << line if section == "preprocess"
           state[:section_lines] << line
@@ -91,9 +116,19 @@ module Parsanol
         when USE_LINE
           document.uses << Regexp.last_match(1)
           doc_comments = []
+        when GLUE_LINE
+          document.glue_rules.concat(Regexp.last_match(1).split)
+          doc_comments = []
         when GRAMMAR_LINE
           document.grammar_name = Regexp.last_match(1)
           document.version = Regexp.last_match(2)
+          tail = stripped.match(EDITION_TAIL)
+          document.edition = if tail.nil?
+                               "v1"
+                             else
+                               level = tail[:number] || tail[:quoted] || tail[:mode]
+                               ["2", "v2"].include?(level) ? "v2" : "v1"
+                             end
           doc_comments = []
         when NAMED_SECTION
           state[:section] = Regexp.last_match(1)
@@ -128,7 +163,15 @@ module Parsanol
           document.docs[rule_name] = doc_comments.join("\n") unless doc_comments.empty?
           doc_comments = []
           state[:rule_lines][rule_name] = line
-          merge_rule(document, line)
+          depth = brace_delta(line)
+          if depth.positive?
+            # Brace-form body opens (ruby#311): the rule completes on a
+            # later line; the continuation loop appends and merges then.
+            state[:rule_depth] = depth
+            state[:rule_depth_name] = rule_name
+          else
+            merge_rule(document, line)
+          end
         else
           doc_comments = []
         end

data/lib/parsanol/parser.rb

@@ -176,6 +176,9 @@ module Parsanol
     # Options:
     # - :reporter - Custom error reporter instance
     # - :prefix - Allow partial matching (default: false)
+    # - :compatibility - :strict (default), or :parslet for legacy memo
+    #   decisions. Auto mode selects native when available; an older native
+    #   extension without the compatibility entrypoint raises unsupported.
     #
     # @return [Hash, Array, Parsanol::Slice] parsed result with position info
     # @raise [Parsanol::ParseFailed] when parsing fails
@@ -200,8 +203,22 @@ module Parsanol
       # parse(input, {mode: :ruby, ...}) is the same call shape a subclass
       # forwarding options via super produces; :mode must be honored
       # wherever it appears, or those callers silently get the native path.
-      mode = opts.delete(:mode) ||
-        (Parsanol::Native.available? && native_expressible? ? :native : :ruby)
+      compatibility = opts.fetch(:compatibility, :strict)
+      unless %i[strict parslet].include?(compatibility)
+        raise ArgumentError, "Unknown compatibility policy: #{compatibility}"
+      end
+
+      requested_mode = opts.delete(:mode)
+      mode = requested_mode ||
+        if compatibility == :parslet
+          Parsanol::Native.available? ? :native : :ruby
+        else
+          Parsanol::Native.available? && native_expressible? ? :native : :ruby
+        end
+      if compatibility == :parslet && mode == :json
+        raise NotImplementedError, "Parslet compatibility does not yet support JSON mode"
+      end
+
       case mode
       when :ruby
         super(input, opts)
@@ -291,6 +308,14 @@ module Parsanol
     # @return [Object] parse result with Slice objects for position info
     #
     def parse_native(input, opts)
+      if opts[:compatibility] == :parslet
+        if opts[:prefix]
+          raise NotImplementedError, "Native Parslet compatibility does not yet support prefix mode"
+        end
+
+        return Parsanol::Native.parse(root, input, compatibility: :parslet)
+      end
+
       unless Parsanol::Native.available?
         Parsanol::Atoms::Base.instance_method(:parse).bind_call(self, input,
                                                                 opts)

data/lib/parsanol/version.rb

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

data/lib/parsanol/vm.rb

@@ -452,6 +452,11 @@ module Parsanol
         @subs = {}      # [obj_id, flag] => pc or :pending
         @pending = {}   # [obj_id, flag] => [[call_idx, body], ...]
         @backtracking_prone = false
+        # Grammar rules form a shared graph. Re-analyzing every reference
+        # repeats whole alternative trees during inlining. These caches
+        # live only for this compiler and retain the depth limit's meaning.
+        @first_byte_tables = {}.compare_by_identity
+        @nullability = {}.compare_by_identity
       end
 
       attr_reader :ops, :backtracking_prone
@@ -484,6 +489,13 @@ module Parsanol
       def first_byte_table(atom, depth = 0)
         return nil if depth > 10
 
+        cached = (@first_byte_tables[atom] ||= {})
+        return cached[depth] if cached.key?(depth)
+
+        cached[depth] = compute_first_byte_table(atom, depth)&.freeze
+      end
+
+      def compute_first_byte_table(atom, depth)
         case atom
         when Parsanol::Atoms::Str
           b = atom.str.getbyte(0)
@@ -508,7 +520,7 @@ module Parsanol
                 i += 1
               end
             else
-              t = ct
+              t = ct.dup
             end
             unless nullable?(child, depth + 1)
               nullable_all = false
@@ -529,7 +541,7 @@ module Parsanol
                 i += 1
               end
             else
-              t = bt
+              t = bt.dup
             end
           end
           t
@@ -572,6 +584,13 @@ module Parsanol
       def nullable?(atom, depth = 0)
         return false if depth > 10
 
+        cached = (@nullability[atom] ||= {})
+        return cached[depth] if cached.key?(depth)
+
+        cached[depth] = compute_nullable(atom, depth)
+      end
+
+      def compute_nullable(atom, depth)
         case atom
         when Parsanol::Atoms::Str then atom.str.bytesize.zero?
         when Parsanol::Atoms::Re then false

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.114
+  version: 1.3.116
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-29 00:00:00.000000000 Z
+date: 2026-10-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