predicator 0.4.0 → 1.0.0

data/lib/predicator/lexer.rex

@@ -0,0 +1,51 @@
+class Predicator::Lexer
+options
+  lineno
+  column
+macro
+  SPACE       /[ \t\r\n]/
+  LPAREN      /\(/
+  RPAREN      /\)/
+  LBRACKET    /\[/
+  RBRACKET    /\]/
+  TRUE        /true\b/
+  FALSE       /false\b/
+  BETWEEN     /between\b/
+  IN          /in\b/
+  BANG        /!/
+  NOT         /not\b/
+  DOT         /\./
+  COMMA       /,/
+  AND         /and\b/
+  OR          /or\b/
+  EQ          /=/
+  GT          />/
+  LT          /</
+  INTEGER     /[+-]?\d(_?\d)*\b/
+  STRING      /(["'])(?:\\?.)*?\1/
+  IDENTIFIER  /[a-z][A-Za-z0-9_]*\b/
+rule
+  /#{SPACE}/       # ignore space
+  /#{LPAREN}/      { [:LPAREN, text] }
+  /#{RPAREN}/      { [:RPAREN, text] }
+  /#{LBRACKET}/    { [:LBRACKET, text] }
+  /#{RBRACKET}/    { [:RBRACKET, text] }
+  /#{TRUE}/        { [:TRUE, text] }
+  /#{FALSE}/       { [:FALSE, text] }
+  /#{BETWEEN}/     { [:BETWEEN, text] }
+  /#{IN}/          { [:IN, text] }
+  /#{BANG}/        { [:BANG, text] }
+  /#{NOT}/         { [:NOT, text] }
+  /#{DOT}/         { [:DOT, text] }
+  /#{COMMA}/       { [:COMMA, text] }
+  /#{AND}/         { [:AND, text] }
+  /#{OR}/          { [:OR, text] }
+  /#{EQ}/          { [:EQ, text] }
+  /#{GT}/          { [:GT, text] }
+  /#{LT}/          { [:LT, text] }
+  /#{INTEGER}/     { [:INTEGER, text] }
+  /#{STRING}/      { [:STRING, text[1...-1]] }
+  /#{IDENTIFIER}/  { [:IDENTIFIER, text] }
+inner
+  def do_parse; end
+end

data/lib/predicator/lexer.rex.rb

@@ -0,0 +1,160 @@
+# encoding: UTF-8
+#--
+# This file is automatically generated. Do not modify it.
+# Generated by: oedipus_lex version 2.5.0.
+# Source: lib/predicator/lexer.rex
+#++
+
+class Predicator::Lexer
+  require 'strscan'
+
+  SPACE      = /[ \t\r\n]/
+  LPAREN     = /\(/
+  RPAREN     = /\)/
+  LBRACKET   = /\[/
+  RBRACKET   = /\]/
+  TRUE       = /true\b/
+  FALSE      = /false\b/
+  BETWEEN    = /between\b/
+  IN         = /in\b/
+  BANG       = /!/
+  NOT        = /not\b/
+  DOT        = /\./
+  COMMA      = /,/
+  AND        = /and\b/
+  OR         = /or\b/
+  EQ         = /=/
+  GT         = />/
+  LT         = /</
+  INTEGER    = /[+-]?\d(_?\d)*\b/
+  STRING     = /(["'])(?:\\?.)*?\1/
+  IDENTIFIER = /[a-z][A-Za-z0-9_]*\b/
+
+  class LexerError < StandardError ; end
+  class ScanError < LexerError ; end
+
+  attr_accessor :lineno
+  attr_accessor :filename
+  attr_accessor :ss
+  attr_accessor :state
+
+  alias :match :ss
+
+  def matches
+    m = (1..9).map { |i| ss[i] }
+    m.pop until m[-1] or m.empty?
+    m
+  end
+
+  def action
+    yield
+  end
+
+  attr_accessor :old_pos
+
+  def column
+    idx = ss.string.rindex("\n", old_pos) || -1
+    old_pos - idx - 1
+  end
+
+  def scanner_class
+    StringScanner
+  end unless instance_methods(false).map(&:to_s).include?("scanner_class")
+
+  def parse str
+    self.ss     = scanner_class.new str
+    self.lineno = 1
+    self.state  ||= nil
+
+    do_parse
+  end
+
+  def parse_file path
+    self.filename = path
+    open path do |f|
+      parse f.read
+    end
+  end
+
+  def location
+    [
+      (filename || "<input>"),
+      lineno,
+      column,
+    ].compact.join(":")
+  end
+
+  def next_token
+
+    token = nil
+
+    until ss.eos? or token do
+      self.lineno += 1 if ss.peek(1) == "\n"
+      self.old_pos = ss.pos
+      token =
+        case state
+        when nil then
+          case
+          when ss.skip(/#{SPACE}/) then
+            # do nothing
+          when text = ss.scan(/#{LPAREN}/) then
+            action { [:LPAREN, text] }
+          when text = ss.scan(/#{RPAREN}/) then
+            action { [:RPAREN, text] }
+          when text = ss.scan(/#{LBRACKET}/) then
+            action { [:LBRACKET, text] }
+          when text = ss.scan(/#{RBRACKET}/) then
+            action { [:RBRACKET, text] }
+          when text = ss.scan(/#{TRUE}/) then
+            action { [:TRUE, text] }
+          when text = ss.scan(/#{FALSE}/) then
+            action { [:FALSE, text] }
+          when text = ss.scan(/#{BETWEEN}/) then
+            action { [:BETWEEN, text] }
+          when text = ss.scan(/#{IN}/) then
+            action { [:IN, text] }
+          when text = ss.scan(/#{BANG}/) then
+            action { [:BANG, text] }
+          when text = ss.scan(/#{NOT}/) then
+            action { [:NOT, text] }
+          when text = ss.scan(/#{DOT}/) then
+            action { [:DOT, text] }
+          when text = ss.scan(/#{COMMA}/) then
+            action { [:COMMA, text] }
+          when text = ss.scan(/#{AND}/) then
+            action { [:AND, text] }
+          when text = ss.scan(/#{OR}/) then
+            action { [:OR, text] }
+          when text = ss.scan(/#{EQ}/) then
+            action { [:EQ, text] }
+          when text = ss.scan(/#{GT}/) then
+            action { [:GT, text] }
+          when text = ss.scan(/#{LT}/) then
+            action { [:LT, text] }
+          when text = ss.scan(/#{INTEGER}/) then
+            action { [:INTEGER, text] }
+          when text = ss.scan(/#{STRING}/) then
+            action { [:STRING, text[1...-1]] }
+          when text = ss.scan(/#{IDENTIFIER}/) then
+            action { [:IDENTIFIER, text] }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        else
+          raise ScanError, "undefined state at #{location}: '#{state}'"
+        end # token = case state
+
+      next unless token # allow functions to trigger redo w/ nil
+    end # while
+
+    raise LexerError, "bad lexical result at #{location}: #{token.inspect}" unless
+      token.nil? || (Array === token && token.size >= 2)
+
+    # auto-switch state
+    self.state = token.last if token && token.first == :state
+
+    token
+  end # def next_token
+    def do_parse; end
+end # class

data/lib/predicator/parser.rb

@@ -1,22 +1,306 @@
-require "predicator/generated_parser"
-require "predicator/lexer"
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.14
+# from Racc grammer file "".
+#
 
+require 'racc/parser.rb'
+
+require "predicator/lexer.rex"
+require "predicator/visitors"
+require "predicator/ast"
 module Predicator
-  class Parser < GeneratedParser
-    def next_token
-      @lexer.next_token
+  class Parser < Racc::Parser
+
+    def initialize
+      @lexer = Lexer.new
     end
 
     def parse string
-      @lexer = Lexer.new string
+      @lexer.parse string
       do_parse
     end
 
+    def next_token
+      @lexer.next_token
+    end
+
     def on_error type, val, values
       super
     rescue Racc::ParseError
       trace = values.each_with_index.map{|l, i| "#{' ' * i}#{l}"}
       raise ParseError, "\nparse error on value #{val.inspect}\n#{trace.join("\n")}"
     end
-  end
+
+##### State transition tables begin ###
+
+racc_action_table = [
+     6,     7,    10,     6,     7,    10,     9,    17,    18,     9,
+     6,     7,    10,    46,    17,    18,     9,    47,    14,    13,
+    15,    14,    13,    15,    28,     6,     7,    10,    14,    13,
+    15,     9,     6,     7,    10,    16,    17,    18,     9,    14,
+    13,    15,    31,    14,    13,    15,    32,    39,    17,    18,
+    14,    13,    15,    -7,    17,    18,    14,    13,    -7,    14,
+    13,    15,    27,    19,    14,    13,    -7,    -7,    22,    23,
+    24,    25,    26,    14,    13,    15,    14,    13,    15,    14,
+    13,    15,    40,    19,    41,    39 ]
+
+racc_action_check = [
+     0,     0,     0,     9,     9,     9,     0,    20,    20,     9,
+    10,    10,    10,    42,    29,    29,    10,    42,     0,     0,
+     0,     9,     9,     9,    16,    17,    17,    17,    10,    10,
+    10,    17,    18,    18,    18,     1,    30,    30,    18,    22,
+    22,    22,    19,    17,    17,    17,    21,    26,     1,     1,
+    18,    18,    18,     8,    21,    21,    39,    39,     8,    23,
+    23,    23,    11,     8,    47,    47,     8,     8,    11,    11,
+    11,    11,    11,    24,    24,    24,    25,    25,    25,    41,
+    41,    41,    27,    34,    37,    40 ]
+
+racc_action_pointer = [
+    -2,    35,   nil,   nil,   nil,   nil,   nil,   nil,    53,     1,
+     8,    53,   nil,   nil,   nil,   nil,    24,    23,    30,    20,
+    -6,    41,    19,    39,    53,    56,    41,    63,   nil,     1,
+    23,   nil,   nil,   nil,    73,   nil,   nil,    71,   nil,    36,
+    79,    59,     6,   nil,   nil,   nil,   nil,    44,   nil ]
+
+racc_action_default = [
+   -27,   -27,    -1,    -2,    -3,    -4,    -5,    -6,   -22,   -27,
+   -27,   -27,   -21,   -23,   -24,   -25,   -27,   -27,   -27,   -27,
+    -8,   -27,   -27,   -27,   -27,   -27,   -27,   -27,    49,    -9,
+   -10,   -26,   -11,   -12,   -22,   -13,   -14,   -27,   -16,   -27,
+   -27,   -27,   -27,   -19,   -17,   -15,   -18,   -27,   -20 ]
+
+racc_goto_table = [
+    34,    34,    34,    34,    33,    35,    36,    37,     1,    42,
+    38,   nil,    43,   nil,   nil,   nil,   nil,    20,    21,    34,
+    48,   nil,   nil,    45,    44,    29,    30 ]
+
+racc_goto_check = [
+     6,     6,     6,     6,     7,     7,     7,     7,     1,     9,
+     8,   nil,    10,   nil,   nil,   nil,   nil,     1,     1,     6,
+    10,   nil,   nil,     7,     8,     1,     1 ]
+
+racc_goto_pointer = [
+   nil,     8,   nil,   nil,   nil,   nil,   -22,   -18,   -16,   -30,
+   -27 ]
+
+racc_goto_default = [
+   nil,   nil,     2,     3,     4,     5,     8,    11,   nil,   nil,
+    12 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 24, :_reduce_none,
+  1, 24, :_reduce_none,
+  1, 24, :_reduce_none,
+  1, 24, :_reduce_none,
+  1, 25, :_reduce_5,
+  1, 25, :_reduce_6,
+  1, 25, :_reduce_7,
+  2, 26, :_reduce_8,
+  3, 26, :_reduce_9,
+  3, 26, :_reduce_10,
+  3, 27, :_reduce_11,
+  3, 28, :_reduce_12,
+  3, 28, :_reduce_13,
+  3, 28, :_reduce_14,
+  5, 28, :_reduce_15,
+  3, 28, :_reduce_16,
+  4, 28, :_reduce_17,
+  3, 31, :_reduce_18,
+  1, 32, :_reduce_none,
+  3, 32, :_reduce_20,
+  1, 30, :_reduce_none,
+  1, 30, :_reduce_none,
+  1, 33, :_reduce_23,
+  1, 33, :_reduce_24,
+  1, 29, :_reduce_25,
+  3, 29, :_reduce_26 ]
+
+racc_reduce_n = 27
+
+racc_shift_n = 49
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :TRUE => 2,
+  :FALSE => 3,
+  :LPAREN => 4,
+  :RPAREN => 5,
+  :LBRACKET => 6,
+  :RBRACKET => 7,
+  :BANG => 8,
+  :NOT => 9,
+  :DOT => 10,
+  :COMMA => 11,
+  :AT => 12,
+  :AND => 13,
+  :OR => 14,
+  :EQ => 15,
+  :GT => 16,
+  :LT => 17,
+  :BETWEEN => 18,
+  :IN => 19,
+  :INTEGER => 20,
+  :STRING => 21,
+  :IDENTIFIER => 22 }
+
+racc_nt_base = 23
+
+racc_use_result_var = false
+
+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",
+  "TRUE",
+  "FALSE",
+  "LPAREN",
+  "RPAREN",
+  "LBRACKET",
+  "RBRACKET",
+  "BANG",
+  "NOT",
+  "DOT",
+  "COMMA",
+  "AT",
+  "AND",
+  "OR",
+  "EQ",
+  "GT",
+  "LT",
+  "BETWEEN",
+  "IN",
+  "INTEGER",
+  "STRING",
+  "IDENTIFIER",
+  "$start",
+  "predicate",
+  "boolean_predicate",
+  "logical_predicate",
+  "group_predicate",
+  "comparison_predicate",
+  "variable",
+  "value",
+  "array",
+  "array_contents",
+  "literal" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+# reduce 2 omitted
+
+# reduce 3 omitted
+
+# reduce 4 omitted
+
+def _reduce_5(val, _values)
+ AST::True.new true 
 end
+
+def _reduce_6(val, _values)
+ AST::False.new false 
+end
+
+def _reduce_7(val, _values)
+ AST::BooleanVariable.new val.first 
+end
+
+def _reduce_8(val, _values)
+ AST::Not.new val.last 
+end
+
+def _reduce_9(val, _values)
+ AST::And.new val.first, val.last 
+end
+
+def _reduce_10(val, _values)
+ AST::Or.new val.first, val.last 
+end
+
+def _reduce_11(val, _values)
+ AST::Group.new val[1] 
+end
+
+def _reduce_12(val, _values)
+ AST::Equal.new val.first, val.last 
+end
+
+def _reduce_13(val, _values)
+ AST::GreaterThan.new val.first, val.last 
+end
+
+def _reduce_14(val, _values)
+ AST::LessThan.new val.first, val.last 
+end
+
+def _reduce_15(val, _values)
+ AST::Between.new val.first, val[2], val.last 
+end
+
+def _reduce_16(val, _values)
+ AST::In.new val.first, val.last 
+end
+
+def _reduce_17(val, _values)
+ AST::NotIn.new val.first, val.last 
+end
+
+def _reduce_18(val, _values)
+ AST::Array.new val[1] 
+end
+
+# reduce 19 omitted
+
+def _reduce_20(val, _values)
+ [val.first, val.last].flatten 
+end
+
+# reduce 21 omitted
+
+# reduce 22 omitted
+
+def _reduce_23(val, _values)
+ AST::String.new val.first 
+end
+
+def _reduce_24(val, _values)
+ AST::Integer.new val.first.to_i 
+end
+
+def _reduce_25(val, _values)
+ AST::Variable.new val.first 
+end
+
+def _reduce_26(val, _values)
+ AST::Variable.new [val.first, val.last].flatten.join(".") 
+end
+
+def _reduce_none(val, _values)
+  val[0]
+end
+
+  end   # class Parser
+  end   # module Predicator