module Fig::Grammar::V1Base

Consumers of this need to mix in Fig::Grammar::Base and Fig::Grammar::Version and have a “rule config_statement”.

Public Instance Methods

_nt_archive() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 153
def _nt_archive
  start_index = index
  if node_cache[:archive].has_key?(index)
    cached = node_cache[:archive][index]
    if cached
      node_cache[:archive][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('archive', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('archive')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
    if r2
      r4 = _nt_quoted_or_bare_string
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Archive0)
    r0.extend(Archive1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:archive][start_index] = r0

  r0
end
_nt_command() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 917
def _nt_command
  start_index = index
  if node_cache[:command].has_key?(index)
    cached = node_cache[:command][index]
    if cached
      node_cache[:command][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('command', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('command')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
    if r2
      r4 = _nt_command_line
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_ws_or_comment
          if r6
            s5 << r6
          else
            break
          end
        end
        if s5.empty?
          @index = i5
          r5 = nil
        else
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        end
        s0 << r5
        if r5
          if (match_len = has_terminal?('end', false, index))
            r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('end')
            r7 = nil
          end
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Command0)
    r0.extend(Command1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:command][start_index] = r0

  r0
end
_nt_command_line() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 1015
def _nt_command_line
  start_index = index
  if node_cache[:command_line].has_key?(index)
    cached = node_cache[:command_line][index]
    if cached
      node_cache[:command_line][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_quoted_or_bare_string
  s0 << r1
  if r1
    i2 = index
    r3 = lambda { |sequence| sequence[-1].text_value == 'end' }.call(s0)
    if r3
      r2 = nil
    else
      @index = i2
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      s4, i4 = [], index
      loop do
        i5, s5 = index, []
        s6, i6 = [], index
        loop do
          r7 = _nt_ws_or_comment
          if r7
            s6 << r7
          else
            break
          end
        end
        if s6.empty?
          @index = i6
          r6 = nil
        else
          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        end
        s5 << r6
        if r6
          r8 = _nt_quoted_or_bare_string
          s5 << r8
          if r8
            i9 = index
            r10 = lambda { |sequence| sequence[-1].text_value == 'end' }.call(s5)
            if r10
              r9 = nil
            else
              @index = i9
              r9 = instantiate_node(SyntaxNode,input, index...index)
            end
            s5 << r9
          end
        end
        if s5.last
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          r5.extend(CommandLine0)
        else
          @index = i5
          r5 = nil
        end
        if r5
          s4 << r5
        else
          break
        end
      end
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CommandLine1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:command_line][start_index] = r0

  r0
end
_nt_config() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 398
def _nt_config
  start_index = index
  if node_cache[:config].has_key?(index)
    cached = node_cache[:config][index]
    if cached
      node_cache[:config][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('config', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('config')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
    if r2
      r4 = _nt_config_name
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_ws_or_comment
          if r6
            s5 << r6
          else
            break
          end
        end
        if s5.empty?
          @index = i5
          r5 = nil
        else
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        end
        s0 << r5
        if r5
          s7, i7 = [], index
          loop do
            r8 = _nt_config_statement_with_ws
            if r8
              s7 << r8
            else
              break
            end
          end
          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
          s0 << r7
          if r7
            if (match_len = has_terminal?('end', false, index))
              r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('end')
              r9 = nil
            end
            s0 << r9
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Config0)
    r0.extend(Config1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:config][start_index] = r0

  r0
end
_nt_config_name() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 1142
def _nt_config_name
  start_index = index
  if node_cache[:config_name].has_key?(index)
    cached = node_cache[:config_name][index]
    if cached
      node_cache[:config_name][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_.-]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[a-zA-Z0-9_.-]')
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  end

  node_cache[:config_name][start_index] = r0

  r0
end
_nt_config_statement_with_ws() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 508
def _nt_config_statement_with_ws
  start_index = index
  if node_cache[:config_statement_with_ws].has_key?(index)
    cached = node_cache[:config_statement_with_ws][index]
    if cached
      node_cache[:config_statement_with_ws][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_config_statement
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ConfigStatementWithWs0)
    r0.extend(ConfigStatementWithWs1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:config_statement_with_ws][start_index] = r0

  r0
end
_nt_descriptor_string() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 1104
def _nt_descriptor_string
  start_index = index
  if node_cache[:descriptor_string].has_key?(index)
    cached = node_cache[:descriptor_string][index]
    if cached
      node_cache[:descriptor_string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    if has_terminal?(@regexps[gr = '\A[^\\s#]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[^\\s#]')
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  end

  node_cache[:descriptor_string][start_index] = r0

  r0
end
_nt_environment_variable_name() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 1469
def _nt_environment_variable_name
  start_index = index
  if node_cache[:environment_variable_name].has_key?(index)
    cached = node_cache[:environment_variable_name][index]
    if cached
      node_cache[:environment_variable_name][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[a-zA-Z0-9_]')
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  end

  node_cache[:environment_variable_name][start_index] = r0

  r0
end
_nt_environment_variable_name_value() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 1519
def _nt_environment_variable_name_value
  start_index = index
  if node_cache[:environment_variable_name_value].has_key?(index)
    cached = node_cache[:environment_variable_name_value][index]
    if cached
      node_cache[:environment_variable_name_value][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  s2, i2 = [], index
  loop do
    if has_terminal?(@regexps[gr = '\A[^\\s#\\\\\'"]'] ||= Regexp.new(gr), :regexp, index)
      r3 = true
      @index += 1
    else
      terminal_parse_failure('[^\\s#\\\\\'"]')
      r3 = nil
    end
    if r3
      s2 << r3
    else
      break
    end
  end
  r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
  s1 << r2
  if r2
    if (match_len = has_terminal?('"', false, index))
      r4 = true
      @index += match_len
    else
      terminal_parse_failure('"')
      r4 = nil
    end
    s1 << r4
    if r4
      s5, i5 = [], index
      loop do
        i6 = index
        if has_terminal?(@regexps[gr = '\A[^"\\\\]'] ||= Regexp.new(gr), :regexp, index)
          r7 = true
          @index += 1
        else
          terminal_parse_failure('[^"\\\\]')
          r7 = nil
        end
        if r7
          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
          r6 = r7
        else
          i8, s8 = index, []
          if (match_len = has_terminal?('\\', false, index))
            r9 = true
            @index += match_len
          else
            terminal_parse_failure('\\')
            r9 = nil
          end
          s8 << r9
          if r9
            if index < input_length
              r10 = true
              @index += 1
            else
              terminal_parse_failure("any character")
              r10 = nil
            end
            s8 << r10
          end
          if s8.last
            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
            r8.extend(EnvironmentVariableNameValue0)
          else
            @index = i8
            r8 = nil
          end
          if r8
            r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
            r6 = r8
          else
            @index = i6
            r6 = nil
          end
        end
        if r6
          s5 << r6
        else
          break
        end
      end
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
      s1 << r5
      if r5
        if (match_len = has_terminal?('"', false, index))
          r11 = true
          @index += match_len
        else
          terminal_parse_failure('"')
          r11 = nil
        end
        s1 << r11
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(EnvironmentVariableNameValue1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i12, s12 = index, []
    s13, i13 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[^\\s#\\\\\'"]'] ||= Regexp.new(gr), :regexp, index)
        r14 = true
        @index += 1
      else
        terminal_parse_failure('[^\\s#\\\\\'"]')
        r14 = nil
      end
      if r14
        s13 << r14
      else
        break
      end
    end
    r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
    s12 << r13
    if r13
      if (match_len = has_terminal?("'", false, index))
        r15 = true
        @index += match_len
      else
        terminal_parse_failure("'")
        r15 = nil
      end
      s12 << r15
      if r15
        s16, i16 = [], index
        loop do
          i17 = index
          if has_terminal?(@regexps[gr = '\A[^\'\\\\]'] ||= Regexp.new(gr), :regexp, index)
            r18 = true
            @index += 1
          else
            terminal_parse_failure('[^\'\\\\]')
            r18 = nil
          end
          if r18
            r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
            r17 = r18
          else
            i19, s19 = index, []
            if (match_len = has_terminal?('\\', false, index))
              r20 = true
              @index += match_len
            else
              terminal_parse_failure('\\')
              r20 = nil
            end
            s19 << r20
            if r20
              if index < input_length
                r21 = true
                @index += 1
              else
                terminal_parse_failure("any character")
                r21 = nil
              end
              s19 << r21
            end
            if s19.last
              r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
              r19.extend(EnvironmentVariableNameValue2)
            else
              @index = i19
              r19 = nil
            end
            if r19
              r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
              r17 = r19
            else
              @index = i17
              r17 = nil
            end
          end
          if r17
            s16 << r17
          else
            break
          end
        end
        r16 = instantiate_node(SyntaxNode,input, i16...index, s16)
        s12 << r16
        if r16
          if (match_len = has_terminal?("'", false, index))
            r22 = true
            @index += match_len
          else
            terminal_parse_failure("'")
            r22 = nil
          end
          s12 << r22
        end
      end
    end
    if s12.last
      r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
      r12.extend(EnvironmentVariableNameValue3)
    else
      @index = i12
      r12 = nil
    end
    if r12
      r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
      r0 = r12
    else
      s23, i23 = [], index
      loop do
        if has_terminal?(@regexps[gr = '\A[^\\s#]'] ||= Regexp.new(gr), :regexp, index)
          r24 = true
          @index += 1
        else
          terminal_parse_failure('[^\\s#]')
          r24 = nil
        end
        if r24
          s23 << r24
        else
          break
        end
      end
      if s23.empty?
        @index = i23
        r23 = nil
      else
        r23 = instantiate_node(SyntaxNode,input, i23...index, s23)
      end
      if r23
        r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
        r0 = r23
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:environment_variable_name_value][start_index] = r0

  r0
end
_nt_include() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 572
def _nt_include
  start_index = index
  if node_cache[:include].has_key?(index)
    cached = node_cache[:include][index]
    if cached
      node_cache[:include][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('include', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('include')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
    if r2
      r4 = _nt_descriptor_string
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Include0)
    r0.extend(Include1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:include][start_index] = r0

  r0
end
_nt_override() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 646
def _nt_override
  start_index = index
  if node_cache[:override].has_key?(index)
    cached = node_cache[:override][index]
    if cached
      node_cache[:override][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('override', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('override')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
    if r2
      r4 = _nt_descriptor_string
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Override0)
    r0.extend(Override1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:override][start_index] = r0

  r0
end
_nt_package_statement() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 91
def _nt_package_statement
  start_index = index
  if node_cache[:package_statement].has_key?(index)
    cached = node_cache[:package_statement][index]
    if cached
      node_cache[:package_statement][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_archive
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_resource
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_retrieve
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        r4 = _nt_config
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          @index = i0
          r0 = nil
        end
      end
    end
  end

  node_cache[:package_statement][start_index] = r0

  r0
end
_nt_package_statement_with_ws() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 45
def _nt_package_statement_with_ws
  start_index = index
  if node_cache[:package_statement_with_ws].has_key?(index)
    cached = node_cache[:package_statement_with_ws][index]
    if cached
      node_cache[:package_statement_with_ws][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_package_statement
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(PackageStatementWithWs0)
    r0.extend(PackageStatementWithWs1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:package_statement_with_ws][start_index] = r0

  r0
end
_nt_path() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 794
def _nt_path
  start_index = index
  if node_cache[:path].has_key?(index)
    cached = node_cache[:path][index]
    if cached
      node_cache[:path][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i1 = index
  if (match_len = has_terminal?('add', false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('add')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?('append', false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('append')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      if (match_len = has_terminal?('path', false, index))
        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('path')
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r1 = r4
      else
        @index = i1
        r1 = nil
      end
    end
  end
  s0 << r1
  if r1
    s5, i5 = [], index
    loop do
      r6 = _nt_ws_or_comment
      if r6
        s5 << r6
      else
        break
      end
    end
    if s5.empty?
      @index = i5
      r5 = nil
    else
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
    end
    s0 << r5
    if r5
      r7 = _nt_environment_variable_name_value
      s0 << r7
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Path0)
    r0.extend(Path1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:path][start_index] = r0

  r0
end
_nt_quoted_or_bare_string() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 1204
def _nt_quoted_or_bare_string
  start_index = index
  if node_cache[:quoted_or_bare_string].has_key?(index)
    cached = node_cache[:quoted_or_bare_string][index]
    if cached
      node_cache[:quoted_or_bare_string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  s2, i2 = [], index
  loop do
    if has_terminal?(@regexps[gr = '\A[^\\s#\\\\"]'] ||= Regexp.new(gr), :regexp, index)
      r3 = true
      @index += 1
    else
      terminal_parse_failure('[^\\s#\\\\"]')
      r3 = nil
    end
    if r3
      s2 << r3
    else
      break
    end
  end
  r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
  s1 << r2
  if r2
    if (match_len = has_terminal?('"', false, index))
      r4 = true
      @index += match_len
    else
      terminal_parse_failure('"')
      r4 = nil
    end
    s1 << r4
    if r4
      s5, i5 = [], index
      loop do
        i6 = index
        if has_terminal?(@regexps[gr = '\A[^"\\\\]'] ||= Regexp.new(gr), :regexp, index)
          r7 = true
          @index += 1
        else
          terminal_parse_failure('[^"\\\\]')
          r7 = nil
        end
        if r7
          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
          r6 = r7
        else
          i8, s8 = index, []
          if (match_len = has_terminal?('\\', false, index))
            r9 = true
            @index += match_len
          else
            terminal_parse_failure('\\')
            r9 = nil
          end
          s8 << r9
          if r9
            if index < input_length
              r10 = true
              @index += 1
            else
              terminal_parse_failure("any character")
              r10 = nil
            end
            s8 << r10
          end
          if s8.last
            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
            r8.extend(QuotedOrBareString0)
          else
            @index = i8
            r8 = nil
          end
          if r8
            r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
            r6 = r8
          else
            @index = i6
            r6 = nil
          end
        end
        if r6
          s5 << r6
        else
          break
        end
      end
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
      s1 << r5
      if r5
        if (match_len = has_terminal?('"', false, index))
          r11 = true
          @index += match_len
        else
          terminal_parse_failure('"')
          r11 = nil
        end
        s1 << r11
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(QuotedOrBareString1)
    r1.extend(QuotedOrBareString2)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i12, s12 = index, []
    s13, i13 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[^\\s#\\\\\']'] ||= Regexp.new(gr), :regexp, index)
        r14 = true
        @index += 1
      else
        terminal_parse_failure('[^\\s#\\\\\']')
        r14 = nil
      end
      if r14
        s13 << r14
      else
        break
      end
    end
    r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
    s12 << r13
    if r13
      if (match_len = has_terminal?("'", false, index))
        r15 = true
        @index += match_len
      else
        terminal_parse_failure("'")
        r15 = nil
      end
      s12 << r15
      if r15
        s16, i16 = [], index
        loop do
          i17 = index
          if has_terminal?(@regexps[gr = '\A[^\'\\\\]'] ||= Regexp.new(gr), :regexp, index)
            r18 = true
            @index += 1
          else
            terminal_parse_failure('[^\'\\\\]')
            r18 = nil
          end
          if r18
            r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
            r17 = r18
          else
            i19, s19 = index, []
            if (match_len = has_terminal?('\\', false, index))
              r20 = true
              @index += match_len
            else
              terminal_parse_failure('\\')
              r20 = nil
            end
            s19 << r20
            if r20
              if index < input_length
                r21 = true
                @index += 1
              else
                terminal_parse_failure("any character")
                r21 = nil
              end
              s19 << r21
            end
            if s19.last
              r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
              r19.extend(QuotedOrBareString3)
            else
              @index = i19
              r19 = nil
            end
            if r19
              r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
              r17 = r19
            else
              @index = i17
              r17 = nil
            end
          end
          if r17
            s16 << r17
          else
            break
          end
        end
        r16 = instantiate_node(SyntaxNode,input, i16...index, s16)
        s12 << r16
        if r16
          if (match_len = has_terminal?("'", false, index))
            r22 = true
            @index += match_len
          else
            terminal_parse_failure("'")
            r22 = nil
          end
          s12 << r22
        end
      end
    end
    if s12.last
      r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
      r12.extend(QuotedOrBareString4)
      r12.extend(QuotedOrBareString5)
    else
      @index = i12
      r12 = nil
    end
    if r12
      r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
      r0 = r12
    else
      s23, i23 = [], index
      loop do
        if has_terminal?(@regexps[gr = '\A[^\\s#]'] ||= Regexp.new(gr), :regexp, index)
          r24 = true
          @index += 1
        else
          terminal_parse_failure('[^\\s#]')
          r24 = nil
        end
        if r24
          s23 << r24
        else
          break
        end
      end
      if s23.empty?
        @index = i23
        r23 = nil
      else
        r23 = instantiate_node(SyntaxNode,input, i23...index, s23)
        r23.extend(QuotedOrBareString6)
      end
      if r23
        r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
        r0 = r23
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:quoted_or_bare_string][start_index] = r0

  r0
end
_nt_resource() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 227
def _nt_resource
  start_index = index
  if node_cache[:resource].has_key?(index)
    cached = node_cache[:resource][index]
    if cached
      node_cache[:resource][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('resource', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('resource')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
    if r2
      r4 = _nt_quoted_or_bare_string
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Resource0)
    r0.extend(Resource1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:resource][start_index] = r0

  r0
end
_nt_retrieve() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 305
def _nt_retrieve
  start_index = index
  if node_cache[:retrieve].has_key?(index)
    cached = node_cache[:retrieve][index]
    if cached
      node_cache[:retrieve][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('retrieve', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('retrieve')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
    if r2
      r4 = _nt_environment_variable_name
      s0 << r4
      if r4
        if (match_len = has_terminal?('->', false, index))
          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('->')
          r5 = nil
        end
        s0 << r5
        if r5
          r6 = _nt_quoted_or_bare_string
          s0 << r6
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Retrieve0)
    r0.extend(Retrieve1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:retrieve][start_index] = r0

  r0
end
_nt_set() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 720
def _nt_set
  start_index = index
  if node_cache[:set].has_key?(index)
    cached = node_cache[:set][index]
    if cached
      node_cache[:set][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('set', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('set')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_ws_or_comment
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
    if r2
      r4 = _nt_environment_variable_name_value
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Set0)
    r0.extend(Set1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:set][start_index] = r0

  r0
end
root() click to toggle source
# File lib/fig/grammar/v1_base.rb, line 28
def root
  @root ||= :package_statement_with_ws
end