joshbuddy-esi_attribute_langague 0.0.1

data/Rakefile

@@ -0,0 +1,35 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "esi_attribute_langague"
+    s.description = s.summary = "ESI Attribute Language"
+    s.email = "joshbuddy@gmail.com"
+    s.homepage = "http://github.com/joshbuddy/esi_attribute_language"
+    s.authors = ["Joshua Hull"]
+    s.files = FileList["[A-Z]*", "{lib,spec}/**/*"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc "Build it up"
+task :build do
+  sh "rex --independent -o lib/esi_attribute_language/grammar/grammar.rex.rb lib/esi_attribute_language/grammar/grammar.rex"
+  sh "racc -v -O parser.output -o lib/esi_attribute_language/grammar/grammar.y.rb lib/esi_attribute_language/grammar/grammar.y"
+  sh "rex --independent -o lib/esi_attribute_language/grammar/simple.rex.rb lib/esi_attribute_language/grammar/simple.rex"
+  sh "racc -v -O parser.output -o lib/esi_attribute_language/grammar/simple.y.rb lib/esi_attribute_language/grammar/simple.y"
+end
+
+require 'spec'
+require 'spec/rake/spectask'
+
+task :spec => 'spec:all'
+namespace(:spec) do
+  Spec::Rake::SpecTask.new(:all) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/*.rb']
+  end
+
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/esi_attribute_language.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), 'esi_attribute_language', 'grammar')
+
+module EsiAttributeLanguage
+
+  class VariableLookup
+    def initialize(variable_name)
+      @variable_name = variable_name.to_sym
+    end
+    
+    def execute(context)
+      context[@variable_name]
+    end
+  end
+
+  class Node
+    def self.cleanse_string(string)
+      if string[0] == ?' && string[-1] == ?'
+        string[1, string.size - 2].gsub('\\\'', '\'')
+      else
+        string
+      end
+    end
+    
+    def result_single(var, context)
+      var.respond_to?(:execute) ? var.execute(context) : var
+    end
+
+    def result(var, context)
+      var.is_a?(Array) ? var.map{|v| result_single(v, context)} : result_single(var, context)
+    end
+  end
+  
+  class ConcatNode < Node
+    def initialize(*parts)
+      @parts = parts
+    end
+    
+    def execute(context)
+      result(@parts, context).join('')
+    end
+  end
+  
+  class HashLookupNode < Node
+    def initialize(variable, key)
+      
+      @variable = variable
+      @key = key
+    end
+    
+    def execute(context)
+      case var = result(@variable, context)
+      when Hash
+        var[result(@key, context)]
+      when Set
+        var.include?(result(@key, context))
+      end
+    end
+  end
+  
+  class OrNode < Node
+    def initialize(lval, rval)
+      @lval = lval
+      @rval = rval
+    end
+    
+    def execute(context)
+      result(@lval, context) || result(@rval, context)
+    end
+    
+  end
+
+  class DummyNode < Node
+    def initialize(lit)
+      @lit = lit
+    end
+    
+    def execute(context)
+      @lit
+    end
+  end
+
+  class MethodNode < Node
+    def initialize(receiver, op, *args)
+      @receiver = receiver
+      @op = op
+      @args = args
+    end
+
+    def execute(context)
+      result(@receiver, context).send(@op, *result(@args, context))
+    end
+  end
+
+end

data/lib/esi_attribute_language/grammar.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), 'grammar', 'grammar.y')
+require File.join(File.dirname(__FILE__), 'grammar', 'grammar.rex')
+require File.join(File.dirname(__FILE__), 'grammar', 'simple.y')
+require File.join(File.dirname(__FILE__), 'grammar', 'simple.rex')
+
+module EsiAttributeLanguage
+
+  ParseError = Class.new(Exception)
+
+  class SimpleGrammar
+    attr_reader :rules
+
+    def self.parse(source)
+      result = SimpleGrammarParser.new.scan_str(source)
+      result.respond_to?(:execute) ? result : DummyNode.new(result)
+    rescue Racc::ParseError => e
+      raise ParseError, e.message
+    end
+
+    def initialize(rules)
+      @root  = rules.first.name
+      @rules = {}
+      rules.each { |r| @rules[r.name] = r }
+    end
+
+    def parse(string)
+      index = @rules[@root].call(string, 0, @rules)
+      index if index == string.length
+    end
+  end
+
+  class Grammar
+
+    attr_reader :rules
+
+    def self.parse(source)
+      result = GrammarParser.new.scan_str(source)
+      result.respond_to?(:execute) ? result : DummyNode.new(result)
+    rescue Racc::ParseError => e
+      raise ParseError, e.message
+    end
+
+    def initialize(rules)
+      @root  = rules.first.name
+      @rules = {}
+      rules.each { |r| @rules[r.name] = r }
+    end
+
+    def parse(string)
+      index = @rules[@root].call(string, 0, @rules)
+      index if index == string.length
+    end
+
+  end
+  
+end

data/lib/esi_attribute_language/grammar/grammar.rex

@@ -0,0 +1,33 @@
+class EsiAttributeLanguage::GrammarParser
+
+rule
+  '(\\'|[^'])*'	      { [:STRING,   text] }
+  ==                  { [:EQ,       text] }
+  !=                  { [:NE,       text] }
+  <=                  { [:LTE,      text] }
+  >=                  { [:GTE,      text] }
+  <                   { [:LT,       text] }
+  >                   { [:GT,       text] }
+  \$                  { [:DOLLAR,   text] }
+  \|                  { [:PIPE,     text] }
+  \[                  { [:LSQUARE,  text] }
+  \]                  { [:RSQUARE,  text] }
+  \{                  { [:LBRACE,   text] }
+  \}                  { [:RBRACE,   text] }
+  \(                  { [:LPAREN,   text] }
+  \)                  { [:RPAREN,   text] }
+  \\                  { [:BSLASH,   text] }
+  \+                  { [:PLUS,     text] }
+  \*                  { [:STAR,     text] }
+  \/                  { [:SLASH,    text] }
+  \'                  { [:QUOTE,    text] }
+  \?                  { [:QMARK,    text] }
+  \.                  { [:DOT,      text] }
+  \^                  { [:CARROT,   text] }
+  \-                  { [:MINUS,    text] }
+  &                   { [:AMP,      text] }
+  !                   { [:BANG,     text] }
+  [0-9]+              { [:NUMBER,   text] }
+  [A-Za-z_-]+         { [:VARIABLE, text] }
+  .                   nil
+end

data/lib/esi_attribute_language/grammar/grammar.rex.rb

@@ -0,0 +1,154 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.3
+# from lexical definition file "lib/esi_attribute_language/grammar/grammar.rex".
+#++
+
+module EsiAttributeLanguage
+class GrammarParser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader :lineno
+  attr_reader :filename
+
+  def scan_setup ; end
+
+  def action &block
+    yield
+  end
+
+  def scan_str( str )
+    scan_evaluate  str
+    do_parse
+  end
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_evaluate  f.read
+    end
+  end
+
+  def scan_file( filename )
+    load_file  filename
+    do_parse
+  end
+
+  def next_token
+    @rex_tokens.shift
+  end
+
+  def scan_evaluate( str )
+    scan_setup
+    @rex_tokens = []
+    @lineno  =  1
+    ss = StringScanner.new(str)
+    state = nil
+    until ss.eos?
+      text = ss.peek(1)
+      @lineno  +=  1  if text == "\n"
+      case state
+      when nil
+        case
+        when (text = ss.scan(/'(\\'|[^'])*'/))
+           @rex_tokens.push action { [:STRING,   text] }
+
+        when (text = ss.scan(/==/))
+           @rex_tokens.push action { [:EQ,       text] }
+
+        when (text = ss.scan(/!=/))
+           @rex_tokens.push action { [:NE,       text] }
+
+        when (text = ss.scan(/<=/))
+           @rex_tokens.push action { [:LTE,      text] }
+
+        when (text = ss.scan(/>=/))
+           @rex_tokens.push action { [:GTE,      text] }
+
+        when (text = ss.scan(/</))
+           @rex_tokens.push action { [:LT,       text] }
+
+        when (text = ss.scan(/>/))
+           @rex_tokens.push action { [:GT,       text] }
+
+        when (text = ss.scan(/\$/))
+           @rex_tokens.push action { [:DOLLAR,   text] }
+
+        when (text = ss.scan(/\|/))
+           @rex_tokens.push action { [:PIPE,     text] }
+
+        when (text = ss.scan(/\[/))
+           @rex_tokens.push action { [:LSQUARE,  text] }
+
+        when (text = ss.scan(/\]/))
+           @rex_tokens.push action { [:RSQUARE,  text] }
+
+        when (text = ss.scan(/\{/))
+           @rex_tokens.push action { [:LBRACE,   text] }
+
+        when (text = ss.scan(/\}/))
+           @rex_tokens.push action { [:RBRACE,   text] }
+
+        when (text = ss.scan(/\(/))
+           @rex_tokens.push action { [:LPAREN,   text] }
+
+        when (text = ss.scan(/\)/))
+           @rex_tokens.push action { [:RPAREN,   text] }
+
+        when (text = ss.scan(/\\/))
+           @rex_tokens.push action { [:BSLASH,   text] }
+
+        when (text = ss.scan(/\+/))
+           @rex_tokens.push action { [:PLUS,     text] }
+
+        when (text = ss.scan(/\*/))
+           @rex_tokens.push action { [:STAR,     text] }
+
+        when (text = ss.scan(/\//))
+           @rex_tokens.push action { [:SLASH,    text] }
+
+        when (text = ss.scan(/\'/))
+           @rex_tokens.push action { [:QUOTE,    text] }
+
+        when (text = ss.scan(/\?/))
+           @rex_tokens.push action { [:QMARK,    text] }
+
+        when (text = ss.scan(/\./))
+           @rex_tokens.push action { [:DOT,      text] }
+
+        when (text = ss.scan(/\^/))
+           @rex_tokens.push action { [:CARROT,   text] }
+
+        when (text = ss.scan(/\-/))
+           @rex_tokens.push action { [:MINUS,    text] }
+
+        when (text = ss.scan(/&/))
+           @rex_tokens.push action { [:AMP,      text] }
+
+        when (text = ss.scan(/!/))
+           @rex_tokens.push action { [:BANG,     text] }
+
+        when (text = ss.scan(/[0-9]+/))
+           @rex_tokens.push action { [:NUMBER,   text] }
+
+        when (text = ss.scan(/[A-Za-z_-]+/))
+           @rex_tokens.push action { [:VARIABLE, text] }
+
+        when (text = ss.scan(/./))
+          ;
+
+        else
+          text = ss.string[ss.pos .. -1]
+          raise  ScanError, "can not match: '" + text + "'"
+        end  # if
+
+      else
+        raise  ScanError, "undefined state: '" + state.to_s + "'"
+      end  # case state
+    end  # until ss
+  end  # def scan_evaluate
+
+end # class
+end # module

data/lib/esi_attribute_language/grammar/grammar.y

@@ -0,0 +1,39 @@
+class EsiAttributeLanguage::GrammarParser
+
+token DOLLAR LSQUARE RSQUARE LPAREN RPAREN LBRACE RBRACE BSLASH PIPE
+token PLUS NUMBER MINUS STAR SLASH VARIABLE STRING EQ NE LTE GTE LT GT BANG AMP
+
+rule
+  expression:
+      NUMBER                             { result = Integer(val[0]) }
+    | STRING                             { result = Node.cleanse_string(val[0]) }
+    | expression EQ expression           { result = MethodNode.new(val[0], :'==', val[2]) }
+    | expression NE expression           { result = MethodNode.new(MethodNode.new(val[0], :'==', val[2]), :'^', true) }
+    | expression LTE expression          { result = MethodNode.new(val[0], :'<=', val[2]) }
+    | expression GTE expression          { result = MethodNode.new(val[0], :'>=', val[2]) }
+    | expression LT expression           { result = MethodNode.new(val[0], :'<' , val[2]) }
+    | expression GT expression           { result = MethodNode.new(val[0], :'>' , val[2]) }
+    | expression AMP expression          { result = MethodNode.new(val[0], :'&' , val[2]) }
+    | expression PIPE expression         { result = MethodNode.new(val[0], :'|' , val[2]) }
+    | expression PLUS expression         { result = MethodNode.new(val[0], :+   , val[2]) }
+    | expression MINUS expression        { result = MethodNode.new(val[0], :-   , val[2]) }
+    | expression STAR expression         { result = MethodNode.new(val[0], :'*' , val[2]) }
+    | expression SLASH expression        { result = MethodNode.new(val[0], :'/' , val[2]) }
+    | BANG expression                    { result = MethodNode.new(val[1], :'^', true) }
+    | LPAREN expression RPAREN           { result = val[1] }
+    | DOLLAR LPAREN variable RPAREN      { result = val[2] } # $(...)
+    ;
+  
+  variable:
+      STRING                             { result = Node.cleanse_string(val[0]) }
+    | variable PIPE variable             { result = OrNode.new(val[0], val[2]) }
+    | variable LBRACE hash_lookup RBRACE { result = HashLookupNode.new(val[0], val[2]) }
+    | VARIABLE                           { result = VariableLookup.new(val[0]) }
+    ;
+  
+  hash_lookup:
+      STRING                             { result = Node.cleanse_string(val[0]) }
+    | VARIABLE                           { result = val[0] }
+    ;
+
+end

data/lib/esi_attribute_language/grammar/grammar.y.rb

@@ -0,0 +1,398 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+module EsiAttributeLanguage
+  class GrammarParser < Racc::Parser
+##### State transition tables begin ###
+
+racc_action_table = [
+    12,     7,     2,    40,    41,     4,    41,    42,    47,    42,
+    21,    10,     1,    14,    15,    17,    29,     6,    18,    19,
+    20,    22,    11,    13,     3,    16,     2,     2,     2,     4,
+     4,     4,    23,    24,    23,    24,     1,     1,     1,    43,
+    44,     6,     6,     6,     2,   nil,   nil,     4,     3,     3,
+     3,   nil,     2,     2,     1,     4,     4,   nil,   nil,     6,
+   nil,     2,     1,     1,     4,   nil,     3,     6,     6,     2,
+     2,     1,     4,     4,     3,     3,     6,   nil,     2,     1,
+     1,     4,   nil,     3,     6,     6,     2,     2,     1,     4,
+     4,     3,     3,     6,   nil,     2,     1,     1,     4,   nil,
+     3,     6,     6,     2,   nil,     1,     4,    26,     3,     3,
+     6,    21,    10,     1,    14,    15,    17,     3,     6,    18,
+    19,    20,    22,    11,    13,     3,    16,    21,    10,   nil,
+    14,    15,    17,   nil,   nil,    18,    19,    20,    22,    11,
+    13,   nil,    16,    21,    10,   nil,    14,    15,    17,   nil,
+   nil,    18,    19,    20,    22,    11,    13,   nil,    16,    21,
+    10,   nil,    14,    15,    17,   nil,   nil,    18,    19,    20,
+    22,    11,    13,   nil,    16,    21,    10,   nil,    14,    15,
+    17,   nil,   nil,    18,    19,    20,    22,    11,    13,   nil,
+    16,    21,    10,   nil,    14,    15,    17,   nil,   nil,    18,
+    19,    20,    22,    11,    13,   nil,    16,    21,    10,   nil,
+    14,    15,    17,   nil,   nil,    18,    19,    20,    22,    11,
+    13,   nil,    16,    21,    10,   nil,    14,    15,    17,   nil,
+   nil,    18,    19,    20,    22,    11,    13,   nil,    16,    21,
+    10,   nil,    14,    15,    17,   nil,   nil,    18,    19,    20,
+    22,    11,    13,   nil,    16,    21,    10,   nil,    14,    15,
+    17,   nil,   nil,    18,    19,    20,    22,    11,    13,   nil,
+    16,    21,    10,   nil,    14,    15,    17,   nil,   nil,    18,
+    19,    20,    22,    11,    13,   nil,    16,    21,    10,   nil,
+    14,    15,    17,   nil,   nil,    18,    19,    20,    22,    11,
+    13,   nil,    16,    21,    10,   nil,    14,    15,    17,   nil,
+   nil,    18,    19,    20,    22,    11,    13,   nil,    16,    21,
+    10,   nil,    14,    15,    17,   nil,   nil,    18,    19,    20,
+    22,    11,    13,   nil,    16 ]
+
+racc_action_check = [
+     5,     2,    19,    25,    25,    19,    46,    25,    45,    46,
+     5,     5,    19,     5,     5,     5,    12,    19,     5,     5,
+     5,     5,     5,     5,    19,     5,     3,     4,     0,     3,
+     4,     0,    42,    42,     7,     7,     3,     4,     0,    41,
+    41,     3,     4,     0,    17,   nil,   nil,    17,     3,     4,
+     0,   nil,    20,    22,    17,    20,    22,   nil,   nil,    17,
+   nil,    10,    20,    22,    10,   nil,    17,    20,    22,    11,
+    18,    10,    11,    18,    20,    22,    10,   nil,    13,    11,
+    18,    13,   nil,    10,    11,    18,    14,    15,    13,    14,
+    15,    11,    18,    13,   nil,    16,    14,    15,    16,   nil,
+    13,    14,    15,    21,   nil,    16,    21,     9,    14,    15,
+    16,     9,     9,    21,     9,     9,     9,    16,    21,     9,
+     9,     9,     9,     9,     9,    21,     9,    28,    28,   nil,
+    28,    28,    28,   nil,   nil,    28,    28,    28,    28,    28,
+    28,   nil,    28,     8,     8,   nil,     8,     8,     8,   nil,
+   nil,     8,     8,     8,     8,     8,     8,   nil,     8,    39,
+    39,   nil,    39,    39,    39,   nil,   nil,    39,    39,    39,
+    39,    39,    39,   nil,    39,    38,    38,   nil,    38,    38,
+    38,   nil,   nil,    38,    38,    38,    38,    38,    38,   nil,
+    38,    36,    36,   nil,    36,    36,    36,   nil,   nil,    36,
+    36,    36,    36,    36,    36,   nil,    36,    27,    27,   nil,
+    27,    27,    27,   nil,   nil,    27,    27,    27,    27,    27,
+    27,   nil,    27,    33,    33,   nil,    33,    33,    33,   nil,
+   nil,    33,    33,    33,    33,    33,    33,   nil,    33,    35,
+    35,   nil,    35,    35,    35,   nil,   nil,    35,    35,    35,
+    35,    35,    35,   nil,    35,    31,    31,   nil,    31,    31,
+    31,   nil,   nil,    31,    31,    31,    31,    31,    31,   nil,
+    31,    32,    32,   nil,    32,    32,    32,   nil,   nil,    32,
+    32,    32,    32,    32,    32,   nil,    32,    37,    37,   nil,
+    37,    37,    37,   nil,   nil,    37,    37,    37,    37,    37,
+    37,   nil,    37,    34,    34,   nil,    34,    34,    34,   nil,
+   nil,    34,    34,    34,    34,    34,    34,   nil,    34,    30,
+    30,   nil,    30,    30,    30,   nil,   nil,    30,    30,    30,
+    30,    30,    30,   nil,    30 ]
+
+racc_action_pointer = [
+    26,   nil,    -4,    24,    25,     0,   nil,    18,   133,   101,
+    59,    67,    16,    76,    84,    85,    93,    42,    68,     0,
+    50,   101,    51,   nil,   nil,    -3,   nil,   197,   117,   nil,
+   309,   245,   261,   213,   293,   229,   181,   277,   165,   149,
+   nil,    23,    16,   nil,   nil,     0,    -1,   nil ]
+
+racc_action_default = [
+   -24,    -1,   -24,   -24,   -24,   -24,    -2,   -24,   -15,   -24,
+   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,   -24,
+   -24,   -24,   -24,   -21,   -18,   -24,   -16,   -11,    -7,    48,
+    -8,   -12,   -13,    -9,   -14,    -3,    -4,    -5,   -10,    -6,
+   -17,   -24,   -24,   -23,   -22,   -24,   -19,   -20 ]
+
+racc_goto_table = [
+    25,     5,    45,   nil,     8,     9,   nil,   nil,   nil,   nil,
+   nil,    27,    28,   nil,    30,    31,    32,    33,    34,    35,
+    36,    37,    38,    39,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,    46 ]
+
+racc_goto_check = [
+     2,     1,     3,   nil,     1,     1,   nil,   nil,   nil,   nil,
+   nil,     1,     1,   nil,     1,     1,     1,     1,     1,     1,
+     1,     1,     1,     1,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,     2 ]
+
+racc_goto_pointer = [
+   nil,     1,    -7,   -39 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 27, :_reduce_1,
+  1, 27, :_reduce_2,
+  3, 27, :_reduce_3,
+  3, 27, :_reduce_4,
+  3, 27, :_reduce_5,
+  3, 27, :_reduce_6,
+  3, 27, :_reduce_7,
+  3, 27, :_reduce_8,
+  3, 27, :_reduce_9,
+  3, 27, :_reduce_10,
+  3, 27, :_reduce_11,
+  3, 27, :_reduce_12,
+  3, 27, :_reduce_13,
+  3, 27, :_reduce_14,
+  2, 27, :_reduce_15,
+  3, 27, :_reduce_16,
+  4, 27, :_reduce_17,
+  1, 28, :_reduce_18,
+  3, 28, :_reduce_19,
+  4, 28, :_reduce_20,
+  1, 28, :_reduce_21,
+  1, 29, :_reduce_22,
+  1, 29, :_reduce_23 ]
+
+racc_reduce_n = 24
+
+racc_shift_n = 48
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :DOLLAR => 2,
+  :LSQUARE => 3,
+  :RSQUARE => 4,
+  :LPAREN => 5,
+  :RPAREN => 6,
+  :LBRACE => 7,
+  :RBRACE => 8,
+  :BSLASH => 9,
+  :PIPE => 10,
+  :PLUS => 11,
+  :NUMBER => 12,
+  :MINUS => 13,
+  :STAR => 14,
+  :SLASH => 15,
+  :VARIABLE => 16,
+  :STRING => 17,
+  :EQ => 18,
+  :NE => 19,
+  :LTE => 20,
+  :GTE => 21,
+  :LT => 22,
+  :GT => 23,
+  :BANG => 24,
+  :AMP => 25 }
+
+racc_nt_base = 26
+
+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",
+  "DOLLAR",
+  "LSQUARE",
+  "RSQUARE",
+  "LPAREN",
+  "RPAREN",
+  "LBRACE",
+  "RBRACE",
+  "BSLASH",
+  "PIPE",
+  "PLUS",
+  "NUMBER",
+  "MINUS",
+  "STAR",
+  "SLASH",
+  "VARIABLE",
+  "STRING",
+  "EQ",
+  "NE",
+  "LTE",
+  "GTE",
+  "LT",
+  "GT",
+  "BANG",
+  "AMP",
+  "$start",
+  "expression",
+  "variable",
+  "hash_lookup" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'grammar.y', 7)
+  def _reduce_1(val, _values, result)
+     result = Integer(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 8)
+  def _reduce_2(val, _values, result)
+     result = Node.cleanse_string(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 9)
+  def _reduce_3(val, _values, result)
+     result = MethodNode.new(val[0], :'==', val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 10)
+  def _reduce_4(val, _values, result)
+     result = MethodNode.new(MethodNode.new(val[0], :'==', val[2]), :'^', true) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 11)
+  def _reduce_5(val, _values, result)
+     result = MethodNode.new(val[0], :'<=', val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 12)
+  def _reduce_6(val, _values, result)
+     result = MethodNode.new(val[0], :'>=', val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 13)
+  def _reduce_7(val, _values, result)
+     result = MethodNode.new(val[0], :'<' , val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 14)
+  def _reduce_8(val, _values, result)
+     result = MethodNode.new(val[0], :'>' , val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 15)
+  def _reduce_9(val, _values, result)
+     result = MethodNode.new(val[0], :'&' , val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 16)
+  def _reduce_10(val, _values, result)
+     result = MethodNode.new(val[0], :'|' , val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 17)
+  def _reduce_11(val, _values, result)
+     result = MethodNode.new(val[0], :+   , val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 18)
+  def _reduce_12(val, _values, result)
+     result = MethodNode.new(val[0], :-   , val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 19)
+  def _reduce_13(val, _values, result)
+     result = MethodNode.new(val[0], :'*' , val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 20)
+  def _reduce_14(val, _values, result)
+     result = MethodNode.new(val[0], :'/' , val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 21)
+  def _reduce_15(val, _values, result)
+     result = MethodNode.new(val[1], :'^', true) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 22)
+  def _reduce_16(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 23)
+  def _reduce_17(val, _values, result)
+     result = val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 27)
+  def _reduce_18(val, _values, result)
+     result = Node.cleanse_string(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 28)
+  def _reduce_19(val, _values, result)
+     result = OrNode.new(val[0], val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 29)
+  def _reduce_20(val, _values, result)
+     result = HashLookupNode.new(val[0], val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 30)
+  def _reduce_21(val, _values, result)
+     result = VariableLookup.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 35)
+  def _reduce_22(val, _values, result)
+     result = Node.cleanse_string(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 36)
+  def _reduce_23(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+  end   # class GrammarParser
+  end   # module EsiAttributeLanguage