Untitled

type
  StringSlice* = ref object
    str: ref string
    start: int
    stop: int

proc `$`*(str: StringSlice): string =
  str.str[str.start .. str.stop]

proc newStringSlice*(str: string): StringSlice =
  new result
  new result.str
  # result.str = new(ref string)
  result.str[] = str
  result.start = 0
  result.stop = str.len-1

converter toStringSlice*(str: string): StringSlice =
  newStringSlice(str)

proc `[]`*(str: StringSlice, slc: HSlice[int, int or BackwardsIndex]): StringSlice =
  if slc.a < 0:
    raise newException(IndexError, "index out of bounds")
  new result
  result.str = str.str
  result.start = str.start + slc.a
  when slc.b is BackwardsIndex:
    if slc.b.int > str.len + 1:
      raise newException(RangeError, "value out of range: " & $(str.len + 1 - slc.b.int))
    result.stop = str.stop - slc.b.int + 1
  else:
    if slc.b + 1 < slc.a or slc.b > str.high:
      raise newException(IndexError, "index out of bounds")
    result.stop = str.start + slc.b

proc high*(str: StringSlice): int =
  str.stop - str.start

proc len*(str: StringSlice): int =
  str.high + 1

proc `&`*(sl1, sl2: StringSlice): StringSlice =
  newStringSlice($sl1 & $sl2)

proc startsWith*[T: StringSlice or string](str: StringSlice, sub: T): bool =
  if sub.len > str.len: return false
  when T is StringSlice:
    for i in sub.start..sub.stop:
      if str.str[i + str.start - sub.start] != sub.str[i]: return false
  else:
    for idx, c in sub:
      if str.str[idx + str.start] != c: return false
  return true

proc `==`*[T: StringSlice or string](str: StringSlice, cmp: T): bool =
  if cmp.isNil():        return false
  if str.len != cmp.len: return false
  when T is StringSlice:
    for i in cmp.start..cmp.stop:
      if str.str[i + str.start - cmp.start] != cmp.str[i]: return false
    return true
  else:
    return str.startsWith(cmp)

import strutils

proc find*(a: SkipTable, s: StringSlice, sub: string, start: Natural = 0, last: Natural = 0): int =
  ## Searches for `sub` in `s` inside range `start`..`last` using preprocessed table `a`.
  ## If `last` is unspecified, it defaults to `s.high`.
  ##
  ## Searching is case-sensitive. If `sub` is not in `s`, -1 is returned.
  let
    last = if last==0: s.high else: last
    m = len(sub)
    n = last + 1
  # search:
  var j = start
  while j <= n - m:
    block match:
      for k in 0..m-1:
        if sub[k] != s.str[s.start + k+j]: break match
      return j
    inc(j, a[s.str[s.start + j+m]])
  return -1

when not (defined(js) or defined(nimdoc) or defined(nimscript)):
  proc c_memchr(cstr: pointer, c: char, n: csize): pointer {.
                importc: "memchr", header: "<string.h>" .}
  const hasCStringBuiltin = true
else:
  const hasCStringBuiltin = false

proc find*(s: StringSlice, sub: char, start: Natural = 0, last: Natural = 0): int =
  ## Searches for `sub` in `s` inside range `start`..`last`.
  ## If `last` is unspecified, it defaults to `s.high`.
  ##
  ## Searching is case-sensitive. If `sub` is not in `s`, -1 is returned.
  let last = if last==0: s.high else: last
  when nimvm:
    for i in start..last:
      if sub == s.str[s.start + i]: return i
  else:
    when hasCStringBuiltin:
      let found = c_memchr(s.str[s.start + start].unsafeAddr, sub, last-start+1)
      if not found.isNil:
        return cast[ByteAddress](found) -% cast[ByteAddress](s.str[s.start])
    else:
      for i in start..last:
        if sub == s.str[s.start + i]: return i
  return -1

proc find*(s: StringSlice, sub: string, start: Natural = 0, last: Natural = 0): int =
  ## Searches for `sub` in `s` inside range `start`..`last`.
  ## If `last` is unspecified, it defaults to `s.high`.
  ##
  ## Searching is case-sensitive. If `sub` is not in `s`, -1 is returned.
  if sub.len > s.len:
    return -1

  if sub.len == 1:
    return find(s, sub[0], start, last)

  var a {.noinit.}: SkipTable
  initSkipTable(a, sub)
  result = find(a, s, sub, start, last)

proc find*(s, sub: StringSlice): int =
  s.find($sub)

proc strip*(s: StringSlice, first = true, last = true): StringSlice =
  new result
  result.str = s.str
  result.start = s.start
  result.stop = s.stop
  if first:
    for i in result.start..result.stop:
      if not (result.str[i] in Whitespace): break
      result.start += 1
  if last:
    for i in countdown(result.stop, result.start):
      if not (result.str[i] in Whitespace): break
      result.stop -= 1

iterator items*(a: StringSlice): char =
  for i in a.start..a.stop:
    yield a.str[i]

proc testStuff() =
  var s = newStringSlice("Hello world")
  var x = s[0 .. ^1][1 .. ^2][0 .. ^1]
  s.str[][5] = 'c'
  echo x
  echo x.startsWith("elloc")
  echo s.high
  echo s.find("worl")
  echo x.find("work")

static:
  echo("--compiletime--")
  teststuff()

echo("--runtime--")
testStuff()