--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/anagram/agcore/stacks.cpp	Sat Dec 22 17:52:45 2007 -0500
@@ -0,0 +1,853 @@
+/*
+ * AnaGram, A System for Syntax Directed Programming
+ * Copyright 1993-2002 Parsifal Software. All Rights Reserved.
+ * See the file COPYING for license and usage terms.
+ *
+ * stacks.cpp
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include "port.h"
+
+#ifdef VACLGUI
+#include <icritsec.hpp>
+#include "resource.h"
+#endif
+
+#include "agstring.h"
+#include "assert.h"
+#include "dict.h"
+#include "myalloc.h"
+#include "stacks.h"
+
+//#define INCLUDE_LOGGING
+#include "log.h"
+
+
+#define cs char_strings_base
+#define ws word_strings_base
+#define ls long_strings_base
+#define is int_stack_base
+#define ni int_stack_top
+
+static char *cs;
+static int  *ws;
+static int  *is;
+static unsigned lcs,lws, lis;
+unsigned ni;
+unsigned nc;
+unsigned nw;
+static unsigned lcx;
+static unsigned lwx;
+static unsigned llx;
+char *string_base;
+int *list_base;
+
+#ifdef VACLGUI
+static AgResource charStackResource;
+#endif
+
+
+void init_stk(void) {
+  LOGSECTION("init_stk");
+  lcs = 100;
+  lws = 100;
+  lis = 20;
+  cs = (char *) myalloc(lcs);
+  ws = (int *) myalloc(lws * sizeof(*ws));
+  is = (int *) myalloc((lis+1) * sizeof(*is));
+  nc = nw = ni = lcx = lwx = llx = 0;
+}
+
+/*
+void logStringStack() {
+  //LOGSECTION("Stack status");
+  log.line() << nc << nw << ni;
+  log.line() << lcs << lws << lis;
+}
+*/
+/*
+void delete_stack(void) {
+  DEALLOCATE(cs);
+  DEALLOCATE(ws);
+  DEALLOCATE(is);
+}
+*/
+/*
+void slide_stack(void) {
+  cs = (char *) myrealloc(cs, lcs, __FILE__, __LINE__);
+  ws = (int *) myrealloc(ws, lws * sizeof(*ws), __FILE__, __LINE__);
+  is = (int *) myrealloc(is, (lis+1) * sizeof(*is), __FILE__, __LINE__);
+}
+*/
+void reset_stk(void) {
+  nc = nw = ni = lcx = lwx = llx = 0;
+}
+
+/*
+void slns(const char *s) {            / * extract line from string * /
+  int n;
+  const char *sp;
+
+  ics();
+  n = 0;
+	if (s) for (sp = s; *sp && *sp != '\n'; sp++) {
+		if (*sp == '\t') do acs(' '); while (++n % tab_spacing);
+		else acs(*sp), n++;
+	}
+	cs[nc] = 0;
+}
+*/
+
+char *string_space(int n) {
+  if (nc + n >= lcs) {
+#ifdef VACLGUI
+    AgLock lock(charStackResource);
+#endif
+    LOGSECTION("string_space::resize");
+    LOGV(lcs) LCV(nc) LCV(n);
+
+    unsigned k = lcs + (lcs >> 1) + n + 1;
+    if (k > MAX_BYTES) k = (unsigned) MAX_BYTES;
+    lcs = k - 1;
+    LOGV(lcs) LCV(nc) LCV(n);
+    assert(lcs >= nc+n);
+    cs = reallocate(cs,k,char);
+    string_base = &cs[lcx];
+  }
+  return &cs[nc];
+}
+
+int *list_space(int n) {
+  if (nw + n >= lws) {
+#ifdef VACLGUI
+    AgLock lock(charStackResource);
+#endif
+    unsigned k = lws + (lws >> 1) + n + 1;
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lws = k - 1;
+    LOGSECTION("list_space::resize");
+    LOGV(lws) LCV(nw+n);
+    assert(lws >= nw+n);
+    REALLOCATE_ST(ws,k);
+    list_base = &ws[lwx];
+  }
+  return &ws[nw];
+}
+
+void sss(const char *s) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  int n;
+
+  assert(s != NULL);
+  n = strlen(s);
+  if (ni + 1 >= lis) {
+    unsigned k = lis + 3 + (lis >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lis = k-1;
+    LOGSECTION("sss::resize");
+    LOGV(lis) LCV(ni+2);
+    assert(lis >= ni+2);
+    REALLOCATE_ST(is,k);
+  }
+  is[ni++] = lcx;
+  if (nc + n >= lcs) {
+    unsigned k = lcs + (lcs >> 1) + n + 1;
+    if (k > MAX_BYTES) {
+      k = (unsigned) MAX_BYTES;
+    }
+    lcs = k - 1;
+    LOGSECTION("sss::resize");
+    LOGV(lcs) LCV(nc+n);
+    assert(lcs >= nc + n);
+    cs = reallocate(cs,k,char);
+  }
+  lcx = nc;
+  string_base = &cs[lcx];
+  strncpy(string_base,s,n);
+  nc += is[ni++] = n;
+  cs[nc] = 0;
+}
+
+void ass(const char *s) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  int n;
+
+  assert(s !=NULL);
+  assert(ni>=2);
+  n = strlen(s);
+  if (nc + n >= lcs) {
+    unsigned k = lcs + (lcs >> 1) + n + 1;
+    if (k > MAX_BYTES) {
+      k = (unsigned) MAX_BYTES;
+    }
+    lcs = k-1;
+    LOGSECTION("ass::resize");
+    LOGV(lcs) LCV(nc+n);
+    assert(lcs >= nc + n);
+    cs = reallocate(cs,k,char);
+    string_base = &cs[lcx];
+  }
+  strncpy(&cs[nc], s, n);
+  nc += n;
+  is[ni-1] += n;
+  cs[nc] = 0;
+}
+
+/*
+static void extend_string(int n) {
+  LOGSECTION("extend_string");
+  LOGV(nc) LCV(n);
+  is[ni-1] += n;
+  nc += n;
+  assert(nc < lcs);
+}
+*/
+
+int ssprintf(const char *fs, ...) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  va_list ap;
+  int n;
+
+  check_stack;
+  if (ni + 1 >= lis) {
+    unsigned k = lis + 3 + (lis >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lis = k - 1;
+    LOGSECTION("ssprintf::resize");
+    LOGV(lis) LCV(ni+2);
+    assert(lis >= ni+2);
+    REALLOCATE_ST(is,k);
+  }
+  is[ni++] = lcx;
+  string_space(500);
+  lcx = nc;
+  string_base = &cs[lcx];
+  va_start(ap,fs);
+  n = is[ni++] = vsprintf(&cs[nc],fs,ap);
+  nc += n;
+  assert(nc < lcs);
+  va_end(ap);
+  return n;
+}
+
+int apprintf(const char *fs, ...) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  va_list ap;
+  int n;
+
+  assert(ni>=2);
+  string_space(500);
+  va_start(ap,fs);
+  is[ni-1] += (n = vsprintf(&cs[nc],fs,ap));
+  nc += n;
+  assert(nc < lcs);
+  va_end(ap);
+  return n;
+}
+
+void tss(void) {
+  cs[nc] = 0;
+}
+
+void ics(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  //check_stack;
+  if (ni + 2 > lis) {
+    unsigned k = lis + 3 + (lis >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lis = k - 1;
+    LOGSECTION("ics::resize");
+    LOGV(lis) LCV(ni+2);
+    assert(lis >= ni+2);
+    REALLOCATE_ST(is,k);
+  }
+  is[ni++] = lcx;
+  lcx = nc;
+  string_base = &cs[lcx];
+  is[ni++] = 0;
+  cs[nc] = 0;
+}
+
+void scs(int c) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  //check_stack;
+  if (ni + 1 >= lis) {
+    unsigned k = lis + 3 + (lis >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lis = k - 1;
+    LOGSECTION("scs::resize");
+    LOGV(lis) LCV(ni+2);
+    assert(lis >= ni+2);
+    REALLOCATE_ST(is,k);
+  }
+  is[ni++] = lcx;
+  if (nc + 1 >= lcs) {
+    unsigned k = lcs + 2 + (lcs >> 1);
+    if (k > MAX_BYTES) {
+      k = (unsigned) MAX_BYTES;
+    }
+    lcs = k - 1;
+    LOGSECTION("scs::resize");
+    LOGV(lcs) LCV(nc+1);
+    assert(lcs >= nc+1);
+    cs = reallocate(cs,k,char);
+  }
+  lcx = nc;
+  string_base = &cs[lcx];
+  cs[nc++] = (char) c;
+  is[ni++] = 1;
+  cs[nc] = 0;
+}
+
+#if 0 /* NOTUSED */
+void ist(void) {                                /* init string table */
+  check_stack;
+  if (ni + 4 >= lis) {
+    unsigned k = lis + 5 + (lis >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lis = k - 1;
+    assert(lis >= ni+4);
+    REALLOCATE_ST(is,k);
+  }
+  is[ni++] = lwx;
+  is[ni++] = lcx;
+  lwx = nw;
+  list_base = &ws[lwx];
+  is[ni++] = nc;
+  lcx = nc;
+  string_base = &cs[lcx];
+  is[ni++] = 0;
+  ws[nw++] = 0;
+}
+#endif /* 0 - NOTUSED */
+
+void iws(void) {                                /* init word stack */
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  //check_stack;
+  if (ni + 2 >= lis) {
+    unsigned k = lis + 3 + (lis >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lis = k - 1;
+    LOGSECTION("iws::resize");
+    LOGV(lis) LCV(ni+2);
+    assert(lis >= ni+2);
+    REALLOCATE_ST(is,k);
+  }
+  is[ni++] = lwx;
+  lwx = nw;
+  list_base = &ws[lwx];
+  is[ni++] = 0;
+}
+
+void sws(int c) {                           /* store word on stack */
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  //check_stack;
+  if (ni + 1 >= lis) {
+    unsigned k = lis + 3 + (lis >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lis = k - 1;
+    LOGSECTION("sws::resize");
+    LOGV(lis) LCV(ni+2);
+    assert(lis >= ni+2);
+    REALLOCATE_ST(is,k);
+  }
+  is[ni++] = lwx;
+  if (nw >= lws) {
+    unsigned k = lws + 2 + (lws >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lws = k - 1;
+    LOGSECTION("sws::resize");
+    LOGV(lws) LCV(nw+2);
+    assert(lws >= nw+1);
+    REALLOCATE_ST(ws,k);
+  }
+  lwx = nw;
+  list_base = &ws[lwx];
+  ws[nw++] = c;
+  is[ni++] = 1;
+}
+
+int rcs(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  //LOGSECTION("rcs");
+  int n;
+
+  assert(ni >= 2);
+  n = is[--ni];
+  LOGV(nc) LCV(lcx) LCV(n);
+  assert(nc == lcx + n);
+  cs[nc] = 0;
+  nc = lcx;
+  lcx = is[--ni];
+  string_base = &cs[lcx];
+  return n;
+}
+
+int fps(FILE *f) {                         /* put string to file */
+  int n;
+
+  char *sb;
+  sb = string_base;
+  n = rcs();
+  fputs(sb,f);
+  return n;
+}
+
+int rps(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  int n;
+
+  assert(ni >= 2);
+  n = 2*is[--ni];
+  assert(nw == lwx + n);
+  nw = lwx;
+  lwx = is[--ni];
+  list_base = &ws[lwx];
+  return n;
+}
+
+int rws(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  int n;
+
+  assert(ni >= 2);
+  n = is[--ni];
+  assert(nw == lwx + n);
+  nw = lwx;
+  lwx = is[--ni];
+  list_base = &ws[lwx];
+  return n;
+}
+
+
+void sis(int i) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  //check_stack;
+  if (ni >= lis) {
+    unsigned k = lis + 2 + (lis >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lis = k - 1;
+    LOGSECTION("sis::resize");
+    LOGV(lis) LCV(ni+2);
+    assert (lis >= ni+1);
+    REALLOCATE_ST(is,k);
+  }
+  is[ni++] = i;
+}
+
+
+int tis(void) {
+  assert(ni >= 1);
+  return is[ni-1];
+}
+
+int fis(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  assert(ni >= 1);
+  return is[--ni];
+}
+
+void concat_string(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+//  check_stack;
+  assert(ni >= 4);
+  ni -= 2;
+  lcx = is[ni];
+  string_base = &cs[lcx];
+  is[ni-1] += is[ni+1];
+}
+
+void concat_list(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  //check_stack;
+  assert(ni >= 2);
+  ni -= 2;
+  lwx = is[ni];
+  list_base = &ws[lwx];
+  is[ni-1] += is[ni+1];
+}
+
+/*
+void its(char c,int n) {
+  assert(ni>=2);
+  while (n > is[ni-1]) acs(' ');
+  if (n == is[ni-1]) {acs(c); return;}
+  if (nc + 1 >= lcs) {
+    unsigned k = lcs + 1 + (lcs >> 1);
+    if (k > MAX_BYTES) {
+      k = (unsigned) MAX_BYTES;
+    }
+    lcs = k - 1;
+    assert(lcs > nc);
+    cs = reallocate(cs,k,char);
+    string_base = &cs[lcx];
+  }
+  memmove(&cs[lcx+n+1],&cs[lcx+n],sizeof(*cs)*(is[ni-1]-n));
+  cs[lcx+n] = c;
+  (is[ni-1])++;
+  cs[++nc] = 0;
+}
+*/
+
+void acs(int c) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  assert(ni>=2);
+  if (nc + 1 >= lcs) {
+    unsigned k = lcs + 2 + (lcs >> 1);
+    if (k > MAX_BYTES) {
+      k = (unsigned) MAX_BYTES;
+    }
+    lcs = k - 1;
+    LOGSECTION("acs::resize");
+    LOGV(lcs) LCV(nc);
+    assert(lcs > nc);
+    cs = reallocate(cs,k,char);
+    string_base = &cs[lcx];
+  }
+  cs[nc++] = (char) c;
+  cs[nc] = 0;
+  (is[ni-1])++;
+}
+
+int isws(int c) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  int bx, tx;
+  unsigned nx;
+  check_stack;
+  assert(ni>=2);
+  if (nw >= lws) {
+    unsigned k = lws + 2 + (lws >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lws = k-1;
+    LOGSECTION("isws::resize");
+    LOGV(lws) LCV(nw);
+    assert(lws > nw);
+    REALLOCATE_ST(ws,k);
+    list_base = &ws[lwx];
+  }
+  if (nw == lwx) {
+    ws[nw++] = c;
+    is[ni-1]++;
+    return 0;
+  }
+  bx = lwx;
+  tx = nw-1;
+  while (bx <= tx) {
+    nx = (bx+tx)/2;
+    if (ws[nx] > c) {
+      tx = nx-1;
+    }
+    else if (ws[nx] < c) {
+      bx = nx + 1;
+    }
+    else {
+      return 1;
+    }
+  }
+  if (nw > (unsigned) bx) {
+    memmove(ws+bx+1,ws+bx, (nw-bx)*sizeof(*ws));
+  }
+  ws[bx] = c;
+  nw++;
+  (is[ni-1])++;
+  return 0;
+}
+
+int xws(int c) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  int k;
+  int *p;
+
+  assert(ni>=2);
+  if (nw >= lws) {
+    unsigned k = lws + 2 + (lws >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lws = k - 1;
+    LOGSECTION("xws::resize");
+    LOGV(lws) LCV(nw);
+    assert(lws > nw);
+    REALLOCATE_ST(ws,k);
+    list_base = &ws[lwx];
+  }
+  k = nw - lwx;
+  p = list_base;
+  while (k--) {
+    if (c == *p++) {
+      return 1;
+    }
+  }
+  ws[nw++] = c;
+  (is[ni-1])++;
+  return 0;
+}
+
+int xps(int c1,int c2) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  unsigned i;
+  int *p;
+  int flag;
+
+  // some compilers fail to be able to unravel the loop below to show
+  // that this isn't necessary
+  flag = -1;
+
+  assert(ni>=2);
+  if (nw + 2 >= lws) {
+    unsigned k = lws + 3 + (lws >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lws = k - 1;
+    LOGSECTION("xps::resize");
+    LOGV(lws) LCV(nw + 2);
+    assert(lws >= nw + 2);
+    REALLOCATE_ST(ws,k);
+    list_base = &ws[lwx];
+  }
+  for (p = list_base, i = lwx;
+       i < nw && ((flag = p[0] - c1) < 0 ||
+		  (flag == 0 && (flag = p[1] - c2) < 0));
+       p += 2, i += 2);
+  if (i < nw && flag == 0) {
+    return 1;
+  }
+  memmove(p+2, p, (nw - i)* sizeof(*p));
+  *p++ = c1; *p = c2;
+  nw += 2;
+  (is[ni-1])++;
+  return 0;
+}
+
+void aws(int c) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  assert(ni>=2);
+  if (nw >= lws) {
+    unsigned k = lws + 2 + (lws >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lws = k - 1;
+    LOGSECTION("aws::resize");
+    LOGV(lws) LCV(nw);
+    assert(lws > nw);
+    REALLOCATE_ST(ws,k);
+    list_base = &ws[lwx];
+  }
+  ws[nw++] = c;
+  (is[ni-1])++;
+}
+
+char *build_string(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  char *h;
+  unsigned n;
+
+  check_stack;
+  assert(ni >= 2);
+  n = is[--ni];
+  lcx = is[--ni];
+  string_base = &cs[lcx];
+  assert(nc >= n);
+  nc -= n;
+  h = ALLOCATE(n+1, char);
+  memmove(h, cs + nc, n*sizeof(*h));
+  h[n] = 0;
+  return h;
+}
+
+AgString buildAgString(void) {
+  char *sb;
+  sb = string_base;
+  return AgString(sb,rcs());
+}
+
+AgArray<int> buildStaticList(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  unsigned n;
+
+  //check_stack;
+  assert(ni >= 1);
+  n = is[--ni];
+  lwx = is[--ni];
+  list_base = &ws[lwx];
+  assert(nw >= n);
+  nw -= n;
+  return AgArray<int>(ws+nw, n);
+}
+
+int *build_list(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  int *h;
+  unsigned n;
+
+  //check_stack;
+  assert(ni >= 1);
+  n = is[--ni];
+  lwx = is[ni-1];
+  list_base = &ws[lwx];
+  assert(nw >= n);
+  nw -= n;
+  is[ni-1] = n;
+  if (n == 0) h = NULL;
+  else ALLOCATE_ST(h, n);
+  memmove(h,ws + nw, n*sizeof(*ws));
+  return h;
+}
+/*
+static void rtbc(void) {
+  assert(ni>=2);
+  if (cs[nc-1] != ' ') return;
+  nc--;
+  is[ni-1]--;
+  cs[nc] = 0;
+}
+*/
+
+int idl(list_dict *d) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  int k,nsx;
+  int *lb;
+
+  check_stack;
+  assert(ni>=2);
+  nsx = d->nsx;
+  lb = list_base;
+  k = add_list_dict(lb, rws(), d);
+  sis(k);
+  return k == nsx;
+}
+
+int fws(void) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  assert(nw > 0);
+  is[ni-1]--;
+  return(ws[--nw]);
+}
+
+void fdl(list_dict *d,unsigned k) {
+#ifdef VACLGUI
+  AgLock lock(charStackResource);
+#endif
+  int n, *l;
+
+  assert(k < d->nsx);
+  iws();
+  l = d->text + d->ndx[k];
+  n = *l++ - 1;
+  if (nw + n >= lws) {
+    unsigned k = lws + n + 1 + (lws >> 1);
+    if (k > MAX_INTS) {
+      k = (unsigned) MAX_INTS;
+    }
+    lws = k - 1;
+    LOGSECTION("fdl::resize");
+    LOGV(lws) LCV(nw + n);
+    assert(lws >= nw+n);
+    REALLOCATE_ST(ws,k);
+    list_base = &ws[lwx];
+  }
+  memmove(list_base, l, n*sizeof(*list_base));
+  nw += n;
+  is[ni-1] = n;
+}
+
+//int idsx(string_dict *);
+/*
+int ids(string_dict *d) {
+  rtbc();
+  return idsx(d);
+}
+
+static int idsx(string_dict *d) {
+  int k,nsx;
+  char *sb;
+
+  check_stack;
+  assert(ni>=2);
+  cs[nc] = 0;
+  sb = string_base;
+  rcs();
+  nsx = d->nsx;
+  k = add_string_dict(sb, d);
+  is[ni++] = k;
+  cs[nc] = 0;
+  return k == nsx;
+}
+*/