Remove static radix tree and small/full builds

Static radix tree was a hack to begin with and I don't want to deal with
it anymore. I might consider small/full builds later on but let's be
honest here, it's premature optimization.

5 files changed, 32 insertions, 208 deletions

diff --git a/makefile b/makefile
index 3b038c16..1686ac64 100644
--- a/makefile
+++ b/makefile
@@ -3,12 +3,10 @@ FLAGS = -d:ssl -o:twt
 FILES = src/main.nim
 
 debug:
-	$(NIMC) $(FLAGS) -d:small $(FILES)
-small:
-	$(NIMC) $(FLAGS) -d:danger $(FILES)
+	$(NIMC) $(FLAGS) $(FILES)
 release:
-	$(NIMC) $(FLAGS) -d:release -d:full $(FILES)
+	$(NIMC) $(FLAGS) -d:release $(FILES)
 danger:
-	$(NIMC) $(FLAGS) -d:danger -d:full $(FILES)
+	$(NIMC) $(FLAGS) -d:danger $(FILES)
 clean:
 	rm ./twt
diff --git a/src/html/entity.nim b/src/html/entity.nim
index 79c57ca0..72c5c452 100644
--- a/src/html/entity.nim
+++ b/src/html/entity.nim
@@ -3,26 +3,15 @@ import json
 import ../utils/radixtree
 
 const entity = staticRead"../../res/entity.json"
-when defined(small):
-  proc genEntityMap(data: seq[tuple[a: string, b: string]]): RadixNode[string] =
-    result = newRadixTree[string]()
-    for pair in data:
-      result[pair.a] = pair.b
+proc genEntityMap(data: seq[tuple[a: string, b: string]]): RadixNode[string] =
+  result = newRadixTree[string]()
+  for pair in data:
+    result[pair.a] = pair.b
 
-  proc genEntityTable(): seq[tuple[a: string, b: string]] =
-    let entityJson = parseJson(entity)
+proc genEntityTable(): seq[tuple[a: string, b: string]] =
+  let entityJson = parseJson(entity)
 
-    for k, v in entityJson:
-      result.add((k.substr(1), v{"characters"}.getStr()))
-  const entityTable = genEntityTable()
-  let entityMap* = genEntityMap(entityTable)
-else:
-  proc genEntityMap(): StaticRadixTree[string] =
-    let entityJson = parseJson(entity)
-    var entityMap = newStaticRadixTree[string]()
-
-    for k, v in entityJson:
-      entityMap[k.substr(1)] = v{"characters"}.getStr()
-
-    return entityMap
-  const entityMap* = genEntityMap()
+  for k, v in entityJson:
+    result.add((k.substr(1), v{"characters"}.getStr()))
+const entityTable = genEntityTable()
+let entityMap* = genEntityMap(entityTable)
diff --git a/src/html/htmlparser.nim b/src/html/htmlparser.nim
index 67aec2e4..94c474f0 100644
--- a/src/html/htmlparser.nim
+++ b/src/html/htmlparser.nim
@@ -89,38 +89,21 @@ proc getescapecmd(buf: string, at: var int): string =
   elif not isAlphaAscii(buf[i]):
     return ""
 
-  when defined(full):
-    var n = 0
-    var s = ""
-    while true:
-      s &= buf[i]
-      if not entityMap.hasPrefix(s, n):
-        break
-      let pn = n
-      n = entityMap{s, n}
-      if n != pn:
-        s = ""
-      inc i
-
-    if entityMap.nodes[n].leaf:
-      at = i
-      return entityMap.nodes[n].value
-  else:
-    var n = entityMap
-    var s = ""
-    while true:
-      s &= buf[i]
-      if not entityMap.hasPrefix(s, n):
-        break
-      let pn = n
-      n = n{s}
-      if n != pn:
-        s = ""
-      inc i
+  var n = entityMap
+  var s = ""
+  while true:
+    s &= buf[i]
+    if not entityMap.hasPrefix(s, n):
+      break
+    let pn = n
+    n = n{s}
+    if n != pn:
+      s = ""
+    inc i
 
-    if n.leaf:
-      at = i
-      return n.value
+  if n.leaf:
+    at = i
+    return n.value
 
   return ""
 
diff --git a/src/utils/radixtree.nim b/src/utils/radixtree.nim
index 0601eeba..dd0a6a1d 100644
--- a/src/utils/radixtree.nim
+++ b/src/utils/radixtree.nim
@@ -14,20 +14,6 @@ type
     of true: value*: T
     of false: discard
 
-  StaticRadixPair = tuple[k: string, v: int]
-
-  StaticRadixNode[T] = object
-    children*: seq[StaticRadixPair]
-    case leaf*: bool
-    of true: value*: T
-    of false: discard
-
-  StaticRadixTree*[T] = object
-    nodes*: seq[StaticRadixNode[T]]
-
-func newStaticRadixTree*[T](): StaticRadixTree[T] =
-  result.nodes.add(StaticRadixNode[T](leaf: false))
-
 func newRadixTree*[T](): RadixNode[T] =
   new(result)
 
@@ -38,21 +24,6 @@ func toRadixTree*[T](table: Table[string, T]): RadixNode[T] =
 
 # getOrDefault: we have to compare the entire string but if it doesn't match
 # exactly we can just return default.
-func getOrDefault(pairseq: seq[StaticRadixPair], k: string, default: int): int =
-  var i = 0
-  while i < pairseq.len:
-    if pairseq[i].k[0] == k[0]:
-      if k.len != pairseq[i].k.len:
-        return default
-      var j = 1
-      while j < k.len:
-        if pairseq[i].k[j] != k[j]:
-          return default
-        inc j
-      return pairseq[i].v
-    inc i
-  return default
-
 func getOrDefault[T](node: RadixNode[T], k: string, default: RadixNode[T]): RadixNode[T] =
   var i = 0
   while i < node.children.len:
@@ -68,33 +39,12 @@ func getOrDefault[T](node: RadixNode[T], k: string, default: RadixNode[T]): Radi
     inc i
   return default
 
-iterator keys(pairseq: seq[StaticRadixPair]): string =
-  var i = 0
-  while i < pairseq.len:
-    yield pairseq[i].k
-    inc i
-
 iterator keys*[T](node: RadixNode[T]): string =
   var i = 0
   while i < node.children.len:
     yield node.children[i].k
     inc i
 
-func contains(pairseq: seq[StaticRadixPair], k: string): bool =
-  var i = 0
-  while i < pairseq.len:
-    if pairseq[i].k[0] == k[0]:
-      if k.len != pairseq[i].k.len:
-        return false
-      var j = 1
-      while j < k.len:
-        if pairseq[i].k[j] != k[j]:
-          return false
-        inc j
-      return true
-    inc i
-  return false
-
 func contains[T](node: RadixNode[T], k: string): bool =
   var i = 0
   while i < node.children.len:
@@ -110,74 +60,6 @@ func contains[T](node: RadixNode[T], k: string): bool =
     inc i
   return false
 
-# Static insert
-proc `[]=`*[T](tree: var StaticRadixTree[T], key: string, value: T) =
-  var n = 0
-  var p = 0
-  var i = 0
-  var j = 0
-  var k = 0
-  var t = ""
-  # find last matching node
-  var conflict = false
-  while i < key.len:
-    let m = i
-    var o = 0
-    for pk in tree.nodes[n].children.keys:
-      if pk[0] == key[i]:
-        var l = 0
-        while l < pk.len and i + l < key.len:
-          if pk[l] != key[i + l]:
-            conflict = true
-            break
-          inc l
-        p = n
-        k = o
-        n = tree.nodes[n].children[k].v
-        t &= pk
-        i += l
-        if not conflict and pk.len == l:
-          j = i
-        break
-      inc o
-    if i == m:
-      break
-    if conflict:
-      break
-
-  # if first node, just add normally
-  if n == 0:
-    tree.nodes.add(StaticRadixNode[T](leaf: true, value: value))
-    tree.nodes[n].children.add((k: key, v: int(tree.nodes.len - 1)))
-  elif conflict:
-    # conflict somewhere, so:
-    # * add new non-leaf to parent
-    # * add old to non-leaf
-    # * add new to non-leaf
-    # * remove old from parent
-    tree.nodes[p].children.add((k: key.substr(j, i - 1), v: int(tree.nodes.len)))
-    tree.nodes.add(StaticRadixNode[T](leaf: false))
-    tree.nodes[^1].children.add((k: t.substr(i), v: n))
-    tree.nodes[^1].children.add((k: key.substr(i), v: int(tree.nodes.len)))
-    tree.nodes.add(StaticRadixNode[T](leaf: true, value: value))
-    tree.nodes[p].children.del(k)
-  elif key.len == t.len:
-    # new matches a node, so replace
-    tree.nodes[n] = StaticRadixNode[T](leaf: true, value: value, children: tree.nodes[n].children)
-  elif i == j:
-    # new is longer than the old, so add child to old
-    tree.nodes[n].children.add((k: key.substr(i), v: int(tree.nodes.len)))
-    tree.nodes.add(StaticRadixNode[T](leaf: true, value: value))
-  else:
-    # new is shorter than old, so:
-    # * add new to parent
-    # * add old to new
-    # * remove old from parent
-    tree.nodes[p].children.add((k: key.substr(j, i - 1), v: int(tree.nodes.len)))
-    tree.nodes.add(StaticRadixNode[T](leaf: true, value: value))
-    tree.nodes[^1].children.add((k: key.substr(i), v: n))
-    tree.nodes[p].children.del(k)
-
 # O(1) add procedures for insert
 proc add[T](node: RadixNode[T], k: string, v: T) =
   node.children.add((k, RadixNode[T](leaf: true, value: v)))
@@ -188,7 +70,7 @@ proc add[T](node: RadixNode[T], k: string) =
 proc add[T](node: RadixNode[T], k: string, v: RadixNode[T]) =
   node.children.add((k, v))
 
-# Non-static insert
+# insert
 proc `[]=`*[T](tree: RadixNode[T], key: string, value: T) =
   var n = tree
   var p: RadixNode[T] = nil
@@ -256,35 +138,9 @@ proc `[]=`*[T](tree: RadixNode[T], key: string, value: T) =
     p.children[^1].v.add(t.substr(i), n)
     p.children.del(k)
 
-func `{}`*[T](tree: StaticRadixTree[T], key: string, at: int = 0): int =
-  return tree.nodes[at].children.getOrDefault(key, at)
-
 func `{}`*[T](node: RadixNode[T], key: string): RadixNode[T] =
   return node.getOrDefault(key, node)
 
-func hasPrefix*[T](tree: StaticRadixTree[T], prefix: string, at: int = 0): bool =
-  var n = at
-  var i = 0
-
-  while i < prefix.len:
-    let m = i
-    var j = 0
-    for pk in tree.nodes[n].children.keys:
-      if pk[0] == prefix[i]:
-        var l = 0
-        while l < pk.len and i + l < prefix.len:
-          if pk[l] != prefix[i + l]:
-            return false
-          inc l
-        n = tree.nodes[n].children[j].v
-        i += l
-        break
-      inc j
-    if i == m:
-      return false
-
-  return true
-
 func hasPrefix*[T](tree: RadixNode[T], prefix: string, at: RadixNode[T] = tree): bool =
   var n = at
   var i = 0
diff --git a/src/utils/twtstr.nim b/src/utils/twtstr.nim
index 29a38c59..730f8b32 100644
--- a/src/utils/twtstr.nim
+++ b/src/utils/twtstr.nim
@@ -325,12 +325,10 @@ func makewidthtable(): array[0..0x10FFFF, byte] =
     else:
       result[ucs] = 1
 
-when defined(full):
-  # store lookup table in executable
-  const width_table = makewidthtable()
-else:
-  # compute lookup table on startup
-  let width_table = makewidthtable()
+# compute lookup table on startup
+# TODO: we could have an option to store it in the executable but honestly I
+# don't see the need to
+let width_table = makewidthtable()
 
 {.push boundChecks:off.}
 func width*(r: Rune): int =