Fix memory leaks

include/vase/shard.h

@@ -17,44 +17,24 @@ struct Shard {
   std::atomic_uint32_t refs;
 
   Shard(ShardKind kind, uint32_t length, uint32_t lines, uint8_t height)
-      : kind(kind), length(length), lines(lines), height(height), refs(0) {};
+      : kind(kind), length(length), lines(lines), height(height), refs(1) {};
 
   virtual ~Shard() = default;
-};
 
-struct ShardPtr {
-  Shard *ptr;
-
-  ShardPtr(const ShardPtr &other) : ptr(other.ptr) {
-    if (ptr)
-      ptr->refs++;
+  static void retain(Shard *n) {
+    n->refs++;
   }
 
-  ShardPtr &operator=(const ShardPtr &other) {
-    if (ptr == other.ptr)
-      return *this;
-    if (ptr && --ptr->refs == 0)
-      delete ptr;
-    ptr = other.ptr;
-    if (ptr)
-      ptr->refs++;
-    return *this;
-  }
-
-  ShardPtr(Shard *p = nullptr) : ptr(p) {
-    if (ptr)
-      ptr->refs++;
-  }
-
-  ~ShardPtr() {
-    if (ptr && --ptr->refs == 0)
-      delete ptr;
+  static void release(Shard *n) {
+    if (!n || --n->refs > 0)
+      return;
+    delete n;
   }
 };
 
 struct Branch : Shard {
-  ShardPtr left;
-  ShardPtr right;
+  Shard *left;
+  Shard *right;
 
   Branch(Shard *l, Shard *r)
       : Shard(
@@ -63,7 +43,15 @@ struct Branch : Shard {
           l->lines + r->lines,
           1 + std::max(l->height, r->height)
         ),
-        left(l), right(r) {};
+        left(l), right(r) {
+    retain(left);
+    retain(right);
+  };
+
+  ~Branch() {
+    release(left);
+    release(right);
+  }
 };
 
 struct Petal : Shard {
@@ -76,10 +64,10 @@ struct Petal : Shard {
         source(source), pos(pos) {};
 };
 
-std::pair<ShardPtr, ShardPtr> split_shard(Shard *n, uint32_t offset);
-ShardPtr concat_shard(ShardPtr left, ShardPtr right);
-ShardPtr merge(Shard *a, Shard *b);
-ShardPtr merge_leaves(Shard *a, Shard *b);
-ShardPtr append_leaf(Shard *root, Shard *leaf);
+std::pair<Shard *, Shard *> split_shard(Shard *n, uint32_t offset);
+Shard *concat_shard(Shard *left, Shard *right);
+Shard *merge(Shard *a, Shard *b);
+Shard *merge_leaves(Shard *a, Shard *b);
+Shard *append_leaf(Shard *root, Shard *leaf);
 
 void print_shard(const Shard *shard, int depth = 0);

include/vase/vase.h

@@ -9,41 +9,80 @@ struct Vase {
   OriginalBuffer original;
   AppendBuffer append;
 
-  std::vector<ShardPtr> undo;
+  /*std::vector<Shard *> undo; // TODO: later
   uint8_t top; // of the undo stack.
-  uint8_t max; // for redo when no edits have been done after some undo.
+  uint8_t max; // for redo when no edits have been done after some undo.*/
 
-  ShardPtr root;
+  Shard *root;
 
   Vase(char *data, uint32_t length) : original(data, length), append() {
     root = new Petal(length, original.newlines.size(), &original, 0);
   }
 
+  ~Vase() {
+    Shard::release(root);
+  }
+
   uint32_t length() {
-    return root.ptr->length;
+    return root->length;
   }
 
   std::string to_string() {
     std::string out;
-    flatten(root.ptr, out);
+    flatten(root, out);
     return out;
   }
 
   void type(uint32_t offset, char key) {
     uint32_t pos = append.key(key);
-    ShardPtr inserted = new Petal(1, key == '\n', &append, pos);
-    auto [left, right] = split_shard(root.ptr, offset);
-    left = append_leaf(left.ptr, inserted.ptr);
-    root = concat_shard(left, right);
+    Shard *inserted = new Petal(1, key == '\n', &append, pos);
+    auto [left, right] = split_shard(root, offset);
+    Shard *left2 = append_leaf(left, inserted);
+    Shard *new_root = concat_shard(left2, right);
+    Shard::release(left);
+    Shard::release(right);
+    Shard::release(left2);
+    Shard::release(inserted);
+    Shard::release(root);
+    root = new_root;
   }
 
   void insert(uint32_t offset, const char *data, uint32_t len) {
     uint32_t lines = 0;
     uint32_t pos = append.append(data, len, &lines);
-    ShardPtr inserted = new Petal(len, lines, &append, pos);
-    auto [left, right] = split_shard(root.ptr, offset);
-    left = append_leaf(left.ptr, inserted.ptr);
-    root = concat_shard(left, right);
+    Shard *inserted = new Petal(len, lines, &append, pos);
+    auto [left, right] = split_shard(root, offset);
+    Shard *left2 = append_leaf(left, inserted);
+    Shard *new_root = concat_shard(left2, right);
+    Shard::release(left);
+    Shard::release(right);
+    Shard::release(left2);
+    Shard::release(inserted);
+    Shard::release(root);
+    root = new_root;
+  }
+
+  void erase(uint32_t cursor, int64_t amount) {
+    if (amount == 0)
+      return;
+    uint32_t start;
+    uint32_t count;
+    if (amount < 0) {
+      count = std::min<uint32_t>(-amount, cursor);
+      start = cursor - count;
+    } else {
+      start = cursor;
+      count = amount;
+    }
+    auto [a, b] = split_shard(root, start);
+    auto [d, c] = split_shard(b, count);
+    Shard *new_root = concat_shard(a, c);
+    Shard::release(a);
+    Shard::release(b);
+    Shard::release(c);
+    Shard::release(d);
+    Shard::release(root);
+    root = new_root;
   }
 
   void flatten(Shard *s, std::string &out) {
@@ -61,8 +100,8 @@ struct Vase {
       }
     } else {
       auto *b = static_cast<Branch *>(s);
-      flatten(b->left.ptr, out);
-      flatten(b->right.ptr, out);
+      flatten(b->left, out);
+      flatten(b->right, out);
     }
   }
 };