parsanol 1.3.105-arm-linux → 1.3.107-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b2a5b84cfa562c1535e789fbb1b255eacbed37ba883009bebc3cdcdd6ee5bf1
-  data.tar.gz: cff2ac2a93078d48366061fc0e929ce7a959db8ee5200f6202b8ee56bd33ab1e
+  metadata.gz: 82264b2e58bdcd642b09e1b7d39e5848685758e4be7b5d04c3d1ccbf8891e1f0
+  data.tar.gz: 4abb4bd1c4195f5efb724a23f14be6e24451c284f25748eec7e914129280d4a8
 SHA512:
-  metadata.gz: 46131326bda0bcc9f9304c88dcf935b67675f9d18aea638bff38334b9f245fba87aad2b7a6433df41349af6dec63dae68e9c33c2b7d287748cc783b26bdc3a9b
-  data.tar.gz: c75b6c38c1f04df3e9de16313c4bf5bbecd57c2490a57c20704b6144b593e884613f1353ae8317975e381119542f831bf6161d82fd53f54edd802b2d96cc50e2
+  metadata.gz: 31541ed28f1e205cb5abcbb0d90f59dbd18ebc9734026f458a2458d8c1cdf97b6a17686c7dc1c9bf6f3fccc5342dde8d078561d403f32dadae225b11edef0171
+  data.tar.gz: 499beed8e7e159aaf36223cc318f4fea3f40f69456b3fb48c5ce1278bd592cf323470905d165dfb22777ca5e607cb96a17de16c039b56395185a42dfac8a1a08

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: 34428344 bytes
-sha256: 82db84475e85ac3ef05019f2004550c38f91468e1354b9f951163d4b5c5d44e5
+size: 34490424 bytes
+sha256: a3cdb4f287af7a777278dc7ef4db062d9c3aa6b30e6667ffb26542d25215dec2

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: 34613524 bytes
-sha256: 1928bf70d15ea9f75289d47f0063597d0d2d529a46736cdf38950615b0a8fb7a
+size: 34675616 bytes
+sha256: 8ccc77dbd45591ffcd1cceabed8a2324593f3cdfbdd3acc463fbec81702381a8

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: 34607716 bytes
-sha256: 204869abbb95705c268e17b3fb9ec5f2f7cf25760d198c592ab122161bab66c3
+size: 34669796 bytes
+sha256: 5b8b78e7c01dca71d2abe00446475964e6bf894dacc0aadb427910ab80eebf38

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: 34617472 bytes
-sha256: 3ea07ee24359603075cd6150c5aa50850349aa5e7bb327bc164dd14ef04e441e
+size: 34679512 bytes
+sha256: 05dea26c9937b15e9f7f9ad8800d4cb29fc365a056640cecea6ac992d03092a3

data/lib/parsanol/native.rb

@@ -29,6 +29,16 @@ module Parsanol
         Parser.available?
       end
 
+      # Whether the reference walker is available (TODO.sota/8 B1): the
+      # `_parse_handle_reference` export ships with parsanol >= 0.18.18.
+      # Probed rather than assumed so a checkout whose extension predates
+      # the export can report the missing fifth fuzz path instead of
+      # raising NoMethodError mid-run.
+      def reference_available?
+        available? && Parser.extension_loaded? &&
+          respond_to?(:_parse_handle_reference)
+      end
+
       # Parse input with a Ruby grammar, returning clean AST with lazy line/column.
       #
       # Uses batch FFI format for maximum performance (3-5x faster than object-by-object).
@@ -355,6 +365,40 @@ module Parsanol
           raise_native_parse_error(e, grammar, input)
         end
       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
+      # fuzz runs it as an independent path, so a native failure here is
+      # a real disagreement and must not be rescued into a different
+      # engine's answer.
+      def parse_reference(grammar, input)
+        unless reference_available?
+          raise NotImplementedError,
+                "reference mode requires the native extension with " \
+                "parsanol >= 0.18.18"
+        end
+
+        handle = Parser.grammar_handle(grammar)
+
+        begin
+          BatchDecoder.decode_and_flatten(_parse_handle_reference(handle, input),
+                                          input, Parsanol::Slice)
+        rescue ArgumentError
+          # Handle dropped Rust-side (e.g. cache cleared): re-register once.
+          Parser.invalidate_handle(handle)
+          begin
+            BatchDecoder.decode_and_flatten(
+              _parse_handle_reference(Parser.grammar_handle(grammar), input),
+              input, Parsanol::Slice
+            )
+          rescue RuntimeError => e
+            raise_native_parse_error(e, grammar, input)
+          end
+        rescue RuntimeError => e
+          raise_native_parse_error(e, grammar, input)
+        end
+      end
     end
   end
 end

data/lib/parsanol/parg/artifact.rb

@@ -108,13 +108,24 @@ module Parsanol
           end
 
           root_atom(entry_name).parse(input)
+        when :reference
+          # The plain recursive relation (TODO.sota/8 B1): same shaping
+          # pipeline, no VM, no memo tables, no fused scans. Never falls
+          # back to :ruby — a reference result produced by another
+          # engine would defeat the differential. Deliberately slow.
+          unless Native.reference_available?
+            raise NotImplementedError, "reference mode requires the native " \
+                                       "extension with parsanol >= 0.18.18"
+          end
+
+          Native.parse_reference(root_atom(entry_name), input)
         when :ruby
           # Deepest-failure reporting parity with the native engine: the
           # default Tree reporter keeps the most recent (root) failure,
           # which reports position 1:1 for grammars with entry wrappers.
           root_atom(entry_name).parse(input, reporter: ErrorReporter::Deepest.new)
         else
-          raise ArgumentError, "unknown mode #{mode.inspect} (use :native or :ruby)"
+          raise ArgumentError, "unknown mode #{mode.inspect} (use :native, :reference or :ruby)"
         end
       end
 
@@ -250,44 +261,82 @@ module Parsanol
         return [[], []] unless body_rule
 
         body_atom = compiler.atom_for(body_rule)
+        # R2 declared form: the baked resync pattern owns the skip
+        # spans (author-deterministic — no trial scanning). Falls back
+        # to the inferred trial scan when the rule declares none.
+        pattern_atom = compiler.resync_atom_for(body_rule) ||
+          compiler.resync_atom_for(entry(entry_name)["root"])
         max = input.length
         resyncs = []
         items = []
         rounds = 0
         while rounds < 8
-          found = nil
-          scan = cursor
-          while scan < max
-            attempt = try_iteration(body_atom, input, scan)
-            if attempt && attempt[1] > scan
-              found = [scan, attempt[1], attempt[0]]
-              break
+          attempt = try_iteration(body_atom, input, cursor)
+          if attempt
+            items << root_atom(entry_name).flatten(attempt[0])
+            cursor = attempt[1]
+            until cursor >= max
+              attempt = try_iteration(body_atom, input, cursor)
+              break unless attempt
+
+              items << root_atom(entry_name).flatten(attempt[0])
+              cursor = attempt[1]
+            end
+            break if cursor >= max
+          end
+          if pattern_atom
+            # Declared: the pattern match (gap + delimiter) is the
+            # annotated error span.
+            span = scan_pattern(pattern_atom, input, cursor)
+            break unless span
+
+            resume = span[1]
+            resyncs << {
+              "offset" => cursor,
+              "skipped" => input[cursor...resume],
+              "resumed_at" => resume,
+            }
+          else
+            # Inferred: scan for the next viable iteration start.
+            found = nil
+            scan = cursor
+            while scan < max
+              attempt = try_iteration(body_atom, input, scan)
+              if attempt && attempt[1] > scan
+                found = [scan, attempt[1], attempt[0]]
+                break
+              end
+              scan += 1
             end
-            scan += 1
+            break unless found
+
+            skip_start, resume, value = found
+            resyncs << {
+              "offset" => cursor,
+              "skipped" => input[cursor...skip_start],
+              "resumed_at" => skip_start,
+            }
+            items << root_atom(entry_name).flatten(value)
           end
-          break unless found
-
-          skip_start, resume, value = found
-          resyncs << {
-            "offset" => cursor,
-            "skipped" => input[cursor...skip_start],
-            "resumed_at" => skip_start,
-          }
-          items << root_atom(entry_name).flatten(value)
           cursor = resume
           rounds += 1
-          until cursor >= max
-            attempt = try_iteration(body_atom, input, cursor)
-            break unless attempt && attempt[1] > cursor
-
-            items << root_atom(entry_name).flatten(attempt[0])
-            cursor = attempt[1]
-          end
-          break if cursor >= max
         end
         [items, resyncs]
       end
 
+      # Scan forward from `from` for the first position where the
+      # declared pattern matches with progress: [match_start, match_end].
+      def scan_pattern(pattern_atom, input, from)
+        scan = from
+        while scan < input.length
+          attempt = try_iteration(pattern_atom, input, scan)
+          return [scan, attempt[1]] if attempt
+
+          scan += 1
+        end
+        nil
+      end
+
       # Apply the body atom at one position: [value, end_pos] on a
       # progressing match, nil otherwise.
       def try_iteration(atom, input, pos)

data/lib/parsanol/parg/compiler.rb

@@ -130,6 +130,17 @@ module Parsanol
               "(bind the class before compiling, or fix the custom declaration)"
       end
 
+      # The declared resync skip pattern for a rule, built as a raw
+      # atom (no trivia injection). Nil when the rule declares none.
+      def resync_atom_for(rule)
+        pattern = @document.resyncs[rule.to_sym] || @document.resyncs[rule.to_s]
+        return nil unless pattern
+
+        expand_left_recursion! unless @expanded
+        @resync_cache ||= {}
+        @resync_cache[rule.to_sym] ||= build_atom(pattern)
+      end
+
       def atom_for(name)
         expand_left_recursion! unless @expanded
         @atom_cache[name] ||= begin
@@ -925,6 +936,12 @@ module Parsanol
       end
 
       def build_envelope
+        @document.resyncs.each_key do |target|
+          unless @document.rules.key?(target.to_sym) ||
+              @document.rules.key?(target.to_s)
+            raise CompileError, "resync declared for unknown rule #{target.inspect}"
+          end
+        end
         entries = @document.entries.to_h do |name, rule|
           [name, entry_envelope(rule)]
         end
@@ -980,11 +997,20 @@ module Parsanol
       end
 
       def entry_envelope(rule)
-        {
+        envelope = {
           "root" => rule,
           "grammar" => JSON.parse(portable_json(rule)),
           "bindings" => binding_list(rule),
         }
+        # R2 declared resync: the skip pattern bakes as its own
+        # mini-grammar (same portable atoms shape) so every engine
+        # matches identical error spans. Raw match — no trivia
+        # injection: the pattern delimits junk, it is not syntax.
+        if (pattern = @document.resyncs[rule.to_sym] || @document.resyncs[rule.to_s])
+          envelope["resync"] =
+            JSON.parse(Parsanol::Native::Parser.serialize_grammar(build_atom(pattern)))
+        end
+        envelope
       end
 
       def portable_json(rule)

data/lib/parsanol/parg/document.rb

@@ -19,6 +19,9 @@ module Parsanol
 
       attr_accessor :grammar_name, :version, :source, :uses, :skip_declaration, :skip_source,
                     :atomic_rules, :skip_capture_key
+      # R2 declared resync: rule name -> skip pattern (the span matched
+      # at a recovery point is consumed as annotated error text).
+      attr_reader :resyncs
       attr_reader :rules, :bindings, :preprocess, :entries, :docs, :tests, :render, :derive,
                   :customs, :states
       # Entries authored in this file (pre-import); nil-entry tests resolve
@@ -45,6 +48,10 @@ module Parsanol
         # suppressed inside their bodies (token-shaped rules match
         # contiguously).
         @atomic_rules = []
+        # R2 declared resync: rule -> skip pattern. Recovery consumes
+        # each pattern match at a failure point as annotated error text
+        # and resumes the iteration after it.
+        @resyncs = {}
       end
 
       def validate!

data/lib/parsanol/parg/parser.rb

@@ -257,6 +257,22 @@ module Parsanol
             skip_newlines
             next
           end
+          if peek&.type == :ident && peek.value == "resync"
+            advance
+            target = rule_name
+            punct("=")
+            node = parse_choice
+            if document.resyncs.key?(target.to_sym)
+              raise ParseError, "duplicate resync declaration for #{target.inspect}"
+            end
+
+            # The target rule may be declared later in the block
+            # (forward reference, like entry roots); the compiler
+            # rejects unknown targets at compile time.
+            document.resyncs[target.to_sym] = validate_resync_node(node)
+            skip_newlines
+            next
+          end
           if peek&.type == :ident && STATE_KEYWORDS.include?(peek.value)
             keyword = advance.value
             slot = ident.value
@@ -300,6 +316,30 @@ module Parsanol
         end
       end
 
+      # A resync pattern may be any expression EXCEPT captures and
+      # state operations: the span it matches is reported as skipped
+      # error text, so bindings and slots have no meaning inside it,
+      # and a capture would silently drop its data.
+      def validate_resync_node(node)
+        case node.kind
+        when :cap
+          raise ParseError,
+                "resync pattern may not contain captures (the matched " \
+                "span is annotated error text), got :cap"
+        when :seq, :alt
+          node.a.each { |child| validate_resync_node(child) }
+          node
+        when :rep, :opt
+          validate_resync_node(node.a)
+          node
+        when :pred
+          validate_resync_node(node.b)
+          node
+        else
+          node
+        end
+      end
+
       def validate_skip_node(node)
         case node.kind
         when :ref

data/lib/parsanol/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.105
+  version: 1.3.107
 platform: arm-linux
 authors:
 - Ribose Inc.