module ABNFGrammar

Autogenerated from a Treetop grammar. Edits may be lost.

Public Instance Methods

_nt_ALPHA() click to toggle source
# File lib/abnfgrammar.rb, line 1871
def _nt_ALPHA
  start_index = index
  if node_cache[:ALPHA].has_key?(index)
    cached = node_cache[:ALPHA][index]
    if cached
      node_cache[:ALPHA][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A[A-Za-z]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[A-Za-z]')
    r0 = nil
  end

  node_cache[:ALPHA][start_index] = r0

  r0
end
_nt_BIT() click to toggle source
# File lib/abnfgrammar.rb, line 1895
def _nt_BIT
  start_index = index
  if node_cache[:BIT].has_key?(index)
    cached = node_cache[:BIT][index]
    if cached
      node_cache[:BIT][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?("0", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"0"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("1", false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('"1"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:BIT][start_index] = r0

  r0
end
_nt_CR() click to toggle source
# File lib/abnfgrammar.rb, line 1980
def _nt_CR
  start_index = index
  if node_cache[:CR].has_key?(index)
    cached = node_cache[:CR][index]
    if cached
      node_cache[:CR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A[\\r]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[\\r]')
    r1 = nil
  end
  if r1
    r0 = r1
  else
    r0 = instantiate_node(SyntaxNode,input, index...index)
  end

  node_cache[:CR][start_index] = r0

  r0
end
_nt_CRLF() click to toggle source
# File lib/abnfgrammar.rb, line 1949
def _nt_CRLF
  start_index = index
  if node_cache[:CRLF].has_key?(index)
    cached = node_cache[:CRLF][index]
    if cached
      node_cache[:CRLF][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_CR
  s0 << r1
  if r1
    r2 = _nt_LF
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CRLF0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:CRLF][start_index] = r0

  r0
end
_nt_DIGIT() click to toggle source
# File lib/abnfgrammar.rb, line 2033
def _nt_DIGIT
  start_index = index
  if node_cache[:DIGIT].has_key?(index)
    cached = node_cache[:DIGIT][index]
    if cached
      node_cache[:DIGIT][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[0-9]')
    r0 = nil
  end

  node_cache[:DIGIT][start_index] = r0

  r0
end
_nt_DQUOTE() click to toggle source
# File lib/abnfgrammar.rb, line 2057
def _nt_DQUOTE
  start_index = index
  if node_cache[:DQUOTE].has_key?(index)
    cached = node_cache[:DQUOTE][index]
    if cached
      node_cache[:DQUOTE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A["]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('["]')
    r0 = nil
  end

  node_cache[:DQUOTE][start_index] = r0

  r0
end
_nt_HEXDIG() click to toggle source
# File lib/abnfgrammar.rb, line 2081
def _nt_HEXDIG
  start_index = index
  if node_cache[:HEXDIG].has_key?(index)
    cached = node_cache[:HEXDIG][index]
    if cached
      node_cache[:HEXDIG][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_DIGIT
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if has_terminal?(@regexps[gr = '\A[A-Fa-f]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[A-Fa-f]')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:HEXDIG][start_index] = r0

  r0
end
_nt_HTAB() click to toggle source
# File lib/abnfgrammar.rb, line 2151
def _nt_HTAB
  start_index = index
  if node_cache[:HTAB].has_key?(index)
    cached = node_cache[:HTAB][index]
    if cached
      node_cache[:HTAB][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A[\\t]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[\\t]')
    r0 = nil
  end

  node_cache[:HTAB][start_index] = r0

  r0
end
_nt_LF() click to toggle source
# File lib/abnfgrammar.rb, line 2009
def _nt_LF
  start_index = index
  if node_cache[:LF].has_key?(index)
    cached = node_cache[:LF][index]
    if cached
      node_cache[:LF][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A[\\n]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[\\n]')
    r0 = nil
  end

  node_cache[:LF][start_index] = r0

  r0
end
_nt_SP() click to toggle source
# File lib/abnfgrammar.rb, line 2175
def _nt_SP
  start_index = index
  if node_cache[:SP].has_key?(index)
    cached = node_cache[:SP][index]
    if cached
      node_cache[:SP][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if (match_len = has_terminal?(" ", false, index))
    r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('" "')
    r0 = nil
  end

  node_cache[:SP][start_index] = r0

  r0
end
_nt_VCHAR() click to toggle source
# File lib/abnfgrammar.rb, line 2199
def _nt_VCHAR
  start_index = index
  if node_cache[:VCHAR].has_key?(index)
    cached = node_cache[:VCHAR][index]
    if cached
      node_cache[:VCHAR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?(@regexps[gr = '\A[!-~]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[!-~]')
    r0 = nil
  end

  node_cache[:VCHAR][start_index] = r0

  r0
end
_nt_WSP() click to toggle source
# File lib/abnfgrammar.rb, line 2119
def _nt_WSP
  start_index = index
  if node_cache[:WSP].has_key?(index)
    cached = node_cache[:WSP][index]
    if cached
      node_cache[:WSP][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_SP
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_HTAB
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:WSP][start_index] = r0

  r0
end
_nt_abnf_rule() click to toggle source
# File lib/abnfgrammar.rb, line 136
def _nt_abnf_rule
  start_index = index
  if node_cache[:abnf_rule].has_key?(index)
    cached = node_cache[:abnf_rule][index]
    if cached
      node_cache[:abnf_rule][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_rulename
  s0 << r1
  if r1
    r2 = _nt_defined_as
    s0 << r2
    if r2
      r3 = _nt_alternation
      s0 << r3
      if r3
        r4 = _nt_c_nl
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AbnfRule0)
    r0.extend(AbnfRule1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:abnf_rule][start_index] = r0

  r0
end
_nt_alternation() click to toggle source
# File lib/abnfgrammar.rb, line 541
def _nt_alternation
  start_index = index
  if node_cache[:alternation].has_key?(index)
    cached = node_cache[:alternation][index]
    if cached
      node_cache[:alternation][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_concatenation
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      if (match_len = has_terminal?("/", false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('"/"')
        r4 = nil
      end
      s3 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_c_wsp
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s3 << r5
        if r5
          r7 = _nt_concatenation
          s3 << r7
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(Alternation0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Alternation1)
    r0.extend(Alternation2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:alternation][start_index] = r0

  r0
end
_nt_bin_val() click to toggle source
# File lib/abnfgrammar.rb, line 1220
def _nt_bin_val
  start_index = index
  if node_cache[:bin_val].has_key?(index)
    cached = node_cache[:bin_val][index]
    if cached
      node_cache[:bin_val][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?("b", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"b"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_BIT
      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
      i5 = index
      i6, s6 = index, []
      s7, i7 = [], index
      loop do
        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
          s10, i10 = [], index
          loop do
            r11 = _nt_BIT
            if r11
              s10 << r11
            else
              break
            end
          end
          if s10.empty?
            @index = i10
            r10 = nil
          else
            r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
          end
          s8 << r10
        end
        if s8.last
          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
          r8.extend(BinVal0)
        else
          @index = i8
          r8 = nil
        end
        if r8
          s7 << r8
        else
          break
        end
      end
      if s7.empty?
        @index = i7
        r7 = nil
      else
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
      end
      s6 << r7
      if s6.last
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        r6.extend(BinVal1)
      else
        @index = i6
        r6 = nil
      end
      if r6
        r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
        r5 = r6
      else
        i12, s12 = index, []
        i13, s13 = index, []
        if (match_len = has_terminal?("-", false, index))
          r14 = true
          @index += match_len
        else
          terminal_parse_failure('"-"')
          r14 = nil
        end
        s13 << r14
        if r14
          s15, i15 = [], index
          loop do
            r16 = _nt_BIT
            if r16
              s15 << r16
            else
              break
            end
          end
          if s15.empty?
            @index = i15
            r15 = nil
          else
            r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
          end
          s13 << r15
        end
        if s13.last
          r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
          r13.extend(BinVal2)
        else
          @index = i13
          r13 = nil
        end
        s12 << r13
        if s12.last
          r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
          r12.extend(BinVal3)
        else
          @index = i12
          r12 = nil
        end
        if r12
          r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
          r5 = r12
        else
          @index = i5
          r5 = nil
        end
      end
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(BinVal4)
    r0.extend(BinVal5)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:bin_val][start_index] = r0

  r0
end
_nt_c_nl() click to toggle source
# File lib/abnfgrammar.rb, line 408
def _nt_c_nl
  start_index = index
  if node_cache[:c_nl].has_key?(index)
    cached = node_cache[:c_nl][index]
    if cached
      node_cache[:c_nl][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_comment
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
    r0.extend(CNl0)
    r0.extend(CNl0)
  else
    r2 = _nt_CRLF
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
      r0.extend(CNl0)
      r0.extend(CNl0)
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:c_nl][start_index] = r0

  r0
end
_nt_c_wsp() click to toggle source
# File lib/abnfgrammar.rb, line 355
def _nt_c_wsp
  start_index = index
  if node_cache[:c_wsp].has_key?(index)
    cached = node_cache[:c_wsp][index]
    if cached
      node_cache[:c_wsp][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_WSP
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
    r0.extend(CWsp1)
    r0.extend(CWsp1)
  else
    i2, s2 = index, []
    r3 = _nt_c_nl
    s2 << r3
    if r3
      r4 = _nt_WSP
      s2 << r4
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(CWsp0)
    else
      @index = i2
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
      r0.extend(CWsp1)
      r0.extend(CWsp1)
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:c_wsp][start_index] = r0

  r0
end
_nt_case_insensitive_string() click to toggle source
# File lib/abnfgrammar.rb, line 2265
def _nt_case_insensitive_string
  start_index = index
  if node_cache[:case_insensitive_string].has_key?(index)
    cached = node_cache[:case_insensitive_string][index]
    if cached
      node_cache[:case_insensitive_string][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?("%i", false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"%i"')
    r2 = nil
  end
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    r3 = _nt_quoted_string
    s0 << r3
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CaseInsensitiveString0)
    r0.extend(CaseInsensitiveString1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:case_insensitive_string][start_index] = r0

  r0
end
_nt_case_sensitive_string() click to toggle source
# File lib/abnfgrammar.rb, line 2318
def _nt_case_sensitive_string
  start_index = index
  if node_cache[:case_sensitive_string].has_key?(index)
    cached = node_cache[:case_sensitive_string][index]
    if cached
      node_cache[:case_sensitive_string][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?("%s", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"%s"')
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_quoted_string
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CaseSensitiveString0)
    r0.extend(CaseSensitiveString1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:case_sensitive_string][start_index] = r0

  r0
end
_nt_char_val() click to toggle source
# File lib/abnfgrammar.rb, line 2223
def _nt_char_val
  start_index = index
  if node_cache[:char_val].has_key?(index)
    cached = node_cache[:char_val][index]
    if cached
      node_cache[:char_val][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_case_insensitive_string
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_case_sensitive_string
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:char_val][start_index] = r0

  r0
end
_nt_comment() click to toggle source
# File lib/abnfgrammar.rb, line 454
def _nt_comment
  start_index = index
  if node_cache[:comment].has_key?(index)
    cached = node_cache[:comment][index]
    if cached
      node_cache[:comment][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?(";", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('";"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3 = index
      r4 = _nt_WSP
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r3 = r4
      else
        r5 = _nt_VCHAR
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r3 = r5
        else
          @index = i3
          r3 = nil
        end
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      r6 = _nt_CRLF
      s0 << r6
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Comment0)
    r0.extend(Comment1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comment][start_index] = r0

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

  i0, s0 = index, []
  i1, s1 = index, []
  r2 = _nt_repetition
  s1 << r2
  if r2
    s3, i3 = [], index
    loop do
      i4, s4 = index, []
      s5, i5 = [], index
      loop do
        r6 = _nt_c_wsp
        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
      s4 << r5
      if r5
        r7 = _nt_repetition
        s4 << r7
      end
      if s4.last
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        r4.extend(Concatenation0)
      else
        @index = i4
        r4 = nil
      end
      if r4
        s3 << r4
      else
        break
      end
    end
    r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
    s1 << r3
    if r3
      s8, i8 = [], index
      loop do
        r9 = _nt_c_wsp
        if r9
          s8 << r9
        else
          break
        end
      end
      r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
      s1 << r8
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Concatenation1)
  else
    @index = i1
    r1 = nil
  end
  s0 << r1
  if r1
    r10 = _nt_inline_module
    s0 << r10
    if r10
      s11, i11 = [], index
      loop do
        r12 = _nt_c_wsp
        if r12
          s11 << r12
        else
          break
        end
      end
      r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
      s0 << r11
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Concatenation2)
    r0.extend(Concatenation3)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:concatenation][start_index] = r0

  r0
end
_nt_dec_val() click to toggle source
# File lib/abnfgrammar.rb, line 1422
def _nt_dec_val
  start_index = index
  if node_cache[:dec_val].has_key?(index)
    cached = node_cache[:dec_val][index]
    if cached
      node_cache[:dec_val][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?("d", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"d"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_DIGIT
      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
      i5 = index
      i6, s6 = index, []
      s7, i7 = [], index
      loop do
        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
          s10, i10 = [], index
          loop do
            r11 = _nt_DIGIT
            if r11
              s10 << r11
            else
              break
            end
          end
          if s10.empty?
            @index = i10
            r10 = nil
          else
            r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
          end
          s8 << r10
        end
        if s8.last
          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
          r8.extend(DecVal0)
        else
          @index = i8
          r8 = nil
        end
        if r8
          s7 << r8
        else
          break
        end
      end
      if s7.empty?
        @index = i7
        r7 = nil
      else
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
      end
      s6 << r7
      if s6.last
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        r6.extend(DecVal1)
      else
        @index = i6
        r6 = nil
      end
      if r6
        r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
        r5 = r6
      else
        i12, s12 = index, []
        i13, s13 = index, []
        if (match_len = has_terminal?("-", false, index))
          r14 = true
          @index += match_len
        else
          terminal_parse_failure('"-"')
          r14 = nil
        end
        s13 << r14
        if r14
          s15, i15 = [], index
          loop do
            r16 = _nt_DIGIT
            if r16
              s15 << r16
            else
              break
            end
          end
          if s15.empty?
            @index = i15
            r15 = nil
          else
            r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
          end
          s13 << r15
        end
        if s13.last
          r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
          r13.extend(DecVal2)
        else
          @index = i13
          r13 = nil
        end
        s12 << r13
        if s12.last
          r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
          r12.extend(DecVal3)
        else
          @index = i12
          r12 = nil
        end
        if r12
          r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
          r5 = r12
        else
          @index = i5
          r5 = nil
        end
      end
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DecVal4)
    r0.extend(DecVal5)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:dec_val][start_index] = r0

  r0
end
_nt_defined_as() click to toggle source
# File lib/abnfgrammar.rb, line 261
def _nt_defined_as
  start_index = index
  if node_cache[:defined_as].has_key?(index)
    cached = node_cache[:defined_as][index]
    if cached
      node_cache[:defined_as][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  s1, i1 = [], index
  loop do
    r2 = _nt_c_wsp
    if r2
      s1 << r2
    else
      break
    end
  end
  r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
  s0 << r1
  if r1
    i3 = index
    if (match_len = has_terminal?("=/", false, index))
      r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"=/"')
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r3 = r4
    else
      if (match_len = has_terminal?("=", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"="')
        r5 = nil
      end
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r3 = r5
      else
        @index = i3
        r3 = nil
      end
    end
    s0 << r3
    if r3
      s6, i6 = [], index
      loop do
        r7 = _nt_c_wsp
        if r7
          s6 << r7
        else
          break
        end
      end
      r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
      s0 << r6
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DefinedAs0)
    r0.extend(DefinedAs1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:defined_as][start_index] = r0

  r0
end
_nt_element() click to toggle source
# File lib/abnfgrammar.rb, line 921
def _nt_element
  start_index = index
  if node_cache[:element].has_key?(index)
    cached = node_cache[:element][index]
    if cached
      node_cache[:element][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_rulename
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_group
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_option
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        r4 = _nt_char_val
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          r5 = _nt_num_val
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            r6 = _nt_prose_val
            r6.extend(Element0)
            r6.extend(Element0)
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = r6
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end
  end

  node_cache[:element][start_index] = r0

  r0
end
_nt_empty_line() click to toggle source
# File lib/abnfgrammar.rb, line 73
def _nt_empty_line
  start_index = index
  if node_cache[:empty_line].has_key?(index)
    cached = node_cache[:empty_line][index]
    if cached
      node_cache[:empty_line][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  s1, i1 = [], index
  loop do
    r2 = _nt_c_wsp
    if r2
      s1 << r2
    else
      break
    end
  end
  r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
  s0 << r1
  if r1
    r3 = _nt_c_nl
    s0 << r3
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(EmptyLine0)
    r0.extend(EmptyLine1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:empty_line][start_index] = r0

  r0
end
_nt_group() click to toggle source
# File lib/abnfgrammar.rb, line 990
def _nt_group
  start_index = index
  if node_cache[:group].has_key?(index)
    cached = node_cache[:group][index]
    if cached
      node_cache[:group][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?("(", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"("')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_c_wsp
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      r4 = _nt_alternation
      s0 << r4
      if r4
        if (match_len = has_terminal?(")", false, index))
          r5 = true
          @index += match_len
        else
          terminal_parse_failure('")"')
          r5 = nil
        end
        s0 << r5
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Group0)
    r0.extend(Group1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:group][start_index] = r0

  r0
end
_nt_hex_val() click to toggle source
# File lib/abnfgrammar.rb, line 1624
def _nt_hex_val
  start_index = index
  if node_cache[:hex_val].has_key?(index)
    cached = node_cache[:hex_val][index]
    if cached
      node_cache[:hex_val][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?("x", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"x"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_HEXDIG
      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
      i5 = index
      i6, s6 = index, []
      s7, i7 = [], index
      loop do
        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
          s10, i10 = [], index
          loop do
            r11 = _nt_HEXDIG
            if r11
              s10 << r11
            else
              break
            end
          end
          if s10.empty?
            @index = i10
            r10 = nil
          else
            r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
          end
          s8 << r10
        end
        if s8.last
          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
          r8.extend(HexVal0)
        else
          @index = i8
          r8 = nil
        end
        if r8
          s7 << r8
        else
          break
        end
      end
      if s7.empty?
        @index = i7
        r7 = nil
      else
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
      end
      s6 << r7
      if s6.last
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        r6.extend(HexVal1)
      else
        @index = i6
        r6 = nil
      end
      if r6
        r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
        r5 = r6
      else
        i12, s12 = index, []
        i13, s13 = index, []
        if (match_len = has_terminal?("-", false, index))
          r14 = true
          @index += match_len
        else
          terminal_parse_failure('"-"')
          r14 = nil
        end
        s13 << r14
        if r14
          s15, i15 = [], index
          loop do
            r16 = _nt_HEXDIG
            if r16
              s15 << r16
            else
              break
            end
          end
          if s15.empty?
            @index = i15
            r15 = nil
          else
            r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
          end
          s13 << r15
        end
        if s13.last
          r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
          r13.extend(HexVal2)
        else
          @index = i13
          r13 = nil
        end
        s12 << r13
        if s12.last
          r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
          r12.extend(HexVal3)
        else
          @index = i12
          r12 = nil
        end
        if r12
          r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
          r5 = r12
        else
          @index = i5
          r5 = nil
        end
      end
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(HexVal4)
    r0.extend(HexVal5)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:hex_val][start_index] = r0

  r0
end
_nt_inline_module() click to toggle source
# File lib/abnfgrammar.rb, line 2540
def _nt_inline_module
  start_index = index
  if node_cache[:inline_module].has_key?(index)
    cached = node_cache[:inline_module][index]
    if cached
      node_cache[:inline_module][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_inline_module1
  r1.extend(InlineModule0)
  r1.extend(InlineModule0)
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('', false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      r2.extend(InlineModule1)
      @index += match_len
    else
      terminal_parse_failure('\'\'')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:inline_module][start_index] = r0

  r0
end
_nt_inline_module1() click to toggle source
# File lib/abnfgrammar.rb, line 2427
def _nt_inline_module1
  start_index = index
  if node_cache[:inline_module1].has_key?(index)
    cached = node_cache[:inline_module1][index]
    if cached
      node_cache[:inline_module1][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?('{', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('\'{\'')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3 = index
      r4 = _nt_inline_module1
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r3 = r4
      else
        i5, s5 = index, []
        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
          @index = i6
          r6 = nil
          terminal_parse_failure('[{}]', true)
        else
          @terminal_failures.pop
          @index = i6
          r6 = instantiate_node(SyntaxNode,input, index...index)
        end
        s5 << r6
        if r6
          if index < input_length
            r8 = true
            @index += 1
          else
            terminal_parse_failure("any character")
            r8 = nil
          end
          s5 << r8
        end
        if s5.last
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          r5.extend(InlineModule10)
        else
          @index = i5
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r3 = r5
        else
          @index = i3
          r3 = nil
        end
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if (match_len = has_terminal?('}', false, index))
        r9 = true
        @index += match_len
      else
        terminal_parse_failure('\'}\'')
        r9 = nil
      end
      s0 << r9
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(InlineModule11)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:inline_module1][start_index] = r0

  r0
end
_nt_num_val() click to toggle source
# File lib/abnfgrammar.rb, line 1133
def _nt_num_val
  start_index = index
  if node_cache[:num_val].has_key?(index)
    cached = node_cache[:num_val][index]
    if cached
      node_cache[:num_val][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?("%", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"%"')
    r1 = nil
  end
  s0 << r1
  if r1
    i2 = index
    r3 = _nt_bin_val
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r2 = r3
    else
      r4 = _nt_dec_val
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r2 = r4
      else
        r5 = _nt_hex_val
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r2 = r5
        else
          @index = i2
          r2 = nil
        end
      end
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NumVal0)
    r0.extend(NumVal1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:num_val][start_index] = r0

  r0
end
_nt_option() click to toggle source
# File lib/abnfgrammar.rb, line 1062
def _nt_option
  start_index = index
  if node_cache[:option].has_key?(index)
    cached = node_cache[:option][index]
    if cached
      node_cache[:option][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?("[", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"["')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_c_wsp
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      r4 = _nt_alternation
      s0 << r4
      if r4
        if (match_len = has_terminal?("]", false, index))
          r5 = true
          @index += match_len
        else
          terminal_parse_failure('"]"')
          r5 = nil
        end
        s0 << r5
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Option0)
    r0.extend(Option1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:option][start_index] = r0

  r0
end
_nt_prose_val() click to toggle source
# File lib/abnfgrammar.rb, line 1808
def _nt_prose_val
  start_index = index
  if node_cache[:prose_val].has_key?(index)
    cached = node_cache[:prose_val][index]
    if cached
      node_cache[:prose_val][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?("<", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"<"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[ -=?-~]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[ -=?-~]')
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if (match_len = has_terminal?(">", false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('">"')
        r4 = nil
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ProseVal0)
    r0.extend(ProseVal1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:prose_val][start_index] = r0

  r0
end
_nt_quoted_string() click to toggle source
# File lib/abnfgrammar.rb, line 2370
def _nt_quoted_string
  start_index = index
  if node_cache[:quoted_string].has_key?(index)
    cached = node_cache[:quoted_string][index]
    if cached
      node_cache[:quoted_string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_DQUOTE
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[ !#-~]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[ !#-~]')
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      r4 = _nt_DQUOTE
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(QuotedString0)
    r0.extend(QuotedString1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:quoted_string][start_index] = r0

  r0
end
_nt_repeat_c() click to toggle source
# File lib/abnfgrammar.rb, line 831
def _nt_repeat_c
  start_index = index
  if node_cache[:repeat_c].has_key?(index)
    cached = node_cache[:repeat_c][index]
    if cached
      node_cache[:repeat_c][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
    r3 = _nt_DIGIT
    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
        r6 = _nt_DIGIT
        if r6
          s5 << r6
        else
          break
        end
      end
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
      s1 << r5
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(RepeatC0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
    r0.extend(RepeatC1)
    r0.extend(RepeatC1)
  else
    s7, i7 = [], index
    loop do
      r8 = _nt_DIGIT
      if r8
        s7 << r8
      else
        break
      end
    end
    r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
    if r7
      r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
      r0 = r7
      r0.extend(RepeatC1)
      r0.extend(RepeatC1)
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:repeat_c][start_index] = r0

  r0
end
_nt_repetition() click to toggle source
# File lib/abnfgrammar.rb, line 769
def _nt_repetition
  start_index = index
  if node_cache[:repetition].has_key?(index)
    cached = node_cache[:repetition][index]
    if cached
      node_cache[:repetition][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_repeat_c
  s0 << r1
  if r1
    r2 = _nt_element
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Repetition0)
    r0.extend(Repetition1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:repetition][start_index] = r0

  r0
end
_nt_rulelist() click to toggle source
# File lib/abnfgrammar.rb, line 15
def _nt_rulelist
  start_index = index
  if node_cache[:rulelist].has_key?(index)
    cached = node_cache[:rulelist][index]
    if cached
      node_cache[:rulelist][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    i1 = index
    r2 = _nt_abnf_rule
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r1 = r2
    else
      r3 = _nt_empty_line
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r1 = r3
      else
        @index = i1
        r1 = nil
      end
    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)
    r0.extend(Rulelist0)
    r0.extend(Rulelist0)
  end

  node_cache[:rulelist][start_index] = r0

  r0
end
_nt_rulename() click to toggle source
# File lib/abnfgrammar.rb, line 187
def _nt_rulename
  start_index = index
  if node_cache[:rulename].has_key?(index)
    cached = node_cache[:rulename][index]
    if cached
      node_cache[:rulename][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_ALPHA
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3 = index
      r4 = _nt_ALPHA
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r3 = r4
      else
        r5 = _nt_DIGIT
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r3 = r5
        else
          if (match_len = has_terminal?("-", false, index))
            r6 = true
            @index += match_len
          else
            terminal_parse_failure('"-"')
            r6 = nil
          end
          if r6
            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
            r3 = r6
          else
            @index = i3
            r3 = nil
          end
        end
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Rulename0)
    r0.extend(Rulename1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:rulename][start_index] = r0

  r0
end
root() click to toggle source
# File lib/abnfgrammar.rb, line 7
def root
  @root ||= :rulelist
end