Match

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
use @pcre2_get_ovector_count_8[U32](match_data: Pointer[_Match] tag)
use @pcre2_get_startchar_8[USize](match_data: Pointer[_Match] tag)
use @pcre2_substring_length_bynumber_8[I32](match_data: Pointer[_Match] tag,
  number: U32, length: Pointer[USize])
use @pcre2_substring_copy_bynumber_8[I32](match_data: Pointer[_Match] tag,
  number: U32, buffer: Pointer[U8] tag, buf_len: Pointer[USize])
use @pcre2_substring_length_byname_8[I32](match_data: Pointer[_Match] tag,
  name: Pointer[U8] tag, length: Pointer[USize])
use @pcre2_substring_copy_byname_8[I32](match_data: Pointer[_Match] tag,
  name: Pointer[U8] tag, buffer: Pointer[U8] tag, buf_len: Pointer[USize])

primitive _Match

class Match
  """
  Contains match data for a combination of a regex and a subject.
  """
  var _match: Pointer[_Match]
  let _subject: ByteSeq
  let _size: U32

  new _create(subject: ByteSeq, m: Pointer[_Match]) =>
    """
    Store a match, a subject, and a size.
    """
    _match = m
    _subject = subject
    _size = @pcre2_get_ovector_count_8(m)

  fun size(): U32 =>
    """
    Returns the capture size of the match.
    """
    _size

  fun start_pos(): USize =>
    """
    Returns the character position of the first character in the match.
    """
    @pcre2_get_startchar_8(_match)

  fun end_pos(): USize =>
    """
    Returns the character position of the last character in the match.
    """
    var len = USize(0)
    @pcre2_substring_length_bynumber_8(_match, U32(0), addressof len)
    start_pos() + (len - 1)

  fun apply[A: (ByteSeq iso & Seq[U8] iso) = String iso](i: U32): A^ ? =>
    """
    Returns a capture by number. Raises an error if the index is out of bounds.
    """
    if i >= _size then
      error
    end

    var len = USize(0)
    var rc = @pcre2_substring_length_bynumber_8(_match, i, addressof len)
    if rc != 0 then error end
    len = len + 1

    let out = recover A(len) end
    len = out.space()
    rc = @pcre2_substring_copy_bynumber_8(_match, i, out.cpointer(),
      addressof len)
    if rc != 0 then error end
    out.truncate(len)
    out

  fun find[A: (ByteSeq iso & Seq[U8] iso) = String iso]
    (name: String box): A^ ?
  =>
    """
    Returns a capture by name. Raises an error if the named capture does not
    exist.
    """
    var len = USize(0)
    let rc =
      @pcre2_substring_length_byname_8(_match, name.cstring(),
        addressof len)

    if rc != 0 then
      error
    end

    len = len + 1
    let out = recover A(len) end
    len = out.space()

    @pcre2_substring_copy_byname_8(_match, name.cstring(), out.cpointer(),
      addressof len)
    out.truncate(len)
    out

  fun groups(): Array[String] iso^ =>
    """
    Returns all of the captured subgroups. Groups that failed to capture
    anything will contain the empty string.
    """
    let res = recover Array[String] end
    var i: U32 = 1
    while i < _size do
      try
        let g: String = apply(i)?
        res.push(g)
      else
        res.push("")
      end
      i = i + 1
    end
    res

  fun ref dispose() =>
    """
    Free the underlying PCRE2 data.
    """
    if not _match.is_null() then
      @pcre2_match_data_free_8(_match)
      _match = Pointer[_Match]
    end

  fun _final() =>
    """
    Free the underlying PCRE2 data.
    """
    if not _match.is_null() then
      @pcre2_match_data_free_8(_match)
    end