parsanol 1.3.79-arm-linux → 1.3.81-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b400959abdd0fff2f2a6841f35db7ead79f1853c565f7d8def56191c0864697
-  data.tar.gz: 469053fa95da3561c14e8cfb278ff134461edf599efd837d628aee316281ea4a
+  metadata.gz: 01fb11b456bec79f8f4bd6b6db018ef771260440414f75ef02f4e1520ec2caf2
+  data.tar.gz: 75e011ecd46597e4c008cbb3fd2c7e3d2bda46ba4cd716c1613a351a28d99fb8
 SHA512:
-  metadata.gz: f48f171c91d3b4f12d5f508d9e02dedef27066620052770ab82b023ba9ee43317e8f0c6aa36c516cc8e0238f28c5e32e1c68a95d56560a03cd3c126ff4d1fab2
-  data.tar.gz: e59521ee0b495463a04728d26271193fb9a11ca769d794ad380256016786afcfefcebe878277222881fd8a6b676583c2116dde29f3e8e4b10ab09270d395387b
+  metadata.gz: 602203c6a4b11eef7c4af0613212091742b1c2f4d9a0250ee27dc7e6d67a891a77c318a70feb7f38b168d64dfd6843ace2123687cc8a17713b0dd9fcb8c8bc43
+  data.tar.gz: 49afc1a994a7aeb1b3231446890bc729da4c6a76f520fa448c872437f45861fb4e912a1dfbf8476e13c37e4723dc21b3675e1e4dc8156851d645905006e0c1dd

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: 33857428 bytes
-sha256: 555fffa50043f91efe6d1003cf97ba60224c83b0118205bff2033615de4bf54d
+size: 33956544 bytes
+sha256: 5f8d55c4f6ab0f5bba8ea501b6ab13b16df2bfa1b63b823152d70bb86b95daaf

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: 34042676 bytes
-sha256: 63a27cccdad9628f8dba74a5efdf1d6993ad7b5ad69a434746608ca1df28dd9c
+size: 34141808 bytes
+sha256: c9ec101532d77f531c2b73fd93c48add52fcd2fc0a06e4047b9e1deb9dc5c4d6

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: 34036828 bytes
-sha256: a7917405bf0af8cbff7095c8391970d47165543ec62fcc25518a3bd017e03397
+size: 34135964 bytes
+sha256: 42f14ef394d8a41ed832e9a9f61fbc0868056062d94df7ea62403290c5581c31

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: 34046564 bytes
-sha256: 3eb609a621681ded3508cdbb5fe6fb0ebea27419febfb58243b56625d041db51
+size: 34145720 bytes
+sha256: 953c7f621b8c343ab150a9dada110ad29b94d571cc621d0be94c8235419bd2b1

data/lib/parsanol/native/parser.rb

@@ -205,6 +205,19 @@ module Parsanol
             [:constant, atom.value.inspect]
           when ::Parsanol::Atoms::Lookbehind
             [:lookbehind, atom.count, atom.pattern, atom.positive]
+          # Subclass first: TriviaCapture < Trivia < Ignored (the same
+          # dispatch discipline as the serializer's).
+          when ::Parsanol::Atoms::TriviaCapture
+            # The capturer table differentiates capture-carrying
+            # grammars from plain-trivia ones — without it the grammar
+            # cache serves one variant's wire to every other and the
+            # wrong marker table reaches the engine (parsanol-ruby#180).
+            [:trivia_capture, atom.capturers.to_a.sort,
+             atom_structure(atom.wrapped_atom, visited)]
+          when ::Parsanol::Atoms::Trivia
+            [:trivia, atom_structure(atom.wrapped_atom, visited)]
+          when ::Parsanol::Atoms::Ignored
+            [:ignored, atom_structure(atom.wrapped_atom, visited)]
           else
             [:unknown, atom.class.name]
           end

data/lib/parsanol/parg/artifact.rb

@@ -65,24 +65,26 @@ module Parsanol
       def parse(entry_name, input, mode: :native)
         case mode
         when :native
-          if Native.available? && !envelope["dynamic"]
-            # Fast lane (parsanol-ruby#162): the per-instance atom
-            # tree rides the DSL serialization/registration caches
+          if Native.available?
+            # Fast lane (parsanol-ruby#162): Native.parse with the
+            # per-instance root atom registers the grammar once
             # (GRAMMAR_CACHE / HANDLE_CACHE keyed on the stable root
-            # atom), so an artifact parses at compiled speed after
-            # the first call. The old path re-serialized the whole
-            # grammar JSON and re-registered it per parse (~8x).
-            # Dynamic artifacts carry ruby-tier atoms their wire
-            # cannot express — they keep the interpreter.
-            begin
-              return root_atom(entry_name).parse(input, mode: :native)
-            rescue Parsanol::ParseFailed
-              # The atom-tree native path reports the root position; the
-              # wire-registration path carries the deepest-failure
-              # diagnostics (parsanol-ruby#171). Failures pay the
-              # serialization once; successes keep the fast lane.
-              return Native.parse(JSON.generate(entry(entry_name).fetch("grammar")), input)
-            end
+            # atom) and every parse after the first runs the native
+            # engine by handle — the same path a DSL parser's
+            # mode: :native takes. Atoms::Base#parse must NOT carry
+            # this lane: it ignores :mode, so it would silently run
+            # the pure-Ruby VM and its interpreter fallback (the
+            # 5-7x real-document gap in #162, and the root-position
+            # diagnostics in #171 before the wire fallback).
+            #
+            # Dynamic-flagged artifacts parse natively too (rs#204):
+            # the state atoms (StateSet/StateMatch/StateSwitch)
+            # evaluate in the engine, riding the capture store's
+            # rollback discipline. Reaching a CustomRef aborts the
+            # native pass outright — Native.parse's error path then
+            # re-runs the interpreter, so customs stay Ruby-tier with
+            # identical trees.
+            return Native.parse(root_atom(entry_name), input)
           end
 
           root_atom(entry_name).parse(input)

data/lib/parsanol/parser.rb

@@ -52,7 +52,12 @@ module Parsanol
         define_method(:root) do
           atom = __send__(rule_name)
           skip_name = self.class.skip_rule_name
-          skip_name ? Parsanol::Skip.inject(self, atom, skip_name)[0] : atom
+          if skip_name
+            Parsanol::Skip.inject(self, atom, skip_name,
+                                  captures: self.class.skip_captures)[0]
+          else
+            atom
+          end
         end
       end
 
@@ -63,6 +68,13 @@ module Parsanol
       # everything it references) builds without injection; it must be
       # non-nullable. Order-independent with +root+.
       #
+      # +capture:+ (parsanol-ruby#180) declares trivia capturers — a
+      # map of rule name to kind label. Units of the skip rule
+      # matching a capturer's leading literal attach to the next
+      # Named capture under +comments:+ (the PARG
+      # `skip = trivia capture: comments` shape) instead of being
+      # discarded; whitespace-shaped units never record.
+      #
       # @example
       #   class MyParser < Parsanol::Parser
       #     rule(:spaces) { match(/[ \t]/).repeat(1) }
@@ -72,8 +84,14 @@ module Parsanol
       #     root :doc
       #   end
       #
-      def skip(rule_name)
+      # @example capturing comments
+      #   rule(:trivia) { spaces | line_comment }
+      #   rule(:line_comment) { str("//") >> match(/[^\n]/).repeat }
+      #   skip :trivia, capture: { line_comment: :line_comment }
+      #
+      def skip(rule_name, capture: nil)
         @skip_rule_name = rule_name
+        @skip_captures = capture
         nil
       end
 
@@ -82,6 +100,12 @@ module Parsanol
       def skip_rule_name
         @skip_rule_name
       end
+
+      # The declared capturer map ({rule => kind label}), or nil —
+      # see {.skip}.
+      def skip_captures
+        @skip_captures
+      end
     end
 
     # Delegates matching to the root rule.

data/lib/parsanol/skip.rb

@@ -13,7 +13,14 @@ module Parsanol
     # methods. Returns [injected_root, skip_atom] with the wrapper
     # built and the lint applied, or raises GrammarError for a
     # nullable skip.
-    def self.inject(parser_instance, root_atom, skip_rule_name)
+    #
+    # +captures+ (parsanol-ruby#180) maps capturer rule names to kind
+    # labels (`skip :trivia, capture: { line_comment: :line }`); the
+    # injected wrapper becomes a TriviaCapture whose units matching a
+    # capturer's leading literal attach to the next Named capture
+    # under `comments:` — the PARG `skip = trivia capture: comments`
+    # shape. Whitespace-shaped units never record.
+    def self.inject(parser_instance, root_atom, skip_rule_name, captures: nil)
       skip_atom = parser_instance.__send__(skip_rule_name)
       skip_atom = skip_atom.parslet while skip_atom.is_a?(Atoms::Entity)
 
@@ -23,10 +30,62 @@ module Parsanol
               "empty loops forever at injection points"
       end
 
-      injector = Injector.new(skip_atom)
+      markers = capturer_markers(parser_instance, captures)
+      injector = Injector.new(skip_atom, markers)
       [injector.inject(root_atom, entry: true), skip_atom]
     end
 
+    # Derives each capturer's leading literal (the leftmost Str the
+    # rule can start with) and keys the marker table by it — the same
+    # derivation the PARG compiler applies to its skip declaration. A
+    # declared capturer without a derivable, non-blank literal is a
+    # declaration error: its units could never be told apart from
+    # whitespace-shaped trivia and it would silently record nothing.
+    def self.capturer_markers(parser_instance, captures)
+      return nil if captures.nil? || captures.empty?
+
+      captures.each_with_object({}) do |(rule_name, kind), markers|
+        atom = parser_instance.__send__(rule_name)
+        atom = atom.parslet while atom.is_a?(Atoms::Entity)
+        literal = leading_literal(atom)
+        if literal.nil? || literal.strip.empty?
+          raise GrammarError,
+                "skip capturer #{rule_name.inspect} has no leading " \
+                "literal: its units cannot be told apart from " \
+                "whitespace-shaped trivia"
+        end
+        markers[literal] = kind || rule_name
+      end
+    end
+
+    # The leftmost literal the atom can start with, or nil when the
+    # shape is not literal-led (alternatives with disagreeing
+    # branches, regexes, lookaheads).
+    def self.leading_literal(atom)
+      case atom
+      when Atoms::Str then atom.str
+      when Atoms::Sequence
+        atom.parslets.each do |child|
+          literal = leading_literal(child)
+          return literal if literal
+        end
+        nil
+      when Atoms::Alternative
+        first = nil
+        atom.alternatives.each do |branch|
+          literal = leading_literal(branch)
+          return nil if literal.nil? || (first && literal != first)
+
+          first ||= literal
+        end
+        first
+      when Atoms::Repetition
+        atom.min&.positive? ? leading_literal(atom.parslet) : nil
+      when Atoms::Named, Atoms::Capture, Atoms::Ignored, Atoms::Trivia
+        leading_literal(atom.parslet)
+      end
+    end
+
     # The injection walk. Mirrors the PARG compiler's semantics:
     # sequences interleave the wrapper before every child, alternatives
     # and repetitions descend, named captures descend (spans stay
@@ -34,8 +93,9 @@ module Parsanol
     # transparency), bare terminals gain a leading wrapper, and the
     # entry root takes leading and trailing wrappers.
     class Injector
-      def initialize(skip_atom)
+      def initialize(skip_atom, markers = nil)
         @skip_atom = skip_atom
+        @markers = markers
         @wrapper_ids = {}.compare_by_identity
       end
 
@@ -50,7 +110,13 @@ module Parsanol
 
       def maybe
         @maybe ||= begin
-          wrapper = Atoms::Trivia.new(Atoms::Repetition.new(@skip_atom, 0, 1))
+          inner = Atoms::Repetition.new(@skip_atom, 0, 1)
+          wrapper =
+            if @markers
+              Atoms::TriviaCapture.new(inner, @markers)
+            else
+              Atoms::Trivia.new(inner)
+            end
           @wrapper_ids[wrapper] = true
           wrapper
         end

data/lib/parsanol/version.rb

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

data/lib/parsanol/vm.rb

@@ -125,11 +125,37 @@ module Parsanol
         return nil if cached.equal?(:fallback)
         return cached if key?(cache, root)
 
+        # Structure-hash probe (rs#166): a fresh parser instance (or a
+        # rule called on one) misses the identity key above and would
+        # silently recompile the ENTIRE grammar per call — the fresh-
+        # parser recompile trap (25x table transforms in coradoc,
+        # metanorma/coradoc#265). The structure hash — the same key
+        # the native grammar cache uses — lets equivalent grammars
+        # share the compiled program; identity stays as the fast
+        # first level.
+        hashed = (@programs_by_hash ||= {})
+        hash_key = begin
+          Parsanol::Native::Parser.public_structure_hash(root)
+        rescue NotImplementedError
+          # A grammar with an unimplemented lazy rule (entities resolve
+          # eagerly for hashing) has no stable structure yet; the
+          # identity cache above still serves it.
+          nil
+        end
+        if hash_key && (shared = hashed[hash_key]).is_a?(Array)
+          # The shared program's compile-time analysis (heavy-memo
+          # seeding) covered this structure; the fresh root inherits
+          # it so its first parse memoizes like the original's.
+          (@heavy ||= {}.compare_by_identity)[root] = true if @heavy_by_hash&.[](hash_key)
+          return shared
+        end
+
         # A grammar the compiler cannot compile — e.g. one containing a
         # lazily resolved Entity that a select-first literal index would
         # never select — falls back to the interpreter, the source of
         # truth. The interpreter resolves such entities lazily, so an
         # unselected branch simply never raises.
+        @last_compile_prone = nil
         program =
           begin
             compile(atom)
@@ -137,6 +163,19 @@ module Parsanol
             :fallback
           end
         cache[root] = program
+        # Only real programs share. A symbol verdict (:fallback /
+        # :oversize) is a property of this particular compile
+        # attempt's path, not of the structure: serving it to a later
+        # grammar with the same structure would silently send a
+        # compile-capable grammar to the interpreter, unseeded — the
+        # order-dependent vm_fail_dispatch failure. Verdicts stay
+        # identity-local; a fresh root recompiles and re-derives
+        # both the verdict and the heavy-memo seed naturally.
+        if hash_key && program.is_a?(Array)
+          hashed[hash_key] = program
+          (@heavy_by_hash ||= {})[hash_key] = @last_compile_prone
+          trim_hashed_cache(hashed)
+        end
         trim_cache(cache)
         # :fallback = VM-incompatible; :oversize even non-inlined means
         # the grammar is beyond the program cap — the interpreter
@@ -157,7 +196,9 @@ module Parsanol
 
       def clear_program_cache
         @programs&.clear
+        @programs_by_hash&.clear
         @heavy&.clear
+        @heavy_by_hash&.clear
       end
 
       # FIFO eviction past the cache limit.
@@ -166,6 +207,11 @@ module Parsanol
         nil
       end
 
+      def trim_hashed_cache(hashed)
+        hashed.shift while hashed.size > PROGRAM_CACHE_LIMIT
+        nil
+      end
+
       # Compiles the grammar rooted at +atom+. Returns the flat program
       # Array, or nil when the grammar uses unsupported atoms.
       def compile(atom)
@@ -205,8 +251,12 @@ module Parsanol
         # rs#166: proneness rides the structure-hash share as a bool —
         # a later identical-structure grammar inherits the seed instead
         # of running its cold start unmemoized because compilation was
-        # skipped entirely.
-        if compiler.backtracking_prone
+        # skipped entirely. Recorded on the VM singleton so the share
+        # store can read it after this compile; program_for resets it
+        # first, so a raised NotImplementedError cannot smear the
+        # previous grammar's proneness onto this one.
+        @last_compile_prone = compiler.backtracking_prone
+        if @last_compile_prone
           (@heavy ||= {}.compare_by_identity)[root] = true
           trim_cache(@heavy)
         end

metadata

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