--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/anagram/agcore/arrays.cpp	Sat Dec 22 17:52:45 2007 -0500
@@ -0,0 +1,258 @@
+/*
+ * AnaGram, A System for Syntax Directed Programming
+ * Copyright 1993-1999 Parsifal Software. All Rights Reserved.
+ * See the file COPYING for license and usage terms.
+ *
+ * arrays.cpp - old array control module
+ */
+
+#include <string.h>
+#include "port.h"
+
+#include "arrays.h"
+#include "assert.h"
+#include "myalloc.h"
+#include "stacks.h"
+#include "tsd.h"
+
+//#define INCLUDE_LOGGING
+#include "log.h"
+
+
+#define mkstrg(n,size) \
+    (array_control_block *) \
+	(ALLOCATE(n*size + sizeof(array_control_block), char))
+
+#define remkstrg(p,n) \
+    (array_control_block *) \
+	(reallocate(p,n + sizeof(array_control_block), char))
+
+typedef struct {
+  unsigned elements_allocated;
+  unsigned element_size;
+} array_control_block;
+
+
+void *init_array(unsigned n, unsigned size) {
+  LOGSECTION("init_array");
+  LOGV(n) LCV(size);
+
+  array_control_block *p;
+  p = mkstrg(n,size);
+  p->elements_allocated = n;
+  p->element_size = size;
+  memset(++p,0,n*size);
+  return p;
+}
+
+void *reset_array_size(void *ptr, unsigned n, unsigned size) {
+  LOGSECTION("reset_array_size");
+  LOGV((int) ptr) LCV(n) LCV(size);
+  array_control_block *p;
+  if (ptr) {
+    delete_array(ptr);
+  }
+  p = mkstrg(n, size);
+  p->elements_allocated = n;
+  p->element_size = size;
+  memset(++p, 0, n*size);
+  LOGV((int) p) LCV(n) LCV(size);
+  return p;
+}
+
+void *reset_array(void *a) {
+  array_control_block *p;
+  unsigned n, size;
+  unsigned k;
+
+  p = (array_control_block *) a;
+  p--;
+  ok_ptr(p);
+  n = p->elements_allocated;
+  size = p->element_size;
+  k = n*size;
+  size_ok(p, k+sizeof(array_control_block), __FILE__, __LINE__);
+  memset(++p,0,k);
+  return p;
+}
+
+void *delete_array(void *a) {
+  array_control_block *p;
+
+  p = (array_control_block *) a;
+  p--;
+  DEALLOCATE(p);
+  return NULL;
+}
+
+static int array_ok(void *ptr) {
+  array_control_block *p;
+
+  p = (array_control_block *) ptr;
+  p--;
+  return ptr_ok(p);
+}
+
+#if 0 /* unused */
+void *slide_array(void *ptr) {
+  array_control_block *p = (array_control_block *) ptr, *q;
+  unsigned size;
+
+  p--;
+  ok_ptr(p);
+  size = p->elements_allocated * p->element_size + sizeof(array_control_block);
+  q = (array_control_block *) reallocate(p,size, char);
+  q++;
+  return (void *) q;
+}
+#endif
+
+int ok_index(void *ptr, unsigned x) {
+  LOGSECTION("ok_index");
+  array_control_block *p = (array_control_block *) ptr;
+  p--;
+  ok_ptr(p);
+  LOGV(x) LCV(p->elements_allocated);
+  return x < p->elements_allocated;
+}
+
+void *check_array_size(void *ptr, unsigned n1, unsigned n) {
+  LOGSECTION("check_array_size");
+  LOGV((int) ptr) LCV(n1) LCV(n);
+  array_control_block *p = (array_control_block *) ptr;
+  unsigned kp,kn;
+//  unsigned long lim;
+//  unsigned min;
+
+  p--;
+  ok_ptr(p);
+  LOGV(p->elements_allocated);
+  if (n1 + 1 < (kp = p->elements_allocated)) {
+    return ptr;
+  }
+  n1 += 2;
+  if (n < n1) {
+    n = n1;
+  }
+  kn = p->element_size;
+  //min = n1*kn;
+  kp *= kn;
+
+  //lim = (MAX_BYTES - sizeof(array_control_block))/kn;
+  //if (lim < n1) {
+  //  no_mem(kp);
+  //}
+
+  LOGV(n) LCV(n1) LCV(p->element_size);  // LCV(lim);
+
+  //if (n > lim) {
+  //  n = (unsigned) lim;
+  //}
+
+  assert(n >= n1);
+  kn *= n;
+/*
+  p = (array_control_block *) vrealloc(p,
+               min + sizeof(array_control_block),
+               kn + sizeof(array_control_block), &n);
+*/
+  p = remkstrg(p, kn);
+  LOGV(kn) LCV(p->element_size);
+  //n -= sizeof(array_control_block);
+  p->elements_allocated = kn/p->element_size;
+  LOGV(p->elements_allocated);
+  assert(p->elements_allocated >= n1);
+  p++;
+  if (kn > kp) {
+    memset((char *)p + kp, 0, kn - kp);
+  }
+  LOGV(kn) LCV(kp);
+  LOGV((int) ((char *)p + kp)) LCV(kn-kp);
+  return p;
+}
+
+void *set_array_size(void *ptr, unsigned n) {
+  array_control_block *p = (array_control_block *) ptr;
+  unsigned kp,kn;
+
+  p--;
+  ok_ptr(p);
+  kp = p->elements_allocated;
+  if (kp == n) {
+    return ptr;
+  }
+  kn = p->element_size;
+  kp *= kn;
+  kn *= n;
+  p = remkstrg(p, kn);
+  p->elements_allocated = n;
+  p++;
+  if (kn > kp) {
+    memset((char *)p + kp, 0, kn - kp);
+  }
+  return p;
+}
+
+static unsigned *init_list(int n) {
+  LOGSECTION("init_list");
+  LOGV(n);
+  unsigned *list = (unsigned *) init_array(n+1, sizeof(*list));
+  list[0] = 1;
+  return list;
+}
+
+unsigned *reset_list(unsigned *list, unsigned n) {
+  LOGSECTION("reset_list");
+  LOGV(list ? list[0] : 0) LCV(n);
+  unsigned *new_array = init_list(n);
+  new_array[0] = 1;
+  if (list) {
+    delete_array(list);
+  }
+  return new_array;
+}
+
+void *check_list_size(unsigned *list, unsigned n) {
+  LOGSECTION("check_list_size");
+  LOGV(list[0]) LCV(n);
+  n += list[0];
+  return check_array_size(list,n,n+n/2);
+}
+
+static unsigned add_data_list(unsigned *list, unsigned *data, unsigned n) {
+  unsigned k = list[0];
+  memmove(list+k, data, n*sizeof(*list));
+  list[0] += n;
+  array_ok(list);
+  return k;
+}
+
+int store_list_data(unsigned *list) {
+  LOGSECTION("store_list_data");
+  unsigned n = tis();
+  LOGV(list[0]) LCV(n);
+  if (n == 0) {
+    return 0;
+  }
+  return add_data_list(list, (unsigned *) list_base, n);
+}
+
+int store_tuple_data(tsd *t, unsigned *list) {
+  unsigned n = t->nt * t->tw;
+  if (n == 0) {
+    return 0;
+  }
+  return add_data_list(list, (unsigned *)t->sb, n);
+}
+/*
+void *shrink_fit(unsigned *list) {
+  return set_array_size(list, list[0]);
+}
+*/
+
+void *check_local_array(void *p) {
+  assert(p != NULL);
+  return p;
+}
+
+/* End ARRAYS.C */