module Cucumber
module TreetopParser

module Feature
  include Treetop::Runtime

  def root
    @root || :root
  end

  module Root0
    def header
      elements[0]
    end

    def scenarios
      elements[1]
    end
  end

  module Root1
    
    def feature
      f = Tree::Feature.new(header.text_value.strip)
      scenarios.populate(f)
      f
    end
  end

  def _nt_root
    start_index = index
    if node_cache[:root].has_key?(index)
      cached = node_cache[:root][index]
      @index = cached.interval.end if cached
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_header
    s0 << r1
    if r1
      r2 = _nt_scenarios
      s0 << r2
    end
    if s0.last
      r0 = (SyntaxNode).new(input, i0...index, s0)
      r0.extend(Root0)
      r0.extend(Root1)
    else
      self.index = i0
      r0 = nil
    end

    node_cache[:root][start_index] = r0

    return r0
  end

  module Header0
  end

  def _nt_header
    start_index = index
    if node_cache[:header].has_key?(index)
      cached = node_cache[:header][index]
      @index = cached.interval.end if cached
      return cached
    end

    s0, i0 = [], index
    loop do
      i1, s1 = index, []
      i2 = index
      r3 = _nt_step_scenario
      if r3
        r2 = nil
      else
        self.index = i2
        r2 = SyntaxNode.new(input, index...index)
      end
      s1 << r2
      if r2
        if index < input_length
          r4 = (SyntaxNode).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure("any character")
          r4 = nil
        end
        s1 << r4
      end
      if s1.last
        r1 = (SyntaxNode).new(input, i1...index, s1)
        r1.extend(Header0)
      else
        self.index = i1
        r1 = nil
      end
      if r1
        s0 << r1
      else
        break
      end
    end
    r0 = SyntaxNode.new(input, i0...index, s0)

    node_cache[:header][start_index] = r0

    return r0
  end

  module Scenarios0
    def step_scenario
      elements[0]
    end

    def more
      elements[1]
    end
  end

  module Scenarios1
    def populate(feature)
      step_scenario.populate(feature)
      more.elements.each { |m| m.populate(feature) }
    end
  end

  def _nt_scenarios
    start_index = index
    if node_cache[:scenarios].has_key?(index)
      cached = node_cache[:scenarios][index]
      @index = cached.interval.end if cached
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_step_scenario
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        i3 = index
        r4 = _nt_table
        if r4
          r3 = r4
        else
          r5 = _nt_step_scenario
          if r5
            r3 = r5
          else
            self.index = i3
            r3 = nil
          end
        end
        if r3
          s2 << r3
        else
          break
        end
      end
      r2 = SyntaxNode.new(input, i2...index, s2)
      s0 << r2
    end
    if s0.last
      r0 = (SyntaxNode).new(input, i0...index, s0)
      r0.extend(Scenarios0)
      r0.extend(Scenarios1)
    else
      self.index = i0
      r0 = nil
    end

    node_cache[:scenarios][start_index] = r0

    return r0
  end

  module StepScenario0
  end

  module StepScenario1
    def scenario_keyword
      elements[1]
    end

    def name
      elements[4]
    end

    def steps
      elements[6]
    end
  end

  module StepScenario2
    def populate(feature)
      sc = feature.add_scenario(name.text_value)
      steps.elements.each{|s| s.populate(sc)}
      Feature.last_scenario = sc
    end
  end

  def _nt_step_scenario
    start_index = index
    if node_cache[:step_scenario].has_key?(index)
      cached = node_cache[:step_scenario][index]
      @index = cached.interval.end if cached
      return cached
    end

    i0, s0 = index, []
    s1, i1 = [], index
    loop do
      r2 = _nt_whitespace
      if r2
        s1 << r2
      else
        break
      end
    end
    r1 = SyntaxNode.new(input, i1...index, s1)
    s0 << r1
    if r1
      r3 = _nt_scenario_keyword
      s0 << r3
      if r3
        if input.index(":", index) == index
          r4 = (SyntaxNode).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure(":")
          r4 = nil
        end
        s0 << r4
        if r4
          s5, i5 = [], index
          loop do
            r6 = _nt_whitespace
            if r6
              s5 << r6
            else
              break
            end
          end
          r5 = SyntaxNode.new(input, i5...index, s5)
          s0 << r5
          if r5
            s7, i7 = [], index
            loop do
              i8, s8 = index, []
              i9 = index
              r10 = _nt_newline
              if r10
                r9 = nil
              else
                self.index = i9
                r9 = SyntaxNode.new(input, index...index)
              end
              s8 << r9
              if r9
                if index < input_length
                  r11 = (SyntaxNode).new(input, index...(index + 1))
                  @index += 1
                else
                  terminal_parse_failure("any character")
                  r11 = nil
                end
                s8 << r11
              end
              if s8.last
                r8 = (SyntaxNode).new(input, i8...index, s8)
                r8.extend(StepScenario0)
              else
                self.index = i8
                r8 = nil
              end
              if r8
                s7 << r8
              else
                break
              end
            end
            r7 = SyntaxNode.new(input, i7...index, s7)
            s0 << r7
            if r7
              s12, i12 = [], index
              loop do
                r13 = _nt_newline
                if r13
                  s12 << r13
                else
                  break
                end
              end
              r12 = SyntaxNode.new(input, i12...index, s12)
              s0 << r12
              if r12
                s14, i14 = [], index
                loop do
                  r15 = _nt_step
                  if r15
                    s14 << r15
                  else
                    break
                  end
                end
                if s14.empty?
                  self.index = i14
                  r14 = nil
                else
                  r14 = SyntaxNode.new(input, i14...index, s14)
                end
                s0 << r14
              end
            end
          end
        end
      end
    end
    if s0.last
      r0 = (SyntaxNode).new(input, i0...index, s0)
      r0.extend(StepScenario1)
      r0.extend(StepScenario2)
    else
      self.index = i0
      r0 = nil
    end

    node_cache[:step_scenario][start_index] = r0

    return r0
  end

  module Step0
  end

  module Step1
    def step_keyword
      elements[1]
    end

    def name
      elements[3]
    end

  end

  module Step2
    def populate(scenario)
      line = input.line_of(interval.first)
      scenario.add_step(step_keyword.text_value, name.text_value, line)
    end
  end

  def _nt_step
    start_index = index
    if node_cache[:step].has_key?(index)
      cached = node_cache[:step][index]
      @index = cached.interval.end if cached
      return cached
    end

    i0, s0 = index, []
    s1, i1 = [], index
    loop do
      r2 = _nt_whitespace
      if r2
        s1 << r2
      else
        break
      end
    end
    r1 = SyntaxNode.new(input, i1...index, s1)
    s0 << r1
    if r1
      r3 = _nt_step_keyword
      s0 << r3
      if r3
        s4, i4 = [], index
        loop do
          r5 = _nt_whitespace
          if r5
            s4 << r5
          else
            break
          end
        end
        r4 = SyntaxNode.new(input, i4...index, s4)
        s0 << r4
        if r4
          s6, i6 = [], index
          loop do
            i7, s7 = index, []
            i8 = index
            r9 = _nt_newline
            if r9
              r8 = nil
            else
              self.index = i8
              r8 = SyntaxNode.new(input, index...index)
            end
            s7 << r8
            if r8
              if index < input_length
                r10 = (SyntaxNode).new(input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure("any character")
                r10 = nil
              end
              s7 << r10
            end
            if s7.last
              r7 = (SyntaxNode).new(input, i7...index, s7)
              r7.extend(Step0)
            else
              self.index = i7
              r7 = nil
            end
            if r7
              s6 << r7
            else
              break
            end
          end
          r6 = SyntaxNode.new(input, i6...index, s6)
          s0 << r6
          if r6
            s11, i11 = [], index
            loop do
              r12 = _nt_newline
              if r12
                s11 << r12
              else
                break
              end
            end
            r11 = SyntaxNode.new(input, i11...index, s11)
            s0 << r11
          end
        end
      end
    end
    if s0.last
      r0 = (SyntaxNode).new(input, i0...index, s0)
      r0.extend(Step1)
      r0.extend(Step2)
    else
      self.index = i0
      r0 = nil
    end

    node_cache[:step][start_index] = r0

    return r0
  end

  def _nt_step_keyword
    start_index = index
    if node_cache[:step_keyword].has_key?(index)
      cached = node_cache[:step_keyword][index]
      @index = cached.interval.end if cached
      return cached
    end

    i0 = index
    if input.index('Dado', index) == index
      r1 = (SyntaxNode).new(input, index...(index + 4))
      @index += 4
    else
      terminal_parse_failure('Dado')
      r1 = nil
    end
    if r1
      r0 = r1
    else
      if input.index('Cuando', index) == index
        r2 = (SyntaxNode).new(input, index...(index + 6))
        @index += 6
      else
        terminal_parse_failure('Cuando')
        r2 = nil
      end
      if r2
        r0 = r2
      else
        if input.index('Entonces', index) == index
          r3 = (SyntaxNode).new(input, index...(index + 8))
          @index += 8
        else
          terminal_parse_failure('Entonces')
          r3 = nil
        end
        if r3
          r0 = r3
        else
          if input.index('Y', index) == index
            r4 = (SyntaxNode).new(input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure('Y')
            r4 = nil
          end
          if r4
            r0 = r4
          else
            self.index = i0
            r0 = nil
          end
        end
      end
    end

    node_cache[:step_keyword][start_index] = r0

    return r0
  end

  def _nt_scenario_keyword
    start_index = index
    if node_cache[:scenario_keyword].has_key?(index)
      cached = node_cache[:scenario_keyword][index]
      @index = cached.interval.end if cached
      return cached
    end

    if input.index('Escenario', index) == index
      r0 = (SyntaxNode).new(input, index...(index + 9))
      @index += 9
    else
      terminal_parse_failure('Escenario')
      r0 = nil
    end

    node_cache[:scenario_keyword][start_index] = r0

    return r0
  end

  module Table0
    def newline
      elements[0]
    end

    def table_line
      elements[1]
    end
  end

  module Table1
    def table_line
      elements[0]
    end

    def more
      elements[1]
    end

  end

  module Table2
    def populate(feature)
      Feature.last_scenario.table_header = table_line.values
      more.elements.each do |e|
        feature.add_row_scenario(Feature.last_scenario, e.table_line.values, e.table_line.line)
      end
    end
  end

  def _nt_table
    start_index = index
    if node_cache[:table].has_key?(index)
      cached = node_cache[:table][index]
      @index = cached.interval.end if cached
      return cached
    end

    i0, s0 = index, []
    r1 = _nt_table_line
    s0 << r1
    if r1
      s2, i2 = [], index
      loop do
        i3, s3 = index, []
        r4 = _nt_newline
        s3 << r4
        if r4
          r5 = _nt_table_line
          s3 << r5
        end
        if s3.last
          r3 = (SyntaxNode).new(input, i3...index, s3)
          r3.extend(Table0)
        else
          self.index = i3
          r3 = nil
        end
        if r3
          s2 << r3
        else
          break
        end
      end
      if s2.empty?
        self.index = i2
        r2 = nil
      else
        r2 = SyntaxNode.new(input, i2...index, s2)
      end
      s0 << r2
      if r2
        s6, i6 = [], index
        loop do
          r7 = _nt_newline
          if r7
            s6 << r7
          else
            break
          end
        end
        r6 = SyntaxNode.new(input, i6...index, s6)
        s0 << r6
      end
    end
    if s0.last
      r0 = (SyntaxNode).new(input, i0...index, s0)
      r0.extend(Table1)
      r0.extend(Table2)
    else
      self.index = i0
      r0 = nil
    end

    node_cache[:table][start_index] = r0

    return r0
  end

  module TableLine0
    def cell_value
      elements[1]
    end

    def separator
      elements[3]
    end
  end

  module TableLine1
    def separator
      elements[1]
    end

    def cells
      elements[2]
    end
  end

  module TableLine2
    def values
      cells.elements.map { |cell| cell.cell_value.text_value }
    end
    
    def line
      input.line_of(interval.first)
    end
  end

  def _nt_table_line
    start_index = index
    if node_cache[:table_line].has_key?(index)
      cached = node_cache[:table_line][index]
      @index = cached.interval.end if cached
      return cached
    end

    i0, s0 = index, []
    s1, i1 = [], index
    loop do
      r2 = _nt_whitespace
      if r2
        s1 << r2
      else
        break
      end
    end
    r1 = SyntaxNode.new(input, i1...index, s1)
    s0 << r1
    if r1
      r3 = _nt_separator
      s0 << r3
      if r3
        s4, i4 = [], index
        loop do
          i5, s5 = index, []
          s6, i6 = [], index
          loop do
            r7 = _nt_whitespace
            if r7
              s6 << r7
            else
              break
            end
          end
          r6 = SyntaxNode.new(input, i6...index, s6)
          s5 << r6
          if r6
            r8 = _nt_cell_value
            s5 << r8
            if r8
              s9, i9 = [], index
              loop do
                r10 = _nt_whitespace
                if r10
                  s9 << r10
                else
                  break
                end
              end
              r9 = SyntaxNode.new(input, i9...index, s9)
              s5 << r9
              if r9
                r11 = _nt_separator
                s5 << r11
              end
            end
          end
          if s5.last
            r5 = (SyntaxNode).new(input, i5...index, s5)
            r5.extend(TableLine0)
          else
            self.index = i5
            r5 = nil
          end
          if r5
            s4 << r5
          else
            break
          end
        end
        if s4.empty?
          self.index = i4
          r4 = nil
        else
          r4 = SyntaxNode.new(input, i4...index, s4)
        end
        s0 << r4
      end
    end
    if s0.last
      r0 = (SyntaxNode).new(input, i0...index, s0)
      r0.extend(TableLine1)
      r0.extend(TableLine2)
    else
      self.index = i0
      r0 = nil
    end

    node_cache[:table_line][start_index] = r0

    return r0
  end

  module CellValue0
  end

  def _nt_cell_value
    start_index = index
    if node_cache[:cell_value].has_key?(index)
      cached = node_cache[:cell_value][index]
      @index = cached.interval.end if cached
      return cached
    end

    s0, i0 = [], index
    loop do
      i1, s1 = index, []
      i2 = index
      i3 = index
      r4 = _nt_separator
      if r4
        r3 = r4
      else
        r5 = _nt_newline
        if r5
          r3 = r5
        else
          r6 = _nt_whitespace
          if r6
            r3 = r6
          else
            self.index = i3
            r3 = nil
          end
        end
      end
      if r3
        r2 = nil
      else
        self.index = i2
        r2 = SyntaxNode.new(input, index...index)
      end
      s1 << r2
      if r2
        if index < input_length
          r7 = (SyntaxNode).new(input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure("any character")
          r7 = nil
        end
        s1 << r7
      end
      if s1.last
        r1 = (SyntaxNode).new(input, i1...index, s1)
        r1.extend(CellValue0)
      else
        self.index = i1
        r1 = nil
      end
      if r1
        s0 << r1
      else
        break
      end
    end
    r0 = SyntaxNode.new(input, i0...index, s0)

    node_cache[:cell_value][start_index] = r0

    return r0
  end

  def _nt_separator
    start_index = index
    if node_cache[:separator].has_key?(index)
      cached = node_cache[:separator][index]
      @index = cached.interval.end if cached
      return cached
    end

    if input.index('|', index) == index
      r0 = (SyntaxNode).new(input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('|')
      r0 = nil
    end

    node_cache[:separator][start_index] = r0

    return r0
  end

  def _nt_newline
    start_index = index
    if node_cache[:newline].has_key?(index)
      cached = node_cache[:newline][index]
      @index = cached.interval.end if cached
      return cached
    end

    i0 = index
    if input.index("\r\n?", index) == index
      r1 = (SyntaxNode).new(input, index...(index + 3))
      @index += 3
    else
      terminal_parse_failure("\r\n?")
      r1 = nil
    end
    if r1
      r0 = r1
    else
      if input.index("\n", index) == index
        r2 = (SyntaxNode).new(input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("\n")
        r2 = nil
      end
      if r2
        r0 = r2
      else
        self.index = i0
        r0 = nil
      end
    end

    node_cache[:newline][start_index] = r0

    return r0
  end

  def _nt_whitespace
    start_index = index
    if node_cache[:whitespace].has_key?(index)
      cached = node_cache[:whitespace][index]
      @index = cached.interval.end if cached
      return cached
    end

    if input.index(Regexp.new('[ \\v\\f\\t]'), index) == index
      r0 = (SyntaxNode).new(input, index...(index + 1))
      @index += 1
    else
      r0 = nil
    end

    node_cache[:whitespace][start_index] = r0

    return r0
  end

end

class FeatureParser < Treetop::Runtime::CompiledParser
  include Feature
end


end
end