parsanol 1.3.13-arm-linux

data/lib/parsanol/atoms/named.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Named capture - assigns a label to matched content.
+# Results appear as { label: value } in the parse tree.
+#
+# @example Labeling matches
+#   str('foo').as(:name)  # returns { name: 'foo' }
+#
+module Parsanol
+  module Atoms
+    class Named < Parsanol::Atoms::Base
+      # @return [Parsanol::Atoms::Base] wrapped parser
+      attr_reader :parslet
+
+      # @return [Symbol] the capture label
+      attr_reader :name
+
+      # Creates a new named capture.
+      #
+      # @param parser [Parsanol::Atoms::Base] parser to wrap
+      # @param label [Symbol] name for captures
+      def initialize(parser, label)
+        super()
+        @parslet = parser
+        @name = label
+      end
+
+      # Applies parser and wraps result in hash.
+      #
+      # @param source [Parsanol::Source] input
+      # @param context [Parsanol::Atoms::Context] context
+      # @param consume_all [Boolean] require full consumption
+      # @return [Array(Boolean, Object)] result
+      def apply(source, context, consume_all)
+        success, value = @parslet.apply(source, context, consume_all)
+        return [false, value] unless success
+
+        ok(wrap_result(value))
+      end
+
+      # Named wrappers skip caching (inner parser handles it).
+      #
+      # @return [Boolean]
+      def cached?
+        false
+      end
+
+      # String representation.
+      #
+      # @param prec [Integer] precedence
+      # @return [String]
+      def to_s_inner(prec)
+        "#{@name}:#{@parslet.to_s(prec)}"
+      end
+
+      # FIRST set is wrapped parser's FIRST set.
+      #
+      # @return [Set]
+      def compute_first_set
+        @parslet.first_set
+      end
+
+      private
+
+      # Wraps matched value in labeled hash.
+      #
+      # @param matched [Object] matched value
+      # @return [Hash] labeled result
+      def wrap_result(matched)
+        { @name => flatten(matched, true) }
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/re.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Regular expression matcher for single characters.
+# Matches one character against a character class pattern.
+#
+# @example Character classes
+#   match('[a-z]')  # matches a-z
+#   match('\d')     # matches digits
+#   any             # matches any character
+#
+module Parsanol
+  module Atoms
+    class Re < Parsanol::Atoms::Base
+      # @return [String] the pattern string
+      attr_reader :match
+
+      # @return [Regexp] compiled pattern
+      attr_reader :re
+
+      # Creates a new regex matcher.
+      #
+      # @param pattern [String, Object] regex character class
+      def initialize(pattern)
+        super()
+        @match = pattern.to_s
+        @re = Regexp.new(@match, Regexp::MULTILINE)
+
+        # Extract pattern for display (strip delimiters)
+        @display = @match.inspect[1..-2] || @match
+
+        # Pre-built error messages
+        @eof_error = "Unexpected end of input"
+        @no_match_error = "Failed to match #{@display}"
+      end
+
+      # Matches one character against the pattern.
+      #
+      # @param source [Parsanol::Source] input
+      # @param context [Parsanol::Atoms::Context] context
+      # @param _consume_all [Boolean] ignored
+      # @return [Array(Boolean, Object)] result
+      def try(source, context, _consume_all)
+        # Fast path: check if next char matches
+        return ok(source.consume(1)) if source.matches?(@re)
+
+        # No input left
+        return context.err(self, source, @eof_error) if source.chars_left < 1
+
+        # Character doesn't match
+        context.err(self, source, @no_match_error)
+      end
+
+      # String representation.
+      #
+      # @param _prec [Integer] unused
+      # @return [String]
+      def to_s_inner(_prec)
+        @display
+      end
+
+      # Simple atoms don't benefit from caching.
+      #
+      # @return [Boolean]
+      def cached?
+        false
+      end
+
+      # Produces flat results.
+      #
+      # @return [Boolean]
+      def flat?
+        true
+      end
+
+      # FIRST set is this atom.
+      #
+      # @return [Set]
+      def compute_first_set
+        Set.new([self])
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/repetition.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+# Repetition - matches a parser multiple times.
+# Supports min/max bounds for various quantifier patterns.
+#
+# @example Quantifiers
+#   str('a').repeat(1,3)  # 1 to 3 'a's
+#   str('a').maybe        # optional 'a' (0 or 1)
+#   str('a').repeat       # zero or more
+#
+module Parsanol
+  module Atoms
+    class Repetition < Parsanol::Atoms::Base
+      # @return [Integer] minimum matches required
+      attr_reader :min
+
+      # @return [Integer, nil] maximum matches allowed
+      attr_reader :max
+
+      # @return [Parsanol::Atoms::Base] repeated parser
+      attr_reader :parslet
+
+      # @return [Symbol] result tag
+      attr_reader :result_tag
+
+      # Alias for compatibility
+      alias tag result_tag
+
+      # Creates a new repetition.
+      #
+      # @param parser [Parsanol::Atoms::Base] parser to repeat
+      # @param min_count [Integer] minimum repetitions
+      # @param max_count [Integer, nil] maximum repetitions
+      # @param tag [Symbol] result tag
+      def initialize(parser, min_count, max_count, tag = :repetition)
+        super()
+
+        # Handle nil max_count (unbounded repetition)
+        if max_count&.zero?
+          raise ArgumentError, "Cannot repeat zero times: #{parser.inspect}"
+        end
+
+        @parslet = parser
+        @min = min_count
+        @max = max_count
+        @result_tag = tag
+
+        # Internal value for comparisons (nil becomes infinity)
+        @max_internal = max_count || Float::INFINITY
+
+        # Pre-built error messages
+        @min_error = "Expected at least #{min_count} of #{parser.inspect}"
+        @extra_error = "Extra input after last repetition"
+      end
+
+      # Error messages hash (for compatibility)
+      def error_msgs
+        { minrep: @min_error, unconsumed: @extra_error }
+      end
+
+      # Executes the repetition.
+      #
+      # @param source [Parsanol::Source] input
+      # @param context [Parsanol::Atoms::Context] context
+      # @param consume_all [Boolean] require full consumption
+      # @return [Array(Boolean, Object)] result
+      def try(source, context, consume_all)
+        # Check for tree memoization support
+        if context.respond_to?(:use_tree_memoization?) && context.use_tree_memoization?
+          return with_tree_cache(source, context, consume_all)
+        end
+
+        # Maybe (0 or 1) - very common, optimize
+        if @min.zero? && @max == 1
+          return try_maybe(source, context,
+                           consume_all)
+        end
+
+        # Exact count optimization
+        if @min == @max && @max && @max <= 3
+          return try_exact(source, context,
+                           consume_all)
+        end
+
+        # General case
+        try_general(source, context, consume_all)
+      end
+
+      precedence REPETITION
+
+      # String representation.
+      #
+      # @param prec [Integer] precedence
+      # @return [String]
+      def to_s_inner(prec)
+        suffix = if @min.zero? && @max == 1
+                   "?"
+                 else
+                   "{#{@min}, #{@max}}"
+                 end
+        @parslet.to_s(prec) + suffix
+      end
+
+      # FIRST set includes EPSILON if min == 0.
+      #
+      # @return [Set]
+      def compute_first_set
+        first = @parslet.first_set.dup
+        first.add(Parsanol::FirstSet::EPSILON) if @min.zero?
+        first
+      end
+
+      private
+
+      # Optional match (0 or 1)
+      def try_maybe(source, context, _consume_all)
+        success, value = @parslet.apply(source, context, false)
+        return ok([@result_tag, value]) if success
+
+        ok(@result_tag == :repetition ? Parsanol::Atoms::Base::REP_TAG : [@result_tag])
+      end
+
+      # Exact count match (1, 2, or 3)
+      def try_exact(source, context, consume_all)
+        case @max
+        when 1
+          single_match(source, context, consume_all)
+        when 2
+          double_match(source, context, consume_all)
+        when 3
+          triple_match(source, context, consume_all)
+        end
+      end
+
+      def single_match(source, context, consume_all)
+        success, value = @parslet.apply(source, context, consume_all)
+        return ok([@result_tag, value]) if success
+
+        context.err_at(self, source, @min_error, source.bytepos, [value])
+      end
+
+      def double_match(source, context, consume_all)
+        success, v1 = @parslet.apply(source, context, false)
+        unless success
+          return context.err_at(self, source, @min_error, source.bytepos,
+                                [v1])
+        end
+
+        success, v2 = @parslet.apply(source, context, consume_all)
+        return ok([@result_tag, v1, v2]) if success
+
+        context.err_at(self, source, @min_error, source.bytepos, [v2])
+      end
+
+      def triple_match(source, context, consume_all)
+        success, v1 = @parslet.apply(source, context, false)
+        unless success
+          return context.err_at(self, source, @min_error, source.bytepos,
+                                [v1])
+        end
+
+        success, v2 = @parslet.apply(source, context, false)
+        unless success
+          return context.err_at(self, source, @min_error, source.bytepos,
+                                [v2])
+        end
+
+        success, v3 = @parslet.apply(source, context, consume_all)
+        return ok([@result_tag, v1, v2, v3]) if success
+
+        context.err_at(self, source, @min_error, source.bytepos, [v3])
+      end
+
+      # General repetition with buffer pooling
+      def try_general(source, context, consume_all)
+        start_pos = source.bytepos
+        occurrence = 0
+
+        # Estimate buffer size
+        estimate = [@max || 10, 10].min
+        buffer = context.acquire_buffer(size: estimate + 1)
+        buffer.push(@result_tag)
+
+        last_error = nil
+
+        loop do
+          success, value = @parslet.apply(source, context, false)
+          last_error = value
+
+          break unless success
+
+          occurrence += 1
+          buffer.push(value)
+
+          break if @max && occurrence >= @max
+        end
+
+        # Check minimum bound
+        if occurrence < @min
+          context.release_buffer(buffer)
+          source.bytepos = start_pos
+          return context.err_at(self, source, @min_error, start_pos,
+                                [last_error])
+        end
+
+        # Check complete consumption
+        if consume_all && source.chars_left.positive?
+          context.release_buffer(buffer)
+          return context.err(self, source, @extra_error, [last_error])
+        end
+
+        ok(Parsanol::LazyResult.new(buffer, context))
+      end
+
+      # Tree memoization for GPEG-style caching
+      def with_tree_cache(source, context, consume_all)
+        start_pos = source.bytepos
+        cache_key = object_id
+
+        # Check cache
+        cached = context.query_tree_memo(cache_key, start_pos)
+        if cached
+          values, end_pos = cached
+          source.bytepos = end_pos
+          return ok([@result_tag] + values)
+        end
+
+        # Parse and cache
+        occurrence = 0
+        estimate = [@max || 10, 10].min
+        buffer = context.acquire_buffer(size: estimate + 1)
+        buffer.push(@result_tag)
+
+        positions = context.acquire_array
+        positions << start_pos
+        last_error = nil
+
+        loop do
+          source.bytepos
+          success, value = @parslet.apply(source, context, false)
+          last_error = value
+
+          break unless success
+
+          occurrence += 1
+          buffer.push(value)
+          positions << source.bytepos
+
+          break if @max && occurrence >= @max
+        end
+
+        # Cache successful prefix
+        if occurrence.positive?
+          end_pos = positions[occurrence]
+          context.store_tree_memo(cache_key, start_pos, buffer.to_a[1..],
+                                  end_pos)
+        end
+
+        # Check minimum
+        if occurrence < @min
+          context.release_buffer(buffer)
+          source.bytepos = start_pos
+          return context.err_at(self, source, @min_error, start_pos,
+                                [last_error])
+        end
+
+        # Check consumption
+        if consume_all && source.chars_left.positive?
+          context.release_buffer(buffer)
+          return context.err(self, source, @extra_error, [last_error])
+        end
+
+        ok(Parsanol::LazyResult.new(buffer, context))
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/scope.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Starts a new scope in the parsing process. Please also see the #captures
+# method.
+#
+module Parsanol
+  module Atoms
+    class Scope < Parsanol::Atoms::Base
+      attr_reader :block
+
+      def initialize(block)
+        super()
+
+        @block = block
+      end
+
+      def cached?
+        false
+      end
+
+      def apply(source, context, consume_all)
+        # Phase 55: Cache @block ivar to reduce lookup overhead
+        block = @block
+        context.scope do
+          parslet = block.call
+          return parslet.apply(source, context, consume_all)
+        end
+      end
+
+      def to_s_inner(prec)
+        "scope { #{block.call.to_s(prec)} }"
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/sequence.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+# Sequential composition - matches parsers in left-to-right order.
+# All parsers must succeed for the sequence to succeed.
+#
+# @example Sequence of matches
+#   str('a') >> str('b')  # matches 'a' then 'b'
+#
+module Parsanol
+  module Atoms
+    class Sequence < Parsanol::Atoms::Base
+      # @return [Array<Parsanol::Atoms::Base>] sequence members
+      attr_reader :parslets
+
+      # Creates a new sequence.
+      #
+      # @param components [Array<Parsanol::Atoms::Base>] parsers to sequence
+      def initialize(*components)
+        super()
+        @parslets = components
+
+        # Pre-built error message
+        @fail_msg = "Failed to match sequence (#{inspect})"
+      end
+
+      # Error messages hash (for compatibility)
+      def error_msgs
+        { failed: @fail_msg }
+      end
+
+      # Appends a parser to this sequence with flattening.
+      #
+      # @param parser [Parsanol::Atoms::Base] parser to append
+      # @return [Parsanol::Atoms::Sequence] new flattened sequence
+      def >>(other)
+        # Flatten nested sequences
+        expanded = if other.is_a?(Parsanol::Atoms::Sequence)
+                     @parslets + other.parslets
+                   else
+                     @parslets + [other]
+                   end
+
+        # Merge adjacent string literals
+        merged = merge_adjacent_strings(expanded)
+
+        self.class.new(*merged)
+      end
+
+      # Executes all parsers in sequence.
+      #
+      # @param source [Parsanol::Source] input
+      # @param context [Parsanol::Atoms::Context] context
+      # @param consume_all [Boolean] require full consumption
+      # @return [Array(Boolean, Object)] result
+      def try(source, context, consume_all)
+        components = @parslets
+        count = components.size
+
+        # Dispatch based on size for optimization
+        case count
+        when 1
+          match_single(components[0], source, context, consume_all)
+        when 2
+          match_pair(components[0], components[1], source, context, consume_all)
+        when 3
+          match_triple(components[0], components[1], components[2], source,
+                       context, consume_all)
+        else
+          match_general(components, source, context, consume_all)
+        end
+      end
+
+      precedence SEQUENCE
+
+      # String representation.
+      #
+      # @param prec [Integer] precedence
+      # @return [String]
+      def to_s_inner(prec)
+        @parslets.map { |p| p.to_s(prec) }.join(" ")
+      end
+
+      # FIRST set is first element's FIRST set (with epsilon propagation).
+      #
+      # @return [Set]
+      def compute_first_set
+        return Set.new if @parslets.empty?
+
+        result = Set.new
+        @parslets.each do |parser|
+          first = parser.first_set
+          result.merge(first.reject { |x| x == Parsanol::FirstSet::EPSILON })
+          break unless first.include?(Parsanol::FirstSet::EPSILON)
+        end
+        result
+      end
+
+      private
+
+      # Single element sequence
+      def match_single(parser, source, context, consume_all)
+        success, value = parser.apply(source, context, consume_all)
+        return context.err(self, source, @fail_msg, [value]) unless success
+
+        ok([:sequence, value])
+      end
+
+      # Two-element sequence with buffer pooling
+      def match_pair(p1, p2, source, context, consume_all)
+        success, v1 = p1.apply(source, context, false)
+        return context.err(self, source, @fail_msg, [v1]) unless success
+
+        success, v2 = p2.apply(source, context, consume_all)
+        return context.err(self, source, @fail_msg, [v2]) unless success
+
+        buffer = context.acquire_buffer(size: 3)
+        buffer.push(:sequence)
+        buffer.push(v1)
+        buffer.push(v2)
+        ok(Parsanol::LazyResult.new(buffer, context))
+      end
+
+      # Three-element sequence with buffer pooling
+      def match_triple(p1, p2, p3, source, context, consume_all)
+        success, v1 = p1.apply(source, context, false)
+        return context.err(self, source, @fail_msg, [v1]) unless success
+
+        success, v2 = p2.apply(source, context, false)
+        return context.err(self, source, @fail_msg, [v2]) unless success
+
+        success, v3 = p3.apply(source, context, consume_all)
+        return context.err(self, source, @fail_msg, [v3]) unless success
+
+        buffer = context.acquire_buffer(size: 4)
+        buffer.push(:sequence)
+        buffer.push(v1)
+        buffer.push(v2)
+        buffer.push(v3)
+        ok(Parsanol::LazyResult.new(buffer, context))
+      end
+
+      # General case for N elements
+      def match_general(components, source, context, consume_all)
+        buffer = context.acquire_buffer(size: components.size + 1)
+        buffer.push(:sequence)
+
+        last_idx = components.size - 1
+        idx = 0
+
+        while idx <= last_idx
+          must_consume = consume_all && (idx == last_idx)
+          success, value = components[idx].apply(source, context, must_consume)
+
+          unless success
+            context.release_buffer(buffer)
+            return context.err(self, source, @fail_msg, [value])
+          end
+
+          buffer.push(value)
+          idx += 1
+        end
+
+        ok(Parsanol::LazyResult.new(buffer, context))
+      end
+
+      # Merges adjacent string atoms using Rope for efficiency
+      def merge_adjacent_strings(components)
+        result = []
+        idx = 0
+
+        while idx < components.size
+          current = components[idx]
+
+          if current.is_a?(Parsanol::Atoms::Str)
+            rope = Parsanol::Rope.new.append(current.str)
+            next_idx = idx + 1
+
+            while next_idx < components.size && components[next_idx].is_a?(Parsanol::Atoms::Str)
+              rope.append(components[next_idx].str)
+              next_idx += 1
+            end
+
+            result << (next_idx > idx + 1 ? Parsanol::Atoms::Str.new(rope.to_s) : current)
+            idx = next_idx
+          else
+            result << current
+            idx += 1
+          end
+        end
+
+        result
+      end
+    end
+  end
+end