Unify all stacks. Passes tests, but needs cleanup.

newstack.h

@@ -0,0 +1,103 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+struct determine_alignment {
+  char x;
+  union {
+    int i;
+    double d;
+    uint64_t u64;
+    size_t sz;
+    void* ptr;
+  } u;
+};
+
+enum {ALIGNMENT = offsetof(struct determine_alignment, u)};
+
+size_t align_round_up(size_t sz) {
+  return ((sz + (ALIGNMENT - 1)) / ALIGNMENT) * ALIGNMENT;
+}
+
+typedef int stack_ptr;
+
+struct stack {
+  char* mem_end; // one-past-the-end of allocated region
+  stack_ptr bound;
+  stack_ptr limit; // 0 - stack is empty
+};
+
+void stack_init(struct stack* s) {
+  s->mem_end = 0;
+  s->bound = ALIGNMENT;
+  s->limit = 0;
+}
+
+void stack_free(struct stack* s) {
+  char* mem_start = s->mem_end - ( -s->bound + ALIGNMENT);
+  free(mem_start);
+  stack_init(s);
+}
+
+stack_ptr stack_top(struct stack* s) {
+  return s->limit;
+}
+
+int stack_pop_will_free(struct stack* s, stack_ptr p) {
+  return p == s->limit;
+}
+
+void* stack_block(struct stack* s, stack_ptr p) {
+  return (void*)(s->mem_end + p);
+}
+
+stack_ptr* stack_block_next(struct stack* s, stack_ptr p) {
+  return &(((stack_ptr*)stack_block(s, p))[-1]);
+}
+
+void stack_reallocate(struct stack* s, size_t sz) {
+  int old_mem_length = -(s->bound) + ALIGNMENT;
+  char* old_mem_start = s->mem_end - old_mem_length;
+  
+  int new_mem_length = align_round_up((old_mem_length + sz + 256) * 2);
+  char* new_mem_start = realloc(old_mem_start, new_mem_length);
+  memmove(new_mem_start + (new_mem_length - old_mem_length),
+            new_mem_start, old_mem_length);
+  s->mem_end = new_mem_start + new_mem_length;
+  s->bound = -(new_mem_length - ALIGNMENT);
+}
+
+stack_ptr stack_push_block(struct stack* s, stack_ptr p, size_t sz) {
+  int alloc_sz = align_round_up(sz) + ALIGNMENT;
+  stack_ptr r = s->limit - alloc_sz;
+  if (r < s->bound) {
+    stack_reallocate(s, alloc_sz);
+  }
+  s->limit = r;
+  *stack_block_next(s, r) = p;
+  return r;
+}
+
+stack_ptr stack_pop_block(struct stack* s, stack_ptr p, size_t sz) {
+  stack_ptr r = *stack_block_next(s, p);
+  if (p == s->limit) {
+    int alloc_sz = align_round_up(sz) + ALIGNMENT;
+    s->limit += alloc_sz;
+  }
+  return r;
+}
+
+#if 0
+int main() {
+  stack s;
+  stack_init(&s);
+  stack_ptr top = 0;
+  top = stack_push_block(&s, top, sizeof(double));
+  double* d1 = stack_block(&s, top);
+  *d1 = 42;
+  top = stack_push_block(&s, top, sizeof(double));
+  double* d2 = stack_block(&s, top);
+  *d2 = 33;
+
+}
+#endif