parsanol 1.3.13-arm-linux

data/lib/parsanol/atoms/str.rb

@@ -0,0 +1,109 @@
+# 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)
+        if source.chars_left < 1
+          return context.err(self, source,
+                             @early_eof_msg)
+        end
+
+        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)
+        if source.chars_left < @char_count
+          return context.err(self, source,
+                             @early_eof_msg)
+        end
+
+        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

data/lib/parsanol/atoms.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Parser atoms - the building blocks for grammars.
+# Each atom type handles a specific parsing primitive or combinator.
+module Parsanol
+  module Atoms
+    # Precedence levels for pretty-printing.
+    # Higher values bind more loosely.
+    module Precedence
+      ATOM       = 1  # literals, entities
+      LOOKAHEAD  = 2  # &expr, !expr
+      REPETITION = 3  # expr*, expr+, expr?
+      SEQUENCE   = 4  # expr expr
+      CHOICE     = 5  # expr | expr
+      TOP        = 6  # outer level
+
+      # Backward-compatible aliases
+      BASE      = ATOM
+      ALTERNATE = CHOICE
+      OUTER     = TOP
+    end
+
+    # Load atom implementations
+    require "parsanol/atoms/can_flatten"
+    require "parsanol/atoms/context"
+    require "parsanol/atoms/dsl"
+    require "parsanol/atoms/base"
+    require "parsanol/atoms/custom"
+    require "parsanol/atoms/ignored"
+    require "parsanol/atoms/named"
+    require "parsanol/atoms/lookahead"
+    require "parsanol/atoms/cut"
+    require "parsanol/atoms/alternative"
+    require "parsanol/atoms/sequence"
+    require "parsanol/atoms/repetition"
+    require "parsanol/atoms/re"
+    require "parsanol/atoms/str"
+    require "parsanol/atoms/entity"
+    require "parsanol/atoms/capture"
+    require "parsanol/atoms/dynamic"
+    require "parsanol/atoms/scope"
+    require "parsanol/atoms/infix"
+    # Load visitor pattern (must be after all atom classes)
+    require "parsanol/atoms/visitor"
+  end
+end

data/lib/parsanol/buffer.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Parsanol
+  # A fixed-size buffer for efficient array operations.
+  #
+  # Buffer wraps an array with a logical size separate from capacity.
+  # This allows reusing buffers without reallocating arrays, reducing GC pressure.
+  #
+  # == Usage
+  #
+  #   buffer = Buffer.new(capacity: 10)
+  #   buffer.push("a")
+  #   buffer.push("b")
+  #   buffer.size  # => 2
+  #   buffer.to_a  # => ["a", "b"]
+  #   buffer.clear!
+  #   buffer.size  # => 0 (but capacity still 10)
+  #
+  # == Size vs Capacity
+  #
+  # - Size: Number of elements logically in the buffer
+  # - Capacity: Maximum elements before reallocation
+  #
+  # Reusing buffers maintains capacity while resetting size.
+  #
+  class Buffer
+    include Resettable
+
+    # @return [Integer] Logical size (number of elements)
+    attr_reader :size
+
+    # @return [Integer] Maximum capacity before growth
+    attr_reader :capacity
+
+    # @return [Array] Underlying array storage
+    attr_reader :storage
+
+    # Initialize a new buffer with specified capacity.
+    #
+    # @param capacity [Integer] Initial capacity (default: 10)
+    #
+    def initialize(capacity: 10)
+      @capacity = capacity
+      @storage = Array.new(capacity)
+      @size = 0
+    end
+
+    # Add an element to the buffer.
+    #
+    # Grows buffer if needed, but this should be rare with proper size classes.
+    #
+    # @param element [Object] Element to add
+    # @return [self] For method chaining
+    #
+    def push(element)
+      grow! if @size >= @capacity
+      @storage[@size] = element
+      @size += 1
+      self
+    end
+
+    alias << push
+
+    # Get element at index.
+    #
+    # @param index [Integer] Zero-based index
+    # @return [Object] Element at index, or nil if out of bounds
+    #
+    def [](index)
+      return nil if index >= @size
+
+      @storage[index]
+    end
+
+    # Set element at index.
+    #
+    # @param index [Integer] Zero-based index
+    # @param value [Object] Value to set
+    #
+    def []=(index, value)
+      @storage[index] = value if index < @size
+    end
+
+    # Convert buffer to array (creates new array slice of logical size).
+    #
+    # @return [Array] Array containing elements [0...size]
+    #
+    def to_a
+      @storage[0...@size]
+    end
+
+    # Clear the buffer (reset logical size, keep capacity).
+    #
+    # @return [self] For method chaining
+    #
+    def clear!
+      # Clear references for GC (keep capacity)
+      @size.upto(@capacity - 1) { |i| @storage[i] = nil }
+      @size = 0
+      self
+    end
+
+    # Check if buffer is empty.
+    #
+    # @return [Boolean] true if size is zero
+    #
+    def empty?
+      @size.zero?
+    end
+
+    # Reset protocol for ObjectPool compatibility.
+    # Delegates to clear! for buffer cleanup.
+    #
+    # @return [self] For method chaining
+    #
+    def reset!
+      clear!
+    end
+
+    private
+
+    # Grow buffer capacity (double it).
+    # Should be rare with proper size class selection.
+    #
+    def grow!
+      new_capacity = @capacity * 2
+      new_storage = Array.new(new_capacity)
+      @storage.each_with_index { |elem, i| new_storage[i] = elem }
+      @storage = new_storage
+      @capacity = new_capacity
+    end
+  end
+end