parsanol 1.3.114 → 1.3.115

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c113bca1ed586242d379c7be03cda7897c6cbb2862d2305f9257cd7670b5e62b
-  data.tar.gz: 4aa6a7a5e0d7f8d7c8ab5424b89d02d6835beee3f12e8cfacefe07e07d3344b4
+  metadata.gz: 116a1ab6a5ed95d4b3998c1d1d0b4860ed7dabafb5464c8aa8ff7d8602d9c221
+  data.tar.gz: 0f4799930aa443744b0ed3367fc139ab18eb565aca24a640a642d37b80596736
 SHA512:
-  metadata.gz: 3259ed625a354e9d36ec43c2737f8d7c0c91e783ca6f573317f0a61a6f0268073f426cc3866721262cca167fd6ee0d7a112751741720dadf1ac9a858a3acb79d
-  data.tar.gz: 51fe65b35a4cef0f660148e90331cb0bae788710c35214baa2d0139a9e516faa0c43e75004bbd23d0874e68fdddf01fb5c437135399f2c1e2198b8742f8310f5
+  metadata.gz: df5ecd79facb4f09fcbbd5328ce3a4d2713fb230322a1f6ff4fccfd68fc6b12cbb6fa5db573df86035e3ce85c1626bed58b75c494a38701305456d35c34f6502
+  data.tar.gz: c1f70bd90dd3ba48126dbb010d9ba89013b39cab654284224afe5031d7713caae84cc3c26b6b454f508b6fa7083504a52bc49dc1c18651a9c381042a94588b71

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.19.8"
+version = "0.19.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86357f129e791c3b7b79a0a8a2b10c7ad00a2e0f8452224bc1cd15b81a7d5c31"
+checksum = "19a06284aa6f46b116ad287275b3febfbd5f36b0f85b130f492d8244afea8c13"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.19.8"
+version = "0.19.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45bbd7570b3fe0a704e1db635f2f54b792d34646576794244646e88f4575c06d"
+checksum = "dd454669ba1439d5c4f1bb3cd71861cda751586a3ddf2521383f8fbbb4b19049"
 dependencies = [
  "proc-macro2",
  "quote",

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/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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parsanol
-  VERSION = "1.3.114"
+  VERSION = "1.3.115"
 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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.114
+  version: 1.3.115
 platform: ruby
 authors:
 - Ribose Inc.