parsanol 1.0.1-aarch64-linux

data/lib/parsanol/atoms/repetition.rb

@@ -0,0 +1,259 @@
+# 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 && 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
+        return try_maybe(source, context, consume_all) if @min.zero? && @max == 1
+
+        # Exact count optimization
+        return try_exact(source, context, consume_all) if @min == @max && @max && @max <= 3
+
+        # 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)
+        return context.err_at(self, source, @min_error, source.bytepos, [v1]) unless success
+
+        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)
+        return context.err_at(self, source, @min_error, source.bytepos, [v1]) unless success
+
+        success, v2 = @parslet.apply(source, context, false)
+        return context.err_at(self, source, @min_error, source.bytepos, [v2]) unless success
+
+        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,194 @@
+# 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

data/lib/parsanol/atoms/str.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Literal string matcher. Matches an exact sequence of characters.
+#
+# @example Match literal text
+#   str('hello')  # matches exactly 'hello'
+#
+module Parsanol
+  module Atoms
+    class Str < Parsanol::Atoms::Base
+      # @return [String] the literal to match
+      attr_reader :str
+
+      # Creates a new string matcher.
+      #
+      # @param text [String, Object] the literal string to match
+      def initialize(text)
+        super()
+        @str = text.to_s
+        @byte_size = @str.bytesize
+        @char_count = @str.length
+
+        # Pre-built error messages (frozen)
+        @early_eof_msg = 'Unexpected end of input'
+        @mismatch_msg = "Expected #{@str.inspect}, but got "
+
+        # Optimization: single-char fast path
+        @single_char = (@str if @char_count == 1)
+      end
+
+      # Attempts to match the literal at current position.
+      #
+      # @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)
+        # Single-character optimization
+        return single_char_match(source, context) if @single_char
+
+        # Multi-character matching
+        multi_char_match(source, context)
+      end
+
+      # String representation.
+      #
+      # @param _prec [Integer] unused
+      # @return [String]
+      def to_s_inner(_prec)
+        "'#{@str}'"
+      end
+
+      # Simple atoms don't benefit from caching.
+      #
+      # @return [Boolean]
+      def cached?
+        false
+      end
+
+      # Produces flat results (Slice).
+      #
+      # @return [Boolean]
+      def flat?
+        true
+      end
+
+      # FIRST set is this atom itself.
+      #
+      # @return [Set]
+      def compute_first_set
+        Set.new([self])
+      end
+
+      private
+
+      # Fast path for single-character strings.
+      def single_char_match(source, context)
+        return context.err(self, source, @early_eof_msg) if source.chars_left < 1
+
+        pos = source.pos
+        slice = source.consume(1)
+
+        return ok(slice) if slice.content == @single_char
+
+        source.bytepos = pos
+        context.err_at(self, source, [@mismatch_msg, slice], pos)
+      end
+
+      # Standard path for multi-character strings.
+      def multi_char_match(source, context)
+        return context.err(self, source, @early_eof_msg) if source.chars_left < @char_count
+
+        pos = source.pos
+        slice = source.consume(@char_count)
+
+        return ok(slice) if slice.content == @str
+
+        source.bytepos = pos
+        context.err_at(self, source, [@mismatch_msg, slice], pos)
+      end
+    end
+  end
+end

data/lib/parsanol/atoms/visitor.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Visitor pattern for traversing parser atom trees.
+# Each atom type dispatches to a corresponding visitor method.
+module Parsanol
+  module Atoms
+    class Base
+      # Accepts visitor and dispatches to type-specific method.
+      # Override in subclasses.
+      #
+      # @param visitor [Object] implements visit_* methods
+      # @raise [NotImplementedError] if not overridden
+      def accept(visitor)
+        raise NotImplementedError,
+              "Missing #accept in #{self.class.name}"
+      end
+    end
+
+    class Str
+      # Dispatches to visitor's visit_str.
+      #
+      # @param visitor [Object] visitor object
+      def accept(visitor)
+        visitor.visit_str(str)
+      end
+    end
+
+    class Entity
+      # Dispatches to visitor's visit_entity.
+      #
+      # @param visitor [Object] visitor object
+      def accept(visitor)
+        visitor.visit_entity(rule_name, @body)
+      end
+    end
+
+    class Named
+      # Dispatches to visitor's visit_named.
+      #
+      # @param visitor [Object] visitor object
+      def accept(visitor)
+        visitor.visit_named(name, parslet)
+      end
+    end
+
+    class Sequence
+      # Dispatches to visitor's visit_sequence.
+      #
+      # @param visitor [Object] visitor object
+      def accept(visitor)
+        visitor.visit_sequence(parslets)
+      end
+    end
+
+    class Repetition
+      # Dispatches to visitor's visit_repetition.
+      #
+      # @param visitor [Object] visitor object
+      def accept(visitor)
+        visitor.visit_repetition(result_tag, min, max, parslet)
+      end
+    end
+
+    class Alternative
+      # Dispatches to visitor's visit_alternative.
+      #
+      # @param visitor [Object] visitor object
+      def accept(visitor)
+        visitor.visit_alternative(alternatives)
+      end
+    end
+
+    class Lookahead
+      # Dispatches to visitor's visit_lookahead.
+      #
+      # @param visitor [Object] visitor object
+      def accept(visitor)
+        visitor.visit_lookahead(positive, bound_parslet)
+      end
+    end
+
+    class Re
+      # Dispatches to visitor's visit_re.
+      #
+      # @param visitor [Object] visitor object
+      def accept(visitor)
+        visitor.visit_re(match)
+      end
+    end
+  end
+end