pestle 0.1.0

data/lib/pestle/grammar/expressions/identifier.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pestle::Grammar
+  # A terminal pointing to a rule, either a grammar rule or a built-in rule.
+  class Identifier < Terminal
+    attr_reader :value
+
+    def initialize(value, tag: nil)
+      super(tag: tag)
+      @value = value
+    end
+
+    def to_s
+      @value
+    end
+
+    def parse(state, pairs)
+      unless @tag.nil?
+        state.with_tag(@tag || raise) do
+          return state.rules[@value].parse(state, pairs)
+        end
+      end
+      state.rules[@value].parse(state, pairs)
+    end
+  end
+end

data/lib/pestle/grammar/expressions/postfix.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module Pestle::Grammar
+  # An optional expression `<expression>?`.
+  class Optional < Expression
+    attr_reader :expression
+
+    def initialize(expression)
+      super(tag: nil)
+      @expression = expression
+    end
+
+    def to_s
+      "#{@expression}?"
+    end
+
+    def parse(state, pairs)
+      children = [] # : Array[Pestle::Pair]
+      pairs.concat(children) if @expression.parse(state, children)
+      true
+    end
+
+    def children = [@expression]
+  end
+
+  # An expression repeated zero or more times `<expression>*`.
+  class Repeat < Expression
+    attr_reader :expression
+
+    def initialize(expression)
+      super(tag: nil)
+      @expression = expression
+    end
+
+    def to_s
+      "#{@expression}*"
+    end
+
+    def parse(state, pairs)
+      children = [] # : Array[Pestle::Pair]
+      loop do
+        state.checkpoint
+        if @expression.parse(state, children)
+          state.ok
+          pairs.concat(children)
+          children.clear
+          state.parse_trivia(children)
+        else
+          state.restore
+          break
+        end
+      end
+      true # Always succeed
+    end
+
+    def children = [@expression]
+  end
+
+  # An expression repeated one or more times `<expression>+`.
+  class RepeatOnce < Expression
+    attr_reader :expression
+
+    def initialize(expression)
+      super(tag: nil)
+      @expression = expression
+    end
+
+    def to_s
+      "#{@expression}+"
+    end
+
+    def parse(state, pairs)
+      children = [] # : Array[Pestle::Pair]
+
+      state.checkpoint
+      if @expression.parse(state, children)
+        state.ok
+        pairs.concat(children)
+        children.clear
+        state.parse_trivia(children)
+      else
+        state.restore
+        return false
+      end
+
+      loop do
+        state.checkpoint
+        if @expression.parse(state, children)
+          state.ok
+          pairs.concat(children)
+          children.clear
+          state.parse_trivia(children)
+        else
+          state.restore
+          break
+        end
+      end
+
+      true
+    end
+
+    def children = [@expression]
+  end
+
+  # An expression repeated a specified number of times `<expression>{n}`.
+  class RepeatExact < Expression
+    attr_reader :expression, :number
+
+    def initialize(expression, number)
+      super(tag: nil)
+      @expression = expression
+      @number = number
+    end
+
+    def to_s
+      "#{@expression}{#{@number}}"
+    end
+
+    def parse(state, pairs)
+      return true if @number.zero?
+
+      children = [] # : Array[Pestle::Pair]
+      count = 0
+
+      state.checkpoint
+
+      loop do
+        state.parse_trivia(children)
+        break unless @expression.parse(state, children)
+
+        count += 1
+
+        break if count == @number
+      end
+
+      if count == @number
+        pairs.concat(children)
+        state.ok
+        true
+      else
+        state.restore
+        false
+      end
+    end
+
+    def children = [@expression]
+  end
+
+  # An expression repeated at least specified number of times `<expression>{n,}`.
+  class RepeatMin < Expression
+    attr_reader :expression, :number
+
+    def initialize(expression, number)
+      super(tag: nil)
+      @expression = expression
+      @number = number
+    end
+
+    def to_s
+      "#{@expression}{#{@number},}"
+    end
+
+    def parse(state, pairs)
+      return true if @number.zero?
+
+      children = [] # : Array[Pestle::Pair]
+      count = 0
+
+      state.checkpoint
+
+      loop do
+        state.parse_trivia(children)
+        break unless @expression.parse(state, children)
+
+        count += 1
+      end
+
+      if count >= @number
+        pairs.concat(children)
+        state.ok
+        true
+      else
+        state.restore
+        false
+      end
+    end
+
+    def children = [@expression]
+  end
+
+  # An expression repeated at most specified number of times `<expression>{,n}`.
+  class RepeatMax < Expression
+    attr_reader :expression, :number
+
+    def initialize(expression, number)
+      super(tag: nil)
+      @expression = expression
+      @number = number
+    end
+
+    def to_s
+      "#{@expression}{,#{@number}}"
+    end
+
+    def parse(state, pairs)
+      return true if @number.zero?
+
+      children = [] # : Array[Pestle::Pair]
+      count = 0
+
+      state.checkpoint
+
+      loop do
+        state.parse_trivia(children)
+        break unless @expression.parse(state, children)
+
+        count += 1
+
+        break if count == @number
+      end
+
+      pairs.concat(children)
+      state.ok
+      true
+    end
+
+    def children = [@expression]
+  end
+
+  # An expression repeated a specified range of times `<expression>{n,m}`.
+  class RepeatMinMax < Expression
+    attr_reader :expression, :min, :max
+
+    def initialize(expression, min, max)
+      super(tag: nil)
+      @expression = expression
+      @min = min
+      @max = max
+    end
+
+    def to_s
+      "#{@expression}{#{@min},#{@max}}"
+    end
+
+    def parse(state, pairs)
+      children = [] # : Array[Pestle::Pair]
+      count = 0
+
+      state.checkpoint
+
+      loop do
+        state.parse_trivia(children)
+        break unless @expression.parse(state, children)
+
+        count += 1
+
+        break if count == @max
+      end
+
+      if count.between?(@min, @max)
+        pairs.concat(children)
+        state.ok
+        true
+      else
+        state.restore
+        false
+      end
+    end
+
+    def children = [@expression]
+  end
+end

data/lib/pestle/grammar/expressions/prefix.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pestle::Grammar
+  # A positive predicate expression `&<expression>`.
+  class PositivePredicate < Expression
+    attr_reader :expression
+
+    def initialize(expression, tag: nil)
+      super(tag: tag)
+      @expression = expression
+    end
+
+    def to_s
+      "#{tag_s}&#{@expression}"
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      state.checkpoint
+      matched = @expression.parse(state, [])
+      state.restore
+      matched
+    end
+
+    def children = [@expression]
+  end
+
+  # A negative predicate expression `!<expression>`.
+  class NegativePredicate < Expression
+    attr_reader :expression
+
+    def initialize(expression, tag: nil)
+      super(tag: tag)
+      @expression = expression
+    end
+
+    def to_s
+      "#{tag_s}!#{@expression}"
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      state.neg_pred_stack << state.scanner.pos
+      state.checkpoint
+      matched = @expression.parse(state, [])
+      state.restore
+      state.neg_pred_stack.pop
+      !matched
+    end
+
+    def children = [@expression]
+  end
+end

data/lib/pestle/grammar/expressions/range.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pestle::Grammar
+  # An expression matching a single character from a continuous range.
+  class Range < Terminal
+    attr_reader :start, :stop
+
+    def initialize(start, stop, tag: nil)
+      super(tag: tag)
+      @start = start
+      @stop = stop
+      @re = /[#{Regexp.escape(start)}-#{Regexp.escape(stop)}]/
+      @s = to_s
+    end
+
+    def to_s
+      "#{tag_s}['#{@start}'..'#{@stop}']"
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      matched = !state.scanner.scan(@re).nil?
+      state.track(@s, matched)
+      matched
+    end
+  end
+end

data/lib/pestle/grammar/expressions/sequence.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pestle::Grammar
+  # The sequence operator `~`.
+  class Sequence < Expression
+    attr_reader :expressions
+
+    def initialize(*expressions)
+      super(tag: nil)
+      @expressions = expressions
+    end
+
+    def to_s
+      seq = @expressions.map(&:to_s).join(" ~ ")
+      "#{tag_s}#{seq}"
+    end
+
+    def parse(state, pairs)
+      children = [] # : Array[Pestle::Pair]
+      state.checkpoint
+
+      @expressions.each_with_index do |expr, i|
+        unless expr.parse(state, children)
+          state.restore
+          return false
+        end
+
+        state.parse_trivia(children) if i < @expressions.length - 1
+      end
+
+      pairs.concat(children)
+      state.ok
+      true
+    end
+
+    def children = @expressions
+  end
+end

data/lib/pestle/grammar/expressions/stack.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Pestle::Grammar
+  # A PUSH terminal with a string literal argument.
+  class PushLiteral < Terminal
+    attr_reader :value
+
+    def initialize(value, tag: nil)
+      super(tag: tag)
+      @value = value
+    end
+
+    def to_s
+      "#{tag_s}PUSH(\"#{value}\")"
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      state.stack_push(@value)
+      true
+    end
+  end
+
+  # A PUSH terminal with an expression.
+  class Push < Expression
+    attr_reader :expression
+
+    def initialize(expression, tag: nil)
+      super(tag: tag)
+      @expression = expression
+    end
+
+    def to_s
+      "#{tag_s}PUSH( #{@expression} )"
+    end
+
+    def parse(state, pairs)
+      start_byte_pos = state.scanner.pos
+      children = [] # : Array[Pestle::Pair]
+
+      if @expression.parse(state, children)
+        pairs.concat(children)
+        state.stack_push(state.text.byteslice(start_byte_pos...state.scanner.pos) || raise)
+        true
+      else
+        false
+      end
+    end
+
+    def children = [@expression]
+  end
+
+  # A PEEK terminal with a range expression.
+  # Matches the range from the bottom of the stack to the top.
+  class PeekSlice < Terminal
+    attr_reader :start, :stop
+
+    def initialize(start, stop, tag: nil)
+      super(tag: tag)
+      @start = start
+      @stop = stop
+    end
+
+    def to_s
+      "#{tag_s}PEEK[#{@start}..#{@stop}]"
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      start_pos = state.scanner.pos
+      state.stack_peek_slice(@start, @stop).each do |s|
+        matched = !state.scanner.scan(s).nil? # steep:ignore ArgumentTypeMismatch
+        state.track(s, matched)
+
+        next if matched
+
+        state.scanner.pos = start_pos
+        return false
+      end
+
+      true
+    end
+  end
+
+  # A PEEK terminal looking at the top of the stack.
+  class Peek < Terminal
+    def to_s
+      "#{tag_s}PEEK"
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      peeked = state.stack_peek
+      state.track("PEEK", !peeked.nil?)
+
+      return false if peeked.nil?
+
+      matched = !state.scanner.scan(peeked).nil? # steep:ignore ArgumentTypeMismatch
+      state.track(peeked, matched)
+      matched
+    end
+  end
+
+  # A PEEK_ALL terminal matching the entire stack, top to bottom.
+  class PeekAll < Terminal
+    def to_s
+      "#{tag_s}PEEK_ALL"
+    end
+
+    def parse(state, pairs)
+      start_pos = state.scanner.pos
+      children = [] # : Array[Pestle::Pair]
+
+      state.user_stack.reverse_each.with_index do |s, i|
+        matched = !state.scanner.scan(s).nil? # steep:ignore ArgumentTypeMismatch
+        state.track(s, matched)
+
+        unless matched
+          state.scanner.pos = start_pos
+          return false
+        end
+
+        state.parse_trivia(children) if i < state.user_stack.length
+      end
+
+      pairs.concat(children)
+      true
+    end
+  end
+
+  # A POP terminal popping off the top of the stack.
+  class Pop < Terminal
+    def to_s
+      "#{tag_s}POP"
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      peeked = state.stack_peek
+      state.track("POP", !peeked.nil?)
+
+      return false if peeked.nil?
+
+      matched = !state.scanner.scan(peeked).nil? # steep:ignore ArgumentTypeMismatch
+      state.track(peeked, matched)
+
+      if matched
+        state.stack_pop
+        true
+      else
+        false
+      end
+    end
+  end
+
+  # A POP_ALL terminal matching the entire stack, top to bottom.
+  class PopAll < Terminal
+    def to_s
+      "#{tag_s}POP_ALL"
+    end
+
+    def parse(state, pairs)
+      start_pos = state.scanner.pos
+      children = [] # : Array[Pestle::Pair]
+
+      state.user_stack.reverse_each.with_index do |s, i|
+        matched = !state.scanner.scan(s).nil? # steep:ignore ArgumentTypeMismatch
+        state.track(s, matched)
+
+        unless matched
+          state.scanner.pos = start_pos
+          return false
+        end
+
+        state.parse_trivia(children) if i < state.user_stack.length
+      end
+
+      state.stack_clear
+      pairs.concat(children)
+      true
+    end
+  end
+
+  # A DROP terminal that matches if the stack is not empty.
+  class Drop < Terminal
+    def to_s
+      "#{tag_s}DROP"
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      matched = !state.stack_pop.nil?
+      state.track("DROP", matched)
+      matched
+    end
+  end
+end

data/lib/pestle/grammar/expressions/string.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pestle::Grammar
+  # An expression matching a string literal.
+  class StringLiteral < Terminal
+    attr_reader :value
+
+    def initialize(value, tag: nil)
+      super(tag: tag)
+      @value = value
+      @re = /#{Regexp.escape(value)}/
+    end
+
+    def to_s
+      @value.inspect
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      matched = !state.scanner.scan(@re).nil?
+      state.track(@value, matched)
+      matched
+    end
+  end
+
+  # An expression matching a string literal case insensitively.
+  class InsensitiveString < Terminal
+    attr_reader :value
+
+    def initialize(value, tag: nil)
+      super(tag: tag)
+      @value = value
+      @re = /#{Regexp.escape(value)}/i
+      @s = to_s
+    end
+
+    def to_s
+      "^#{@value.inspect}"
+    end
+
+    def parse(state, pairs) # rubocop: disable Lint/UnusedMethodArgument
+      matched = !state.scanner.scan(@re).nil?
+      state.track(@s, matched)
+      matched
+    end
+  end
+end