cadenza 0.7.0.rc1

data/lib/cadenza/nodes/block_node.rb

@@ -0,0 +1,20 @@
+module Cadenza
+  
+   class BlockNode
+      attr_accessor :name, :children
+
+      def initialize(name, children)
+         @name = name
+         @children = children
+      end
+
+      def implied_globals
+         @children.map(&:implied_globals).flatten.uniq
+      end
+
+      def ==(rhs)
+         @name == rhs.name and
+         @children == rhs.children
+      end
+  end
+end

data/lib/cadenza/nodes/boolean_inverse_node.rb

@@ -0,0 +1,17 @@
+module Cadenza
+   class BooleanInverseNode
+      attr_accessor :expression
+
+      def initialize(expression)
+         @expression = expression
+      end
+
+      def ==(rhs)
+         @expression == rhs.expression
+      end
+
+      def eval(context)
+         !@expression.eval(context)
+      end
+   end
+end

data/lib/cadenza/nodes/constant_node.rb

@@ -0,0 +1,21 @@
+module Cadenza
+   class ConstantNode
+      attr_accessor :value
+
+      def initialize(value)
+         @value = value
+      end
+    
+      def implied_globals
+         []
+      end
+
+      def eval(context)
+         @value
+      end
+          
+      def ==(rhs)
+         @value == rhs.value
+      end
+   end
+end

data/lib/cadenza/nodes/document_node.rb

@@ -0,0 +1,27 @@
+module Cadenza
+  class DocumentNode
+    attr_accessor :extends
+    attr_accessor :children
+    attr_accessor :blocks
+    
+    def initialize(children=[])
+      @children = children
+      @blocks = {}
+    end
+
+    def ==(rhs)
+      @children == rhs.children and
+      @extends == rhs.extends and
+      @blocks == rhs.blocks
+    end
+
+    def add_block(block)
+      @blocks[block.name] = block
+    end
+
+    def implied_globals
+      @children.map(&:implied_globals).flatten.uniq
+    end
+
+  end
+end

data/lib/cadenza/nodes/filter_node.rb

@@ -0,0 +1,25 @@
+
+module Cadenza
+   class FilterNode
+      attr_accessor :identifier, :parameters
+
+      def initialize(identifier, parameters=[])
+         @identifier = identifier
+         @parameters = parameters
+      end
+
+      def ==(rhs)
+         @identifier == rhs.identifier and
+         @parameters == rhs.parameters
+      end
+
+      def implied_globals
+         @parameters.map(&:implied_globals).flatten.uniq
+      end
+
+      def evaluate(context, value)
+         params = [value] + @parameters.map {|x| x.eval(context) }
+         context.evaluate_filter(@identifier, params)
+      end
+   end
+end

data/lib/cadenza/nodes/for_node.rb

@@ -0,0 +1,37 @@
+module Cadenza
+  class ForNode
+   attr_accessor :iterator, :iterable, :children
+    
+   MAGIC_LOCALS = %w(forloop.counter forloop.counter0 forloop.first forloop.last)
+
+   def initialize(iterator, iterable, children)
+      @iterator = iterator
+      @iterable = iterable
+      @children = children
+   end
+
+   def implied_globals
+      iterable_globals = @iterable.implied_globals
+      iterator_globals = @iterator.implied_globals
+
+      iterator_regex = Regexp.new("^#{@iterator.identifier}[\.](.+)$")
+
+      all_children_globals = @children.map(&:implied_globals).flatten
+
+      children_globals = all_children_globals.reject {|x| x =~ iterator_regex }
+
+      iterator_children_globals = all_children_globals.select {|x| x =~ iterator_regex }.map do |identifier|
+         "#{iterable.identifier}.#{iterator_regex.match(identifier)[1]}"
+      end
+
+      (iterable_globals | children_globals | iterator_children_globals) - MAGIC_LOCALS - iterator_globals
+   end
+
+   def ==(rhs)
+      @iterator == rhs.iterator and
+      @iterable == rhs.iterable and
+      @children == rhs.children
+   end
+    
+  end
+end

data/lib/cadenza/nodes/generic_block_node.rb

@@ -0,0 +1,21 @@
+ module Cadenza
+   class GenericBlockNode
+      attr_accessor :identifier, :children, :parameters
+
+      def initialize(identifier, children, parameters=[])
+         @identifier = identifier
+         @children = children
+         @parameters = parameters
+      end    
+
+      def implied_globals
+         []
+      end
+    
+      def ==(rhs)
+         @identifier == rhs.identifier and
+         @children == rhs.children and
+         @parameters == rhs.parameters
+      end
+   end
+ end

data/lib/cadenza/nodes/if_node.rb

@@ -0,0 +1,42 @@
+module Cadenza
+  class IfNode
+   attr_accessor :expression, :true_children, :false_children
+
+   def initialize(expression, true_children=[], false_children=[])
+      @expression = expression
+      @true_children = true_children
+      @false_children = false_children
+   end
+
+   def implied_globals
+      (@expression.implied_globals + true_children.map(&:implied_globals).flatten + false_children.map(&:implied_globals).flatten).uniq
+   end
+
+   def evaluate_expression_for_children(context)
+      value = @expression.eval(context)
+
+      if value == true
+         return @true_children
+
+      elsif value == false
+         return @false_children
+
+      elsif value.is_a?(String)
+         return value.length == 0 || value =~ /\s+/ ? @false_children : @true_children
+
+      elsif value.is_a?(Float) or value.is_a?(Fixnum)
+         return value == 0 ? @false_children : @true_children
+
+      else
+         return !!value ? @true_children : @false_children
+         
+      end
+   end
+
+   def ==(rhs)
+      @expression == rhs.expression and
+      @true_children == rhs.true_children and
+      @false_children == rhs.false_children
+   end
+  end
+end

data/lib/cadenza/nodes/inject_node.rb

@@ -0,0 +1,34 @@
+module Cadenza
+  class InjectNode
+    attr_accessor :value, :filters, :parameters
+    
+    def initialize(value, filters=[], parameters=[])
+      @value = value
+      @filters = filters
+      @parameters = parameters
+    end
+
+    def ==(rhs)
+      self.value == rhs.value and
+      self.filters == rhs.filters and
+      self.parameters == rhs.parameters
+    end
+
+    def implied_globals
+      (@value.implied_globals + @filters.map(&:implied_globals).flatten).uniq
+    end
+
+    def evaluate(context)
+      value = @value.eval(context)
+
+      if value.is_a? Proc
+        args = parameters.map {|p| p.eval(context) }
+        value = value.call(context, *args)
+      end
+
+      @filters.each {|filter| value = filter.evaluate(context, value) }
+
+      value
+    end
+  end
+end

data/lib/cadenza/nodes/operation_node.rb

@@ -0,0 +1,66 @@
+module Cadenza
+  class OperationNode
+      attr_accessor :left, :right, :operator
+
+      def initialize(left, operator, right)
+         @left = left
+         @right = right
+         @operator = operator
+      end
+          
+      def implied_globals
+         @left.implied_globals | @right.implied_globals
+      end
+    
+      def eval(context)
+         l = @left.eval(context)
+         r = @right.eval(context)
+
+         case @operator
+            when '=='
+               return l == r
+
+            when '!='
+               return l != r
+
+            when '>='
+               return l >= r
+
+            when '<='
+               return l <= r
+
+            when '>'
+               return l > r
+
+            when '<'
+               return l < r
+
+            when 'and'
+               return l && r
+
+            when 'or'
+               return l || r
+
+            when '+'
+               return l + r
+
+            when '-'
+               return l - r
+
+            when '*'
+               return l * r
+
+            when '/'
+               return l / r
+
+            else throw "undefined operator: #{@operator}"
+         end
+      end
+
+      def ==(rhs)
+         @operator == rhs.operator and
+         @left == rhs.left and
+         @right == rhs.right
+      end
+  end
+end

data/lib/cadenza/nodes/text_node.rb

@@ -0,0 +1,17 @@
+ module Cadenza
+   class TextNode
+      attr_accessor :text
+
+      def initialize(text)
+         @text = text
+      end    
+
+      def implied_globals
+         []
+      end
+    
+      def ==(rhs)
+         @text == rhs.text
+      end
+   end
+ end

data/lib/cadenza/nodes/variable_node.rb

@@ -0,0 +1,21 @@
+module Cadenza  
+   class VariableNode
+      attr_accessor :identifier
+
+      def initialize(identifier)
+         @identifier = identifier
+      end
+
+      def implied_globals
+         [self.identifier]
+      end
+
+      def eval(context)
+         context.lookup(@identifier)
+      end
+      
+      def ==(rhs)
+         self.identifier == rhs.identifier
+      end
+  end
+end

data/lib/cadenza/parser.rb

@@ -0,0 +1,942 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.7
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+# parser.rb : generated by racc
+  
+module Cadenza
+  class Parser < Racc::Parser
+
+module_eval(<<'...end cadenza.y/module_eval...', 'cadenza.y', 229)
+attr_reader :lexer
+
+def initialize(options={})
+  @lexer = options.fetch(:lexer, Cadenza::Lexer.new)
+
+  raise "Lexers passed to the parser must define next_token" unless @lexer.respond_to?(:next_token)
+
+  raise "Lexers passed to the parser must define source=" unless @lexer.respond_to?(:source=)
+end
+
+def parse(source)
+  @lexer.source = source
+
+  @stack = [DocumentNode.new]
+
+  do_parse
+
+  @stack.first
+end
+
+def push_child(node)
+  @stack.last.children.push(node)
+end
+
+def push_block(block_node)
+  @stack.first.add_block(block_node)
+  push_child(block_node)
+end
+
+def next_token
+  @lexer.next_token
+end
+...end cadenza.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    38,     3,   111,     4,     3,    38,     4,    55,    23,    24,
+    25,    26,     3,    38,   154,    70,    71,     9,    38,    95,
+     9,    70,    71,    31,   115,    34,   118,    35,     9,    38,
+    34,    36,    35,    79,    37,    93,    36,    39,    34,    37,
+    35,   157,    39,    34,    36,    35,    82,    37,    87,    36,
+    39,    38,    37,    93,    34,    39,    35,    82,    83,     3,
+    36,   155,    38,    37,   136,     3,    39,   129,    70,    71,
+    38,    81,    70,    71,    80,     9,    34,   114,    35,    59,
+    60,     9,    36,    38,    91,    37,   141,    34,    39,    35,
+    61,    62,    87,    36,   133,    34,    37,    35,   144,    39,
+     3,    36,    44,     3,    37,   124,   156,    39,    34,    95,
+    35,    97,    83,    96,    36,    91,     9,    37,   128,     9,
+    39,    55,    23,    24,    25,    26,    55,    23,    24,    25,
+    26,    55,    23,    24,    25,    26,   142,    31,   143,   142,
+    77,   149,    31,     3,     3,    40,    40,    31,    55,    23,
+    24,    25,    26,    55,    23,    24,    25,    26,    76,     9,
+     9,     3,   123,     4,    31,     3,     3,     4,     4,    31,
+    22,    23,    24,    25,    26,   122,     3,     9,     4,    61,
+    62,     9,     9,     3,   121,     4,    31,    55,    23,    24,
+    25,    26,     9,    55,    23,    24,    25,    26,     3,     9,
+     4,   120,     3,    31,   137,     3,   117,   134,   116,    31,
+   111,     3,   152,   129,     9,     3,   111,   129,     9,    61,
+    62,     9,    55,    23,    24,    25,    26,     9,     3,    98,
+   124,     9,     3,     3,   124,    44,    61,    62,    31,    70,
+    71,    70,    71,    73,     9,    72,    59,    60,     9,     9,
+    63,    64,    65,    66,    67,    68,    63,    64,    65,    66,
+    67,    68,    55,    23,    24,    25,    26,    55,    23,    24,
+    25,    26,    55,    23,    24,    25,    26,    55,    23,    24,
+    25,    26,    55,    23,    24,    25,    26,    55,    23,    24,
+    25,    26,    55,    23,    24,    25,    26,    55,    23,    24,
+    25,    26,    55,    23,    24,    25,    26,    55,    23,    24,
+    25,    26,    55,    23,    24,    25,    26,    59,    60,    61,
+    62,    61,    62,    61,    62,    54,    95,    51,    48,    18,
+   158,   159 ]
+
+racc_action_check = [
+   137,     0,    97,     0,   145,   155,   145,    38,    38,    38,
+    38,    38,   146,     4,   146,    75,    75,     0,    44,    78,
+   145,    56,    56,    38,    75,   137,    78,   137,   146,    40,
+   155,   137,   155,    38,   137,   137,   155,   137,     4,   155,
+     4,   155,   155,    44,     4,    44,    44,     4,    44,    44,
+     4,   134,    44,    51,    40,    44,    40,    40,    40,   153,
+    40,   153,   129,    40,    93,   131,    40,   131,    74,    74,
+   154,    39,   139,   139,    39,   153,   134,    74,   134,    28,
+    28,   131,   134,   124,   134,   134,   111,   129,   134,   129,
+   108,   108,   129,   129,    91,   154,   129,   154,   116,   129,
+     6,   154,     6,   126,   154,   126,   154,   154,   124,    57,
+   124,    57,   124,    57,   124,    48,     6,   124,    87,   126,
+   124,    26,    26,    26,    26,    26,   141,   141,   141,   141,
+   141,    34,    34,    34,    34,    34,   113,    26,   113,   140,
+    37,   140,   141,     5,    42,     5,    42,    34,    35,    35,
+    35,    35,    35,    22,    22,    22,    22,    22,    36,     5,
+    42,    43,    83,    43,    35,     2,    47,     2,    47,    22,
+     3,     3,     3,     3,     3,    82,   119,    43,   119,    29,
+    29,     2,    47,    50,    81,    50,     3,    70,    70,    70,
+    70,    70,   119,    95,    95,    95,    95,    95,    53,    50,
+    53,    80,    94,    70,    94,    92,    77,    92,    76,    95,
+   142,    90,   144,    90,    53,    89,    73,    89,    94,   107,
+   107,    92,    71,    71,    71,    71,    71,    90,    86,    58,
+    86,    89,    85,    46,    85,    46,   106,   106,    71,    33,
+    33,    58,    58,    33,    86,    33,   101,   101,    85,    46,
+    30,    30,    30,    30,    30,    30,    69,    69,    69,    69,
+    69,    69,    63,    63,    63,    63,    63,    64,    64,    64,
+    64,    64,    65,    65,    65,    65,    65,    59,    59,    59,
+    59,    59,    60,    60,    60,    60,    60,    66,    66,    66,
+    66,    66,    61,    61,    61,    61,    61,    68,    68,    68,
+    68,    68,    31,    31,    31,    31,    31,    67,    67,    67,
+    67,    67,    62,    62,    62,    62,    62,   102,   102,   105,
+   105,   104,   104,   103,   103,    18,   150,     8,     7,     1,
+   156,   157 ]
+
+racc_action_pointer = [
+   -23,   329,   141,   168,    11,   119,    76,   302,   301,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   325,   nil,
+   nil,   nil,   151,   nil,   nil,   nil,   119,   nil,    71,   169,
+   238,   300,   nil,   220,   129,   146,   156,   138,     5,    69,
+    27,   nil,   120,   137,    16,   nil,   209,   142,    80,   nil,
+   159,    16,   nil,   174,   nil,   nil,     2,    88,   222,   275,
+   280,   290,   310,   260,   265,   270,   285,   305,   295,   244,
+   185,   220,   nil,   214,    49,    -4,   174,   178,    -2,   nil,
+   173,   156,   147,   134,   nil,   208,   204,    90,   nil,   191,
+   187,    66,   181,    36,   178,   191,   nil,     0,   nil,   nil,
+   nil,   238,   309,   313,   311,   309,   226,   209,    80,   nil,
+   nil,    64,   nil,   113,   nil,   nil,    96,   nil,   nil,   152,
+   nil,   nil,   nil,   nil,    81,   nil,    79,   nil,   nil,    60,
+   nil,    41,   nil,   nil,    49,   nil,   nil,    -2,   nil,    53,
+   116,   124,   208,   nil,   184,   -20,   -12,   nil,   nil,   nil,
+   305,   nil,   nil,    35,    68,     3,   302,   303,   nil,   nil ]
+
+racc_action_default = [
+    -2,   -79,    -1,   -79,   -79,   -79,   -79,   -54,   -59,   -67,
+   -68,   -69,   -70,   -71,   -72,   -73,   -75,   -77,   -79,   -74,
+   -76,   -78,    -3,    -4,    -5,    -6,   -79,    -8,   -11,   -14,
+   -21,   -79,   -23,   -79,   -79,   -79,   -79,   -79,   -79,   -79,
+   -79,   -41,   -79,   -79,   -79,   -46,   -79,   -79,   -79,   -53,
+   -79,   -79,   -58,   -79,   160,    -3,   -26,   -79,   -79,   -79,
+   -79,   -79,   -79,   -79,   -79,   -79,   -79,   -79,   -79,   -22,
+   -79,   -79,   -32,   -79,   -79,   -79,   -79,   -79,   -79,   -61,
+   -79,   -79,   -79,   -79,   -42,   -79,   -79,   -79,   -47,   -79,
+   -79,   -79,   -79,   -79,   -79,   -79,   -34,   -79,    -7,    -9,
+   -10,   -12,   -13,   -15,   -16,   -17,   -18,   -19,   -20,   -24,
+   -25,   -28,   -30,   -79,   -36,   -37,   -79,   -56,   -63,   -79,
+   -65,   -66,   -38,   -39,   -79,   -44,   -79,   -43,   -40,   -79,
+   -49,   -79,   -48,   -52,   -79,   -55,   -57,   -79,   -60,   -27,
+   -79,   -79,   -79,   -33,   -79,   -79,   -79,   -45,   -50,   -35,
+   -29,   -31,   -51,   -79,   -79,   -79,   -79,   -79,   -62,   -64 ]
+
+racc_goto_table = [
+    19,    21,    41,    45,    33,    43,    47,    57,   113,    52,
+    20,    50,     2,    69,    49,    99,   100,    42,    46,   109,
+   110,   101,   102,    78,    53,   119,   145,    58,   151,     1,
+   nil,   nil,   140,   nil,   nil,    74,    75,   nil,   nil,    84,
+    19,    21,    85,    88,    19,    21,    89,   nil,   nil,   nil,
+    20,   nil,   nil,   nil,    20,    86,   nil,   nil,   nil,    90,
+   nil,   nil,    92,   nil,   nil,    94,   103,   104,   105,   106,
+   107,   108,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   125,   127,    19,    21,   130,   132,    19,    21,
+    19,    21,    19,    21,    20,   138,   139,   126,    20,   135,
+    20,   131,    20,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   147,    19,    21,   150,   nil,   148,    19,
+    21,   146,   nil,   nil,    20,   nil,   nil,   nil,   nil,    20,
+   nil,   nil,   nil,   nil,    19,    21,   nil,   nil,   nil,   nil,
+   nil,    19,    21,   nil,    20,   nil,   nil,   153,   nil,   nil,
+   nil,    20 ]
+
+racc_goto_check = [
+    32,    26,    16,    17,     4,    15,    15,     9,    11,    25,
+    31,    23,     2,     7,    21,     3,     3,     2,     2,     8,
+     8,     5,     5,     9,    27,    29,    30,     4,    10,     1,
+   nil,   nil,    11,   nil,   nil,     4,     4,   nil,   nil,    16,
+    32,    26,    15,    17,    32,    26,    15,   nil,   nil,   nil,
+    31,   nil,   nil,   nil,    31,     2,   nil,   nil,   nil,     2,
+   nil,   nil,     2,   nil,   nil,     2,     6,     6,     6,     6,
+     6,     6,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    16,    16,    32,    26,    17,    17,    32,    26,
+    32,    26,    32,    26,    31,    25,     4,     2,    31,    21,
+    31,     2,    31,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,    16,    32,    26,     9,   nil,    17,    32,
+    26,     2,   nil,   nil,    31,   nil,   nil,   nil,   nil,    31,
+   nil,   nil,   nil,   nil,    32,    26,   nil,   nil,   nil,   nil,
+   nil,    32,    26,   nil,    31,   nil,   nil,     2,   nil,   nil,
+   nil,    31 ]
+
+racc_goto_pointer = [
+   nil,    29,    12,   -44,     1,   -40,     3,   -18,   -51,   -15,
+  -114,   -65,   nil,   nil,   nil,     0,    -3,    -3,   nil,   nil,
+   nil,     7,   nil,     4,   nil,     1,    -1,    16,   nil,   -54,
+   -92,     8,    -2 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,    27,    56,    28,    29,    30,    32,   nil,
+   112,   nil,    10,     5,     6,   nil,   nil,   nil,    11,    12,
+     7,   nil,    13,   nil,     8,   nil,    17,   nil,    14,   nil,
+   nil,    16,    15 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 42, :_reduce_none,
+  0, 42, :_reduce_2,
+  1, 44, :_reduce_3,
+  1, 44, :_reduce_4,
+  1, 44, :_reduce_5,
+  1, 44, :_reduce_6,
+  3, 44, :_reduce_7,
+  1, 46, :_reduce_none,
+  3, 46, :_reduce_9,
+  3, 46, :_reduce_10,
+  1, 47, :_reduce_none,
+  3, 47, :_reduce_12,
+  3, 47, :_reduce_13,
+  1, 48, :_reduce_none,
+  3, 48, :_reduce_15,
+  3, 48, :_reduce_16,
+  3, 48, :_reduce_17,
+  3, 48, :_reduce_18,
+  3, 48, :_reduce_19,
+  3, 48, :_reduce_20,
+  1, 49, :_reduce_none,
+  2, 49, :_reduce_22,
+  1, 45, :_reduce_none,
+  3, 45, :_reduce_24,
+  3, 45, :_reduce_25,
+  1, 50, :_reduce_26,
+  3, 50, :_reduce_27,
+  1, 51, :_reduce_28,
+  3, 51, :_reduce_29,
+  1, 52, :_reduce_30,
+  3, 52, :_reduce_31,
+  3, 53, :_reduce_32,
+  5, 53, :_reduce_33,
+  4, 53, :_reduce_34,
+  6, 53, :_reduce_35,
+  4, 54, :_reduce_36,
+  4, 55, :_reduce_37,
+  3, 56, :_reduce_38,
+  3, 57, :_reduce_none,
+  3, 58, :_reduce_none,
+  2, 59, :_reduce_41,
+  3, 59, :_reduce_42,
+  4, 59, :_reduce_43,
+  4, 59, :_reduce_44,
+  5, 59, :_reduce_45,
+  2, 60, :_reduce_46,
+  3, 60, :_reduce_47,
+  4, 60, :_reduce_48,
+  4, 60, :_reduce_49,
+  5, 60, :_reduce_50,
+  6, 61, :_reduce_51,
+  3, 62, :_reduce_none,
+  2, 63, :_reduce_53,
+  0, 64, :_reduce_54,
+  4, 63, :_reduce_55,
+  4, 65, :_reduce_56,
+  3, 66, :_reduce_none,
+  2, 67, :_reduce_58,
+  0, 68, :_reduce_59,
+  4, 67, :_reduce_60,
+  0, 70, :_reduce_61,
+  8, 69, :_reduce_62,
+  0, 71, :_reduce_63,
+  9, 69, :_reduce_64,
+  4, 72, :_reduce_65,
+  4, 72, :_reduce_66,
+  1, 73, :_reduce_67,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 73, :_reduce_none,
+  1, 43, :_reduce_73,
+  2, 43, :_reduce_74,
+  1, 43, :_reduce_75,
+  2, 43, :_reduce_76,
+  1, 43, :_reduce_77,
+  2, 43, :_reduce_78 ]
+
+racc_reduce_n = 79
+
+racc_shift_n = 160
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :IDENTIFIER => 2,
+  :INTEGER => 3,
+  :REAL => 4,
+  :STRING => 5,
+  "(" => 6,
+  ")" => 7,
+  "*" => 8,
+  "/" => 9,
+  "+" => 10,
+  "-" => 11,
+  :OP_EQ => 12,
+  :OP_NEQ => 13,
+  :OP_LEQ => 14,
+  :OP_GEQ => 15,
+  ">" => 16,
+  "<" => 17,
+  :NOT => 18,
+  :AND => 19,
+  :OR => 20,
+  "," => 21,
+  ":" => 22,
+  "|" => 23,
+  :VAR_OPEN => 24,
+  :VAR_CLOSE => 25,
+  :STMT_OPEN => 26,
+  :IF => 27,
+  :STMT_CLOSE => 28,
+  :UNLESS => 29,
+  :ELSE => 30,
+  :ENDIF => 31,
+  :ENDUNLESS => 32,
+  :FOR => 33,
+  :IN => 34,
+  :ENDFOR => 35,
+  :BLOCK => 36,
+  :ENDBLOCK => 37,
+  :END => 38,
+  :EXTENDS => 39,
+  :TEXT_BLOCK => 40 }
+
+racc_nt_base = 41
+
+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",
+  "IDENTIFIER",
+  "INTEGER",
+  "REAL",
+  "STRING",
+  "\"(\"",
+  "\")\"",
+  "\"*\"",
+  "\"/\"",
+  "\"+\"",
+  "\"-\"",
+  "OP_EQ",
+  "OP_NEQ",
+  "OP_LEQ",
+  "OP_GEQ",
+  "\">\"",
+  "\"<\"",
+  "NOT",
+  "AND",
+  "OR",
+  "\",\"",
+  "\":\"",
+  "\"|\"",
+  "VAR_OPEN",
+  "VAR_CLOSE",
+  "STMT_OPEN",
+  "IF",
+  "STMT_CLOSE",
+  "UNLESS",
+  "ELSE",
+  "ENDIF",
+  "ENDUNLESS",
+  "FOR",
+  "IN",
+  "ENDFOR",
+  "BLOCK",
+  "ENDBLOCK",
+  "END",
+  "EXTENDS",
+  "TEXT_BLOCK",
+  "$start",
+  "target",
+  "document",
+  "primary_expression",
+  "logical_expression",
+  "multiplicative_expression",
+  "additive_expression",
+  "boolean_expression",
+  "inverse_expression",
+  "parameter_list",
+  "filter",
+  "filter_list",
+  "inject_statement",
+  "if_tag",
+  "unless_tag",
+  "else_tag",
+  "end_if_tag",
+  "end_unless_tag",
+  "if_block",
+  "unless_block",
+  "for_tag",
+  "end_for_tag",
+  "for_block",
+  "@1",
+  "block_tag",
+  "end_block_tag",
+  "block_block",
+  "@2",
+  "generic_block",
+  "@3",
+  "@4",
+  "extends_statement",
+  "document_component" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 8)
+  def _reduce_2(val, _values, result)
+     result = nil 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 12)
+  def _reduce_3(val, _values, result)
+     result = VariableNode.new(val[0].value) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 13)
+  def _reduce_4(val, _values, result)
+     result = ConstantNode.new(val[0].value) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 14)
+  def _reduce_5(val, _values, result)
+     result = ConstantNode.new(val[0].value) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 15)
+  def _reduce_6(val, _values, result)
+     result = ConstantNode.new(val[0].value) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 16)
+  def _reduce_7(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+# reduce 8 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 21)
+  def _reduce_9(val, _values, result)
+     result = OperationNode.new(val[0], "*", val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 22)
+  def _reduce_10(val, _values, result)
+     result = OperationNode.new(val[0], "/", val[2]) 
+    result
+  end
+.,.,
+
+# reduce 11 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 27)
+  def _reduce_12(val, _values, result)
+     result = OperationNode.new(val[0], "+", val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 28)
+  def _reduce_13(val, _values, result)
+     result = OperationNode.new(val[0], "-", val[2]) 
+    result
+  end
+.,.,
+
+# reduce 14 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 33)
+  def _reduce_15(val, _values, result)
+     result = OperationNode.new(val[0], "==", val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 34)
+  def _reduce_16(val, _values, result)
+     result = OperationNode.new(val[0], "!=", val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 35)
+  def _reduce_17(val, _values, result)
+     result = OperationNode.new(val[0], "<=", val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 36)
+  def _reduce_18(val, _values, result)
+     result = OperationNode.new(val[0], ">=", val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 37)
+  def _reduce_19(val, _values, result)
+     result = OperationNode.new(val[0], ">", val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 38)
+  def _reduce_20(val, _values, result)
+     result = OperationNode.new(val[0], "<", val[2]) 
+    result
+  end
+.,.,
+
+# reduce 21 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 43)
+  def _reduce_22(val, _values, result)
+     result = BooleanInverseNode.new(val[1]) 
+    result
+  end
+.,.,
+
+# reduce 23 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 48)
+  def _reduce_24(val, _values, result)
+     result = OperationNode.new(val[0], "and", val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 49)
+  def _reduce_25(val, _values, result)
+     result = OperationNode.new(val[0], "or", val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 53)
+  def _reduce_26(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 54)
+  def _reduce_27(val, _values, result)
+     result = val[0].push(val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 58)
+  def _reduce_28(val, _values, result)
+     result = FilterNode.new(val[0].value) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 59)
+  def _reduce_29(val, _values, result)
+     result = FilterNode.new(val[0].value, val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 63)
+  def _reduce_30(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 64)
+  def _reduce_31(val, _values, result)
+     result = val[0].push(val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 69)
+  def _reduce_32(val, _values, result)
+     result = InjectNode.new(val[1]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 71)
+  def _reduce_33(val, _values, result)
+     result = InjectNode.new(val[1], val[3]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 74)
+  def _reduce_34(val, _values, result)
+            variable = VariableNode.new(val[1].value)
+        result = InjectNode.new(variable, [], val[2])
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 79)
+  def _reduce_35(val, _values, result)
+            variable = VariableNode.new(val[1].value)
+        result = InjectNode.new(variable, val[4], val[2])
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 87)
+  def _reduce_36(val, _values, result)
+            @stack.push DocumentNode.new
+        result = val[2]
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 95)
+  def _reduce_37(val, _values, result)
+            @stack.push DocumentNode.new
+        result = BooleanInverseNode.new(val[2])
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 101)
+  def _reduce_38(val, _values, result)
+     @stack.push DocumentNode.new 
+    result
+  end
+.,.,
+
+# reduce 39 omitted
+
+# reduce 40 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 113)
+  def _reduce_41(val, _values, result)
+     @stack.pop; result = IfNode.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 114)
+  def _reduce_42(val, _values, result)
+     result = IfNode.new(val[0], @stack.pop.children) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 117)
+  def _reduce_43(val, _values, result)
+            false_children, true_children = @stack.pop.children, @stack.pop.children
+        result = IfNode.new(val[0], true_children, false_children)
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 122)
+  def _reduce_44(val, _values, result)
+            false_children, true_children = @stack.pop.children, @stack.pop.children
+        result = IfNode.new(val[0], true_children, false_children)
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 127)
+  def _reduce_45(val, _values, result)
+            false_children, true_children = @stack.pop.children, @stack.pop.children
+        result = IfNode.new(val[0], true_children, false_children)
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 133)
+  def _reduce_46(val, _values, result)
+     @stack.pop; result = IfNode.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 134)
+  def _reduce_47(val, _values, result)
+     result = IfNode.new(val[0], @stack.pop.children) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 137)
+  def _reduce_48(val, _values, result)
+            false_children, true_children = @stack.pop.children, @stack.pop.children
+        result = IfNode.new(val[0], true_children, false_children)
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 142)
+  def _reduce_49(val, _values, result)
+            false_children, true_children = @stack.pop.children, @stack.pop.children
+        result = IfNode.new(val[0], true_children, false_children)
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 147)
+  def _reduce_50(val, _values, result)
+            false_children, true_children = @stack.pop.children, @stack.pop.children
+        result = IfNode.new(val[0], true_children, false_children)
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 153)
+  def _reduce_51(val, _values, result)
+     result = [val[2].value, val[4].value] 
+    result
+  end
+.,.,
+
+# reduce 52 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 164)
+  def _reduce_53(val, _values, result)
+            iterator = VariableNode.new(val[0][0])
+        iterable = VariableNode.new(val[0][1])
+        
+        result = ForNode.new(iterator, iterable, [])      
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 169)
+  def _reduce_54(val, _values, result)
+     @stack.push DocumentNode.new 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 171)
+  def _reduce_55(val, _values, result)
+            iterator = VariableNode.new(val[0][0])
+        iterable = VariableNode.new(val[0][1])
+        
+        result = ForNode.new(iterator, iterable, @stack.pop.children)
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 179)
+  def _reduce_56(val, _values, result)
+     result = val[2].value 
+    result
+  end
+.,.,
+
+# reduce 57 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 188)
+  def _reduce_58(val, _values, result)
+     result = BlockNode.new(val[0], []) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 189)
+  def _reduce_59(val, _values, result)
+     @stack.push DocumentNode.new 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 189)
+  def _reduce_60(val, _values, result)
+     result = BlockNode.new(val[0], @stack.pop.children) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 193)
+  def _reduce_61(val, _values, result)
+     @stack.push DocumentNode.new 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 195)
+  def _reduce_62(val, _values, result)
+     result = GenericBlockNode.new(val[1].value, @stack.pop.children) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 196)
+  def _reduce_63(val, _values, result)
+     @stack.push DocumentNode.new 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 198)
+  def _reduce_64(val, _values, result)
+     result = GenericBlockNode.new(val[1].value, @stack.pop.children, val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 202)
+  def _reduce_65(val, _values, result)
+     result = val[2].value 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 203)
+  def _reduce_66(val, _values, result)
+     result = VariableNode.new(val[2].value) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 207)
+  def _reduce_67(val, _values, result)
+     result = TextNode.new(val[0].value) 
+    result
+  end
+.,.,
+
+# reduce 68 omitted
+
+# reduce 69 omitted
+
+# reduce 70 omitted
+
+# reduce 71 omitted
+
+# reduce 72 omitted
+
+module_eval(<<'.,.,', 'cadenza.y', 216)
+  def _reduce_73(val, _values, result)
+     push_child val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 217)
+  def _reduce_74(val, _values, result)
+     push_child val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 218)
+  def _reduce_75(val, _values, result)
+     @stack.first.extends = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 219)
+  def _reduce_76(val, _values, result)
+     @stack.first.extends = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 220)
+  def _reduce_77(val, _values, result)
+     push_block(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'cadenza.y', 221)
+  def _reduce_78(val, _values, result)
+     push_block(val[1]) 
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+  end   # class Parser
+  end   # module Cadenza