fabulator-grammar 0.0.1 → 0.0.3

data/lib/fabulator/grammar/expr/rule_alternative.rb

@@ -0,0 +1,45 @@
+module Fabulator
+  module Grammar
+    module Expr
+      class RuleAlternative
+        def initialize
+          @sequences = [ ]
+        end
+
+        def add_sequence(s)
+          s = [ s ] unless s.is_a?(Array)
+          @sequences += s
+        end
+
+        def parse(source)
+          results = { }
+          @sequences.each do |sequence|
+            r = sequence.parse(source)
+            return nil if r.nil? # we fail
+            nom = (sequence.name rescue nil)
+            rr = { }
+            if nom.nil?
+              rr = r
+            elsif !r.nil?
+              if !(r.is_a?(Hash) || r.is_a?(Array)) || !r.empty?
+                rr[nom] = r
+              end
+            end
+            if rr.is_a?(Hash) && !rr.empty?
+              rr.each_pair do |k,v|
+                if results[k].nil?
+                  results[k] = v
+                elsif results[k].is_a?(Array)
+                  results[k] << v
+                else
+                  results[k] = [ results[k], v ]
+                end
+              end
+            end
+          end
+          results
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/grammar/expr/rule_mode.rb

@@ -0,0 +1,16 @@
+module Fabulator
+  module Grammar
+    module Expr
+      class RuleMode
+        def initialize(m)
+          @mode = m
+        end
+
+        def parse(s)
+          s.mode = @mode
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/grammar/expr/rule_ref.rb

@@ -2,12 +2,23 @@ module Fabulator::Grammar::Expr
   class RuleRef
     def initialize(qname)
       bits = qname.split(/:/,2)
-      @ns_prefix = bits[0]
-      @name = bits[1]
+      if bits.size > 1
+        @ns_prefix = bits[0]
+        @name = bits[1]
+      else
+        @name = qname
+      end
     end
 
-    def to_regex
-      %r{}
+    def name
+      @name
+    end
+
+    def parse(cursor)
+      rule = cursor.find_rule(@name)
+      return nil if rule.nil?
+      # we have @name as the path prefix for this part?
+      cursor.attempt { |c| rule.parse(c) }
     end
   end
 end

data/lib/fabulator/grammar/expr/rule_sequence.rb

@@ -0,0 +1,59 @@
+module Fabulator
+  module Grammar
+    module Expr
+      class RuleSequence
+        def initialize(hypo, atom, quant = nil)
+          @name = hypo
+          @atom = atom
+          @quantifier = quant
+        end
+
+        # eventually, this can be the hypo name
+        def name
+          @name.nil? ? (@atom.name rescue nil) : @name
+        end
+
+        def parse(source)
+          if @quantifier.nil?
+            return @atom.parse(source)
+          end
+
+          case @quantifier.first
+            when '?'.to_sym: return @atom.parse(source) || { }
+            when :s: 
+              ret = [ ]
+              r = @atom.parse(source)
+              while !r.nil?
+                ret << r
+                if @quantifier[1].nil?
+                  r = @atom.parse(source)
+                else
+                  r = @quantifier[1].parse(source)
+                  if !r.nil?
+                    r = @atom.parse(source)
+                  end
+                end
+              end
+              return ret.empty? ? nil : ret
+            when 's?'.to_sym:
+              ret = [ ]
+              r = @atom.parse(source)
+              while !r.nil?
+                ret << r
+                if @quantifier[1].nil?
+                  r = @atom.parse(source)
+                else
+                  r = @quantifier[1].parse(source)
+                  if !r.nil?
+                    r = @atom.parse(source)
+                  end
+                end
+              end
+              return ret.empty? ? {} : ret
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/fabulator/grammar/expr/sequence.rb

@@ -1,8 +1,9 @@
 module Fabulator::Grammar::Expr
   class Sequence
-    def initialize(sub_seq, count = [ :one ])
+    def initialize(hypo, sub_seq, count = [ :one ])
       @sub_sequence = sub_seq
       @modifiers = ''
+      @hypothetical = hypo
       case (count - [:min]).first
         when :zero_or_one: @modifiers = '?'
         when :one_or_more: @modifiers = '+'
@@ -20,7 +21,12 @@ module Fabulator::Grammar::Expr
     end
 
     def to_regex
+      # how do we handle setting the hypothetical?
       s = %r{#{@sub_sequence.to_regex}#{@modifiers}}
     end
+
+    def parse(cursor)
+      cursor.match(self.to_regex)
+    end
   end
 end

data/lib/fabulator/grammar/expr/set_skip.rb

@@ -0,0 +1,16 @@
+module Fabulator
+  module Grammar
+    module Expr
+      class SetSkip
+        def initialize(skip)
+          @skip = skip
+        end
+
+        def parse(cursor)
+          cursor.skip = @skip
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/grammar/expr/text.rb

@@ -7,5 +7,13 @@ module Fabulator::Grammar::Expr
     def to_regex
       Regexp.escape(@text)
     end
+
+    def name
+      nil
+    end
+
+    def parse(cursor)
+      cursor.match_token(Regexp.quote(@text))
+    end
   end
 end

data/lib/fabulator/grammar/expr/{rules.rb → token.rb}

@@ -1,5 +1,7 @@
 module Fabulator::Grammar::Expr
-  class Rules
+  class Token
+    attr_accessor :name
+
     def initialize
       @alternatives = [ ]
     end
@@ -11,5 +13,14 @@ module Fabulator::Grammar::Expr
     def to_regex
       Regexp.union(@alternatives.collect{|a| a.to_regex })
     end
+
+    def parse(cursor)
+      res = cursor.match_token(self.to_regex)
+      if res.nil?
+        return nil
+      else
+        return res
+      end
+    end
   end
 end

data/lib/fabulator/grammar/expr/token_alternative.rb

@@ -0,0 +1,42 @@
+module Fabulator::Grammar::Expr
+  class TokenAlternative
+    def initialize
+      @sequences = [ ]
+      @anchor_start = false
+      @anchor_end = false
+    end
+
+    def anchor_start(t)
+      @anchor_start = case t
+        when '^': '^'
+        when '^^': '\A'
+      end
+    end
+
+    def anchor_end(t)
+      @anchor_end = case t
+        when '$': '$'
+        when '$$': '\Z'
+      end
+    end
+
+    def add_sequence(s)
+      @sequences << s
+    end
+
+    def to_regex
+      r = %r{#{@sequences.collect{ |s| s.to_regex }}}
+      if @anchor_start
+        if @anchor_end
+          %r{#{@anchor_start}#{r}#{@anchor_end}}
+        else
+          %r{#{@anchor_start}#{r}}
+        end
+      elsif @anchor_end
+        %r{#{r}#{@anchor_end}}
+      else
+        r
+      end
+    end
+  end
+end

data/lib/fabulator/grammar/rule_parser.rb

@@ -0,0 +1,667 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+module Fabulator
+  module Grammar
+    class RuleParser < Racc::Parser
+
+module_eval(<<'...end rules.racc/module_eval...', 'rules.racc', 75)
+  require 'fabulator/grammar'
+
+  def parse(t)
+    @source = t
+    @curpos = 0
+    @line = 0
+    @col = 0
+
+    @in_quantifier = false
+       
+    @yydebug = true
+
+    @last_token = nil
+       
+    do_parse
+  end
+
+  def on_error(*args)
+    raise Fabulator::Grammar::ParserError.new("unable to parse '#{args[1]}' near line #{@line + 1}, column #{@col}")
+  end
+
+  @@ops = {
+    ':=' => :COLON_EQUAL,
+    '['  => :LB,
+    ']'  => :RB,
+    '('  => :LP,
+    ')'  => :RP,
+    '{'  => :LC,
+    '}'  => :RC,
+    '?'  => :QUESTION,
+    '.'  => :DOT,
+    '..' => :DOT_DOT,
+    '...'=> :DOT_DOT_DOT,
+    '...!'=> :DOT_DOT_DOT_BANG,
+    '|'  => :PIPE,
+    ','  => :COMMA,
+    ':'  => :COLON,
+    '^'  => :CARET,
+    '^^' => :CARET_CARET,
+    '$'  => :DOLLAR,
+    '$$' => :DOLLAR_DOLLAR,
+    '/'  => :SLASH,
+  }
+
+  @@regex = {
+    :simple_tokens => %r{^(#{Regexp.union(@@ops.keys.sort_by{|a| a.length}.reverse.collect{ |k| k })})},
+    :ncname => %r{(?:[a-zA-Z_][-a-zA-Z0-9_.]*)},
+    :integer => %r{(\d+)},
+    :literal => %r{((?:"(?:[^\\"]*(?:\\.[^\\"]*)*)")|(?:'(?:[^\\']*(?:\\.[^\\']*)*)'))},
+  }
+
+  @@regex[:general] = Regexp.compile(%{^(#{@@regex[:ncname]})|#{@@regex[:integer]}|#{@@regex[:literal]}})
+
+  def next_token
+    @token = nil  
+    white_space = 0
+    new_line = 0
+    while @curpos < @source.length && @source[@curpos..@curpos] =~ /\s/ do
+      if @source[@curpos..@curpos] =~ /\n/
+        new_line = new_line + 1
+        @line = @line + 1
+        @col = 0
+      else
+        @col = @col + 1
+      end   
+      @curpos = @curpos + 1
+      white_space = white_space + 1
+    end
+    
+    # skip comments delimited by (:  :)
+    # comments can be nested
+    # these are XPath 2.0 comments
+    #
+
+    if @curpos < @source.length && @source[@curpos..@curpos+1] == '(:'
+      comment_depth = 1
+      @curpos = @curpos + 2
+      @col = @col + 2
+      while comment_depth > 0 && @curpos < @source.length
+        if @source[@curpos..@curpos+1] == '(:'
+          comment_depth = comment_depth + 1
+          @curpos = @curpos + 1
+          @col = @col + 1
+        end
+        if @source[@curpos..@curpos+1] == ':)'
+          comment_depth = comment_depth - 1
+          @curpos = @curpos + 1
+          @col = @col + 1
+        end
+        @curpos = @curpos + 1
+        @col = @col + 1
+      end
+      white_space = white_space + 1
+    end
+    
+    while @curpos < @source.length && @source[@curpos..@curpos] =~ /\s/ do
+      if @source[@curpos..@curpos] =~ /\n/
+        new_line = new_line + 1
+        @line = @line + 1
+        @col = 0
+      else
+        @col = @col + 1
+      end   
+      @curpos = @curpos + 1
+      white_space = white_space + 1
+    end
+    
+    if @curpos >= @source.length
+      @last_token = nil
+      return [ false, false ]
+    end
+
+    res = @@regex[:simple_tokens].match(@source[@curpos..@source.length-1])
+    if !res.nil?
+      if !res[1].nil?  
+        @token = [ @@ops[res[1]], res[1] ]
+      end
+    end
+  
+    if @token.nil?
+      res = @@regex[:general].match(@source[@curpos..@source.length-1])
+      if res.nil?
+        raise "Failed to parse '#{@source}' at #{@curpos}': #{@source[@curpos..@source.length-1]}"
+      end
+  #ncname, integer, literal
+      if !res[1].nil?
+        @token = [:NCNAME, res[1].to_s]
+      elsif !res[2].nil?
+        @token = [:INTEGER, res[2].to_s]
+      elsif !res[3].nil?
+        @token = [:LITERAL, res[3].to_s]
+        @token[1] = @token[1][1..@token[1].size-2]
+        @col += 2
+        @curpos += 2
+      end
+    end
+
+
+    if @token.nil?
+      puts "Uh oh... we don't know what to do: #{@source[@curpos .. @source.length-1]}"
+      return [ nil, nil ]
+    else
+      @curpos += @token[1].length
+      @col += @token[1].length
+    end
+
+    if !@token.nil? && @token[0] == :LP
+       # shorthand: if we see '(s[ )]', '(s?[ )]', '(?)', '(\d', then we have
+       if @curpos > 1 && ![' ', '('].include?(@source[@curpos-2 .. @curpos-2])
+         @token[0] = :LLP
+         @in_quantifier = true
+       end
+    elsif @in_quantifier
+      @in_quantifier = false
+      if @token[0] == :NCNAME
+        @token[0] = case @token[1]
+          when 's': :S
+          else :NCNAME
+        end
+      end
+    end
+
+    if !@token.nil? && @token[0] == :LB
+      if @curpos == 1 || @source[@curpos-2 .. @curpos - 2] == ' '
+        @token[0] = :LLB
+        @in_directive = true
+      end
+    elsif @in_directive && @token[0] == :NCNAME
+      @token[0] = @token[1].upcase.to_sym
+      @in_directive = false
+    end
+
+  #  puts "token: #{@token.join(' => ')}"
+    return @token
+  end
+...end rules.racc/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    12,    57,    16,    64,    37,    58,    12,    62,    16,     6,
+     8,    11,    15,    18,    19,     6,     8,    11,    15,    18,
+    19,    38,    10,    14,    38,    63,    16,    61,    10,    14,
+    38,     3,    16,     4,    38,    59,    66,    38,    34,    33,
+    38,    10,    14,    38,    10,    14,    10,    14,    38,    48,
+    10,    14,    10,    14,    10,    14,    38,    10,    14,    67,
+    10,    14,     4,    10,    14,    34,    75,    45,    10,    14,
+    44,    69,    70,    12,    33,    71,    10,    14,    48,    73,
+    43,    47,     6,     8,    11,    15,    18,    19,    27,    42,
+    77,    28,    29,    30,    31,    26,    55,    37,    52,    53,
+    54,    79,    80,    21,    82,    83,    84 ]
+
+racc_action_check = [
+    22,    40,    22,    50,    39,    42,     2,    49,     2,    22,
+    22,    22,    22,    22,    22,     2,     2,     2,     2,     2,
+     2,    52,    22,    22,    75,    50,     8,    49,     2,     2,
+    31,     1,     6,     1,    69,    46,    52,    20,    48,    38,
+    53,    52,    52,    26,    75,    75,     8,     8,    67,    33,
+    31,    31,     6,     6,    69,    69,    66,    20,    20,    53,
+    53,    53,    32,    26,    26,    16,    67,    30,    67,    67,
+    29,    54,    55,     7,    16,    62,    66,    66,    63,    65,
+    28,    32,     7,     7,     7,     7,     7,     7,    12,    27,
+    68,    12,    12,    12,    12,    12,    37,    17,    37,    37,
+    37,    71,    74,     3,    76,    78,    81 ]
+
+racc_action_pointer = [
+   nil,    31,     3,   103,   nil,   nil,    27,    70,    21,   nil,
+   nil,   nil,    84,   nil,   nil,   nil,    47,    78,   nil,   nil,
+    32,   nil,    -3,   nil,   nil,   nil,    38,    84,    74,    64,
+    61,    25,    60,    44,   nil,   nil,   nil,    76,    12,   -15,
+    -5,   nil,    -1,   nil,   nil,   nil,    29,   nil,    20,     2,
+    -3,   nil,    16,    35,    48,    51,   nil,   nil,   nil,   nil,
+   nil,   nil,    46,    73,   nil,    58,    51,    43,    69,    29,
+   nil,    96,   nil,   nil,    81,    19,    83,   nil,    84,   nil,
+   nil,    85,   nil,   nil,   nil ]
+
+racc_action_default = [
+    -3,   -47,    -1,   -47,    -3,    -4,   -47,    -5,   -47,    -6,
+   -35,   -17,   -47,    -7,    -3,   -18,   -38,   -22,   -19,   -20,
+   -47,    85,    -2,   -15,    -8,   -16,   -33,   -47,   -47,   -47,
+   -47,   -33,   -47,   -47,   -25,   -37,   -21,   -47,   -38,   -24,
+   -47,   -34,   -47,   -10,   -11,   -12,   -47,   -36,   -47,   -47,
+   -47,   -40,   -33,   -33,   -47,   -47,   -23,   -14,    -9,   -13,
+   -43,   -44,   -45,   -42,   -39,   -47,   -33,   -33,   -47,   -33,
+   -26,   -47,   -41,   -27,   -47,   -33,   -47,   -29,   -47,   -46,
+   -28,   -47,   -32,   -31,   -30 ]
+
+racc_goto_table = [
+    40,    51,    49,    36,    17,    46,     1,    23,    17,    25,
+    17,    50,    24,    22,    60,   nil,   nil,   nil,   nil,   nil,
+    32,   nil,    39,   nil,    17,    56,    65,    68,   nil,   nil,
+   nil,    72,    49,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    74,    76,   nil,    78,   nil,   nil,   nil,   nil,   nil,    81 ]
+
+racc_goto_check = [
+     7,    13,    10,     9,     8,     7,     1,     5,     8,     5,
+     8,    12,     6,     2,    14,   nil,   nil,   nil,   nil,   nil,
+     1,   nil,     8,   nil,     8,     9,     7,     7,   nil,   nil,
+   nil,    13,    10,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+     7,     7,   nil,     7,   nil,   nil,   nil,   nil,   nil,     7 ]
+
+racc_goto_pointer = [
+   nil,     6,     9,   nil,   nil,     1,     5,   -26,     2,   -14,
+   -31,   nil,   -22,   -32,   -35 ]
+
+racc_goto_default = [
+   nil,   nil,     2,     5,     7,     9,    13,   nil,    41,   nil,
+    20,    35,   nil,   nil,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 31, :_reduce_1,
+  3, 31, :_reduce_2,
+  0, 32, :_reduce_3,
+  2, 32, :_reduce_4,
+  1, 33, :_reduce_none,
+  1, 33, :_reduce_none,
+  1, 34, :_reduce_7,
+  2, 34, :_reduce_8,
+  4, 36, :_reduce_9,
+  3, 36, :_reduce_none,
+  3, 36, :_reduce_none,
+  3, 36, :_reduce_none,
+  4, 36, :_reduce_13,
+  4, 36, :_reduce_14,
+  2, 36, :_reduce_15,
+  2, 36, :_reduce_16,
+  1, 36, :_reduce_17,
+  1, 36, :_reduce_18,
+  1, 36, :_reduce_19,
+  1, 36, :_reduce_20,
+  2, 35, :_reduce_21,
+  1, 35, :_reduce_22,
+  3, 35, :_reduce_23,
+  2, 35, :_reduce_24,
+  2, 40, :_reduce_25,
+  3, 39, :_reduce_26,
+  4, 39, :_reduce_27,
+  5, 39, :_reduce_28,
+  4, 39, :_reduce_29,
+  6, 39, :_reduce_30,
+  5, 39, :_reduce_31,
+  5, 39, :_reduce_32,
+  0, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 38, :_reduce_35,
+  3, 38, :_reduce_36,
+  2, 38, :_reduce_37,
+  0, 41, :_reduce_none,
+  3, 41, :_reduce_none,
+  1, 42, :_reduce_none,
+  3, 42, :_reduce_none,
+  2, 42, :_reduce_none,
+  2, 43, :_reduce_none,
+  2, 43, :_reduce_none,
+  1, 44, :_reduce_none,
+  3, 44, :_reduce_none ]
+
+racc_reduce_n = 47
+
+racc_shift_n = 85
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :PIPE => 2,
+  :LLB => 3,
+  :MODE => 4,
+  :NCNAME => 5,
+  :RB => 6,
+  :COMMIT => 7,
+  :UNCOMMIT => 8,
+  :REJECT => 9,
+  :SKIP => 10,
+  :RESYNC => 11,
+  :DOT_DOT_DOT => 12,
+  :DOT_DOT_DOT_BANG => 13,
+  :CARET => 14,
+  :CARET_CARET => 15,
+  :DOLLAR => 16,
+  :DOLLAR_DOLLAR => 17,
+  :COLON_EQUAL => 18,
+  :LLP => 19,
+  :QUESTION => 20,
+  :RP => 21,
+  :S => 22,
+  :INTEGER => 23,
+  :DOT_DOT => 24,
+  :LITERAL => 25,
+  :LP => 26,
+  :LB => 27,
+  :COMMA => 28,
+  :SLASH => 29 }
+
+racc_nt_base = 30
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "PIPE",
+  "LLB",
+  "MODE",
+  "NCNAME",
+  "RB",
+  "COMMIT",
+  "UNCOMMIT",
+  "REJECT",
+  "SKIP",
+  "RESYNC",
+  "DOT_DOT_DOT",
+  "DOT_DOT_DOT_BANG",
+  "CARET",
+  "CARET_CARET",
+  "DOLLAR",
+  "DOLLAR_DOLLAR",
+  "COLON_EQUAL",
+  "LLP",
+  "QUESTION",
+  "RP",
+  "S",
+  "INTEGER",
+  "DOT_DOT",
+  "LITERAL",
+  "LP",
+  "LB",
+  "COMMA",
+  "SLASH",
+  "$start",
+  "rules",
+  "rule",
+  "rule_bit",
+  "directives",
+  "sequence",
+  "directive",
+  "opt_separator",
+  "atom",
+  "sequence_qualifiers",
+  "hypothetical",
+  "opt_params",
+  "params",
+  "param",
+  "relative_path" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'rules.racc', 6)
+  def _reduce_1(val, _values, result)
+     result = Fabulator::Grammar::Expr::Rule.new; result.add_alternative(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 7)
+  def _reduce_2(val, _values, result)
+     result = val[0]; result.add_alternative(val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 9)
+  def _reduce_3(val, _values, result)
+     result = Fabulator::Grammar::Expr::RuleAlternative.new; 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 10)
+  def _reduce_4(val, _values, result)
+     result = val[0]; result.add_sequence(val[1]) 
+    result
+  end
+.,.,
+
+# reduce 5 omitted
+
+# reduce 6 omitted
+
+module_eval(<<'.,.,', 'rules.racc', 15)
+  def _reduce_7(val, _values, result)
+     result = [ val[0] ] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 16)
+  def _reduce_8(val, _values, result)
+     result = val[0] + [ val[1] ] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 18)
+  def _reduce_9(val, _values, result)
+     result = Fabulator::Grammar::Expr::RuleMode.new(val[2]) 
+    result
+  end
+.,.,
+
+# reduce 10 omitted
+
+# reduce 11 omitted
+
+# reduce 12 omitted
+
+module_eval(<<'.,.,', 'rules.racc', 22)
+  def _reduce_13(val, _values, result)
+     result = Fabulator::Grammar::Expr::SetSkip.new(val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 23)
+  def _reduce_14(val, _values, result)
+     result = Fabulator::Grammar::Expr::Resync.new(val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 24)
+  def _reduce_15(val, _values, result)
+     result = Fabulator::Grammar::Expr::LookAhead.new(val[1]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 25)
+  def _reduce_16(val, _values, result)
+     result = Fabulator::Grammar::Expr::NegLookAhead.new(val[1]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 26)
+  def _reduce_17(val, _values, result)
+     result = Fabulator::Grammar::Expr::Anchor.new(:start_of_line) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 27)
+  def _reduce_18(val, _values, result)
+     result = Fabulator::Grammar::Expr::Anchor.new(:start_of_string) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 28)
+  def _reduce_19(val, _values, result)
+     result = Fabulator::Grammar::Expr::Anchor.new(:end_of_line) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 29)
+  def _reduce_20(val, _values, result)
+     result = Fabulator::Grammar::Expr::Anchor.new(:end_of_string) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 31)
+  def _reduce_21(val, _values, result)
+     result = Fabulator::Grammar::Expr::RuleSequence.new(nil, val[0], val[1]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 32)
+  def _reduce_22(val, _values, result)
+     result = Fabulator::Grammar::Expr::RuleSequence.new(nil, val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 33)
+  def _reduce_23(val, _values, result)
+     result = Fabulator::Grammar::Expr::RuleSequence.new(val[0], val[1], val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 34)
+  def _reduce_24(val, _values, result)
+     result = Fabulator::Grammar::Expr::RuleSequence.new(val[0], val[1]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 36)
+  def _reduce_25(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 44)
+  def _reduce_26(val, _values, result)
+     result = [ '?'.to_sym ] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 45)
+  def _reduce_27(val, _values, result)
+     result = [ :s, val[2] ] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 46)
+  def _reduce_28(val, _values, result)
+     result = [ 's?'.to_sym, val[3] ] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 47)
+  def _reduce_29(val, _values, result)
+     result = [ :count, val[1], val[2] ] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 48)
+  def _reduce_30(val, _values, result)
+     result = [ :range, [ val[1], val[3] ], val[4] ] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 49)
+  def _reduce_31(val, _values, result)
+     result = [ :upto, val[2], val[3] ] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 50)
+  def _reduce_32(val, _values, result)
+     result = [ :atleast, val[1],val[3] ] 
+    result
+  end
+.,.,
+
+# reduce 33 omitted
+
+# reduce 34 omitted
+
+module_eval(<<'.,.,', 'rules.racc', 55)
+  def _reduce_35(val, _values, result)
+     result = Fabulator::Grammar::Expr::Text.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 56)
+  def _reduce_36(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'rules.racc', 57)
+  def _reduce_37(val, _values, result)
+     result = Fabulator::Grammar::Expr::RuleRef.new(val[0]) 
+    result
+  end
+.,.,
+
+# reduce 38 omitted
+
+# reduce 39 omitted
+
+# reduce 40 omitted
+
+# reduce 41 omitted
+
+# reduce 42 omitted
+
+# reduce 43 omitted
+
+# reduce 44 omitted
+
+# reduce 45 omitted
+
+# reduce 46 omitted
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+    end   # class RuleParser
+    end   # module Grammar
+  end   # module Fabulator