small changes to editDistance

[ghost]

the first change prevents checking the null byte (which is not secure when it occurs inside the string and should be changed anyways).

the second change removes a tautologic check:
at line 1905 len1 is still always <= len2 because the same operations where done to both and at the begin len1 is also definetly <= len2.
Especially this means that if len1 > 0 also len2 > 0 is always true.

[Araq]

Don't remove this check. Invariant or not, this check makes things easier to read / ensure it's correct / maintainable.

[data-man]

Please, test this:

proc editDistanceNew*(a, b: string): int =
  ## Returns the edit distance between `a` and `b`.
  ##
  ## This uses the `Levenshtein`:idx: distance algorithm with only a linear
  ## memory overhead.  This implementation is highly optimized!
  var 
    aLen = a.len
    bLen = b.len
  if aLen > bLen:
    # make `b` the longer sequence
    return editDistanceNew(b, a)

  # skip common prefix:
  var s = 0
  while s < aLen and a[s] == b[s]:
    inc(s)
    dec(aLen)
    dec(bLen)

  # skip common suffix:
  while aLen > 0 and bLen > 0 and a[s+aLen-1] == b[s+bLen-1]:
    dec(aLen)
    dec(bLen)

  # trivial cases:
  if aLen == 0: return bLen
  if bLen == 0: return aLen

  # another special case:
  if aLen == 1:
    for j in s..s+bLen-1:
      if a[s] == b[j]: return bLen - 1

    return bLen

  inc(aLen)
  inc(bLen)
  var row: seq[int]
  newSeq(row, bLen)

  for i in 0..bLen - 1: row[i] = i

  for i in 1 .. aLen- 1:
    var char1 = a[s + i - 1]
    var prevCost = i - 1
    var newCost = i

    for j in 1 .. bLen - 1:
      var char2 = b[s + j - 1]

      if char1 == char2:
        newCost = prevCost
      else:
        newCost = min(newCost, min(prevCost, row[j])) + 1

      prevCost = row[j]
      row[j] = newCost

  result = row[bLen - 1]

[Araq]

This was done in the "access the null terminator is now error" commits.