rural 0.1.0

data/ext/vlerq.c

@@ -0,0 +1,4531 @@
+/* vlerq.c - this is the single-source-file version of Vlerq for Ruby */
+
+/* %includeDir<../src>% */
+/* %includeDir<../_ruby>% */
+
+/* %include<bits.c>% */
+/*
+ * bits.c - Implementation of bitwise operations.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * defs.h - Binding-specific definitions needed by the general code.
+ */
+
+typedef unsigned long Object_p;
+
+struct Shared *(GetShared) (void);
+/*
+ * column.h - Definition of sequences, columns, and items.
+ */
+
+#include <stdint.h>
+/* on OpenBSD, use this line instead: typedef int intptr_t; */
+
+#ifdef __sparc__
+#define VALUES_MUST_BE_ALIGNED 1
+#endif
+ 
+#if WORDS_BIGENDIAN
+#define _BIG_ENDIAN 1
+#endif
+
+#if DEBUG
+#define Assert(x) do if (!(x)) FailedAssert(#x, __FILE__, __LINE__); while (0)
+#else
+#define Assert(x)
+#endif
+
+#define INVALID_COUNT (-1)
+
+#define PUSH_KEEP_REFS \
+  { Buffer keep, *prevkeeps = GetShared()->keeps; \
+    InitBuffer(&keep); \
+    GetShared()->keeps = &keep;
+#define POP_KEEP_REFS \
+    ReleaseSequences((Sequence_p*) BufferAsPtr(&keep, 1), \
+                     BufferFill(keep) / sizeof(Sequence_p)); \
+    ReleaseBuffer(&keep, 0); \
+    GetShared()->keeps = prevkeeps; \
+  }
+    
+/* keep in sync with CharAsItemType() in column.c */
+typedef enum ItemTypes {
+  IT_unknown,
+  IT_int,
+  IT_wide,
+  IT_float,
+  IT_double,
+  IT_string,
+  IT_bytes,
+  IT_object,
+  IT_column,
+  IT_view,
+  IT_error
+} ItemTypes;
+
+typedef enum ErrorCodes {
+  EC_cioor,
+  EC_rioor,
+  EC_cizwv,
+  EC_nmcw,
+  EC_rambe,
+  EC_nalor,
+  EC_wnoa
+} ErrorCodes;
+
+typedef struct Shared {
+  struct SharedInfo  *info;      /* ext_tcl.c */
+  int                 refs;      /* ext_tcl.c */
+  struct Buffer      *keeps;     /* column.c */
+  intptr_t            position;  /* emit.c: current file emit offset */
+  struct Buffer      *itembuf;   /* emit.c: current item buffer */
+  struct Buffer      *colbuf;    /* emit.c: current column buffer */
+  struct Sequence    *empty;     /* view.c */
+} Shared, *Shared_p;
+
+typedef struct RefCounted *RefCounted_p;
+typedef struct Sequence   *Sequence_p;
+typedef struct Column     *Column_p;
+typedef union Item        *Item_p;
+typedef Sequence_p         View_p;
+
+typedef int       (*Sizer) (Sequence_p seq);
+typedef ItemTypes (*Getter) (int row, Item_p item);
+typedef void      (*Cleaner) (RefCounted_p seq);
+
+typedef struct RefCounted {
+  Cleaner  cleaner;   /* called during cleanup */
+  int      refcount;  /* reference count */
+  int      filler;    /* needed for 64b alignment, can reuse for any purpose */
+} RefCounted;
+
+typedef struct Sequence {
+  RefCounted  head;   /* manages ref counts, must be first is struct */
+  Getter      getter; /* function to access a single item */
+  union { int i; void *p; } data[4]; /* getter-specific use */
+} Sequence;
+
+#define S_Count(seq) ((seq)->head.filler)
+
+#define IncRefCount(seq) AdjustSeqRefs(seq, 1)
+#define DecRefCount(seq) AdjustSeqRefs(seq, -1)
+
+typedef struct Column {
+  Sequence_p   seq;    /* the sequence which will handle accesses */
+  int          pos;    /* position of this column in the view */
+} Column;              
+                       
+typedef union Item {   
+  char         b [8];  /* used for raw access and byte-swapping */
+  int          q [2];  /* used for hash calculation of wides and doubles */
+  int          i;      /* IT_int */
+  int64_t      w;      /* IT_wide */
+  float        f;      /* IT_float */
+  double       d;      /* IT_double */
+  const void  *p;      /* used to convert pointers */
+  const char  *s;      /* IT_string */
+  struct { const uint8_t *ptr; int len; } u; /* IT_bytes */
+  Object_p     o;      /* IT_object */
+  Column       c;      /* IT_column */
+  View_p       v;      /* IT_view */
+  ErrorCodes   e;      /* IT_error */
+} Item;
+
+void      *(AdjustSeqRefs) (void *refs, int count);
+void       (AppendToStringColumn) (const void *s, int bytes, Column_p column);
+int        (CastObjToItem) (char type, Item_p item);
+ItemTypes  (CharAsItemType) (char type);
+Column     (CoerceCmd) (Object_p obj, const char *str);
+void       (FailedAssert) (const char *msg, const char *file, int line);
+Column     (ForceStringColumn) (Column column);
+ItemTypes  (GetItem) (int row, Item_p item);
+Item       (GetTypedItem) (int row, Column column, ItemTypes type);
+Column     (InitColumn) (int count, Getter proc, int auxbytes);
+Sequence_p (KeepRef) (Sequence_p seq);
+Column     (NewCountsColumn) (Column column);
+Column     (NewIntVec) (int count, int **dataptr);
+Column     (NewIotaColumn) (int count);
+Column     (NewPtrVec) (int count, intptr_t **dataptr);
+Column     (NewSequenceColumn) (ItemTypes type, const Sequence_p *p, int n);
+Column     (NewStringColumn) (int maxitems, int maxbytes, int istext);
+Column     (OmitColumn) (Column omit, int size);
+void       (ReleaseSequences) (Sequence_p *refs, int count);
+
+/* the following must be supplied in the language binding */
+Column     (CoerceColumn) (ItemTypes type, Object_p obj);
+int        (ColumnByName) (View_p meta, Object_p obj);
+Object_p   (ItemAsObj) (ItemTypes type, Item_p item);
+Column     (ObjAsColumn) (Object_p obj);
+int        (ObjToItem) (ItemTypes type, Item_p item);
+/*
+ * buffer.h - Definition of a simple temporary buffer.
+ */
+
+typedef struct Buffer *Buffer_p;
+typedef struct Overflow *Overflow_p;
+
+typedef struct Buffer {
+  union { char *c; int *i; const void **p; } fill;
+  char       *limit;
+  Overflow_p  head;
+  char       *ofill;
+  intptr_t    ocount;
+  char       *result;
+  char        buf [128];
+  char        slack [8];
+} Buffer;
+
+#define ADD_CHAR_TO_BUF(b,x) \
+          { char _c = x; \
+            if ((b).fill.c < (b).limit) *(b).fill.c++ = _c; \
+              else AddToBuffer(&(b), &_c, sizeof _c); }
+
+#define ADD_INT_TO_BUF(b,x) \
+          { int _i = x; \
+            if ((b).fill.c < (b).limit) *(b).fill.i++ = _i; \
+              else AddToBuffer(&(b), &_i, sizeof _i); }
+
+#define ADD_PTR_TO_BUF(b,x) \
+          { const void *_p = x; \
+            if ((b).fill.c < (b).limit) *(b).fill.p++ = _p; \
+              else AddToBuffer(&(b), &_p, sizeof _p); }
+
+#define BufferFill(b) ((b).ocount + ((b).fill.c - (b).buf))
+
+void   InitBuffer(Buffer_p bp);
+void   ReleaseBuffer(Buffer_p bp, int keep);
+void   AddToBuffer(Buffer_p bp, const void *data, intptr_t len);
+char  *BufferAsPtr(Buffer_p bp, int fast);
+Column BufferAsIntCol(Buffer_p bp);
+/*
+ * bits.h - Definition of bitwise operations.
+ */
+
+int  (BitTest) (const uint8_t *bitmap, int row);
+void (BitSet) (uint8_t *bitmap, int row);
+
+int BitTest (const uint8_t *bitmap, int row) {
+  return bitmap[row/8] & (1 << row % 8);
+}
+
+void BitSet (uint8_t *bitmap, int row) {
+  bitmap[row/8] |= 1 << row % 8;
+}
+/* %include<buffer.c>% */
+/*
+ * buffer.c - Implementation of a simple temporary buffer.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+
+typedef struct Overflow {
+  Overflow_p p;
+  char       b[4096];
+} Overflow;
+
+void InitBuffer(Buffer_p bp) {
+  bp->fill.c = bp->buf;
+  bp->limit = bp->buf + sizeof bp->buf;
+  bp->head = 0;
+  bp->ofill = 0;
+  bp->ocount = 0;
+  bp->result = 0;
+}
+
+void ReleaseBuffer(Buffer_p bp, int keep) {
+  while (bp->head != 0) {
+    Overflow_p op = bp->head;
+    bp->head = op->p;
+    free(op);
+  }
+  if (!keep && bp->result != 0)
+    free(bp->result);
+}
+
+void AddToBuffer(Buffer_p bp, const void *data, intptr_t len) {
+  intptr_t n;
+  while (len > 0) {
+    if (bp->fill.c >= bp->limit) {
+      if (bp->head == 0 || bp->ofill >= bp->head->b + sizeof bp->head->b) {
+        Overflow_p op = (Overflow_p) malloc(sizeof(Overflow));
+        op->p = bp->head;
+        bp->head = op;
+        bp->ofill = op->b;
+      }
+      memcpy(bp->ofill, bp->buf, sizeof bp->buf);
+      bp->ofill += sizeof bp->buf;
+      bp->ocount += sizeof bp->buf;
+      n = bp->fill.c - bp->slack;
+      memcpy(bp->buf, bp->slack, n);
+      bp->fill.c = bp->buf + n;
+    }
+    n = len;
+    if (n > bp->limit - bp->fill.c)
+      n = bp->limit - bp->fill.c; /* TODO: copy big chunks to overflow */
+    memcpy(bp->fill.c, data, n);
+    bp->fill.c += n;
+    data = (const char*) data + n;
+    len -= n;
+  }
+}
+
+char *BufferAsPtr(Buffer_p bp, int fast) {
+  intptr_t n = bp->fill.c - bp->buf, len = bp->ocount + n;
+  if (fast && n == len)
+    return bp->buf;
+  if (bp->result == 0)
+    bp->result = malloc(len);
+  len -= n;
+  memcpy(bp->result + len, bp->buf, n);
+  if (bp->head != 0) {
+    Overflow_p curr = bp->head;
+    n = bp->ofill - curr->b;
+    do {
+      len -= n;
+      memcpy(bp->result + len, curr->b, n);
+      curr = curr->p;
+      n = sizeof bp->head->b;
+    } while (curr != 0);
+  }
+  return bp->result;
+}
+
+Column BufferAsIntCol(Buffer_p bp) {
+  int count, *data;
+  Column result;
+  
+  count = BufferFill(*bp) / sizeof(int);
+  result = NewIntVec(count, &data);
+  memcpy(data, BufferAsPtr(bp, 1), BufferFill(*bp));
+  ReleaseBuffer(bp, 0); /* TODO: try to avoid extra alloc + copy */
+  
+  return result;
+}
+/* %include<column.c>% */
+/*
+ * column.c - Implementation of sequences, columns, and items.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*
+ * view.h - Definition of views.
+ */
+
+typedef enum MetaCols {
+  MC_name, MC_type, MC_subv, MC_limit
+} MetaCols;
+
+#define V_Cols(view) ((Column_p) ((view) + 1))
+#define V_Types(view) (*(char**) ((view)->data))
+#define V_Meta(view) (*(View_p*) ((view)->data+1))
+
+#define ViewWidth(view) ViewSize(V_Meta(view))
+#define ViewCol(view,col) (V_Cols(view)[col])
+#define ViewColType(view,col) ((ItemTypes) V_Types(view)[col])
+#define ViewCompat(view1,view2) MetaIsCompatible(V_Meta(view1), V_Meta(view2))
+
+View_p (CloneView) (View_p view);
+View_p (ColMapView) (View_p view, Column mapcol);
+View_p (ColOmitView) (View_p view, Column mapcol);
+View_p (DescAsMeta) (const char** desc, const char* end);
+View_p (DescToMeta) (const char *desc);
+View_p (EmptyMetaView) (void);
+View_p (FirstView) (View_p view, int count);
+char   (GetColType) (View_p meta, int col);
+View_p (IndirectView) (View_p meta, Sequence_p seq);
+View_p (LastView) (View_p view, int count);
+View_p (NameColView) (View_p view);
+View_p (NewView) (View_p meta);
+View_p (NoColumnView) (int rows);
+View_p (PairView) (View_p view1, View_p view2);
+View_p (TakeView) (View_p view, int count);
+int    (MetaIsCompatible) (View_p meta1, View_p meta2);
+Column (ViewAsCol) (View_p view);
+int    (ViewCompare) (View_p view1, View_p view2);
+int    (ViewSize) (View_p view);
+void   (ViewStructure) (View_p meta, Buffer_p buffer);
+void   (ReleaseUnusedViews) (void);
+void   (SetViewColumns) (View_p view, int first, int count, Column src);
+View_p (TagView) (View_p view, const char* name);
+/*
+ * getters.h - Definition of several simple getter functions.
+ */
+
+Getter (PickIntGetter) (int bits);
+Getter (FixedGetter) (int bytes, int rows, int real, int flip);
+
+void *AdjustSeqRefs (void *refs, int count) {
+  if (refs != NULL) {
+    RefCounted_p ptr = refs;
+    ptr->refcount += count;
+    if (ptr->refcount <= 0) {
+      if (ptr->cleaner != NULL)
+        ptr->cleaner(ptr);
+      free(refs);
+      refs = NULL;
+    }
+  }
+  return refs;
+}
+
+Sequence_p KeepRef (Sequence_p seq) {
+  Shared_p sh = GetShared();
+  
+  ADD_PTR_TO_BUF(*sh->keeps, seq);
+  return IncRefCount(seq);
+}
+
+Column InitColumn (int count, Getter proc, int auxbytes) {
+  Column column;
+  
+  column.seq = KeepRef((Sequence_p) calloc(1, sizeof(Sequence) + auxbytes));
+  S_Count(column.seq) = count;
+  column.seq->getter = proc;
+
+  /* default for data[0] is to point to the aux bytes after the sequence */
+  column.seq->data[0].p = column.seq + 1;
+  
+  /* make sure 64-bit values have a "native" 8-byte alignment */
+  Assert(((intptr_t) column.seq->data[0].p) % 8 == 0);
+
+  column.pos = INVALID_COUNT;
+  return column;
+}
+
+void ReleaseSequences (Sequence_p *refs, int count) {
+  while (--count >= 0)
+    DecRefCount(refs[count]);
+}
+
+Column NewIntVec (int count, int **dataptr) {
+  const int w = sizeof(int);
+  Column result = InitColumn(count, PickIntGetter(8 * w), w * count);
+  if (dataptr != NULL)
+    *dataptr = result.seq->data[0].p;
+  return result;
+}
+
+Column NewPtrVec (int count, intptr_t **dataptr) {
+  const int w = sizeof(intptr_t);
+  Column result = InitColumn(count, PickIntGetter(8 * w), w * count);
+  if (dataptr != NULL)
+    *dataptr = result.seq->data[0].p;
+  return result;
+}
+
+ItemTypes GetItem (int row, Item_p item) {
+  if (row < 0 || row >= S_Count(item->c.seq)) {
+    item->e = EC_rioor;
+    return IT_error;
+  }
+    
+  return item->c.seq->getter(row, item);
+}
+
+Item GetTypedItem (int row, Column column, ItemTypes type) {
+  Item item;
+  ItemTypes got;
+  
+  item.c = column;
+  got = GetItem(row, &item);
+  Assert(got == type);
+    
+  return item;
+}
+
+#if 0 /* unused */
+const char *ItemTypeAsString (ItemTypes type) {
+  static const char *typeTable[] = {
+    "",  /* IT_unknown */
+    "I", /* IT_int */
+    "L", /* IT_wide */
+    "D", /* IT_double */
+    "S", /* IT_string */
+    "O", /* IT_object */
+    "C", /* IT_column */
+    "V", /* IT_view */
+    "E", /* IT_error */
+  };
+
+  return typeTable[type];
+}
+#endif
+
+ItemTypes CharAsItemType (char type) {
+  switch (type) {
+    case 0:   return IT_unknown;
+    case 'I': return IT_int;
+    case 'L': return IT_wide;
+    case 'F': return IT_float;
+    case 'D': return IT_double;
+    case 'S': return IT_string;
+    case 'B': return IT_bytes;
+    case 'O': return IT_object;
+    case 'C': return IT_column;
+    case 'V': return IT_view;
+  }
+  return IT_error;
+}
+
+static void StringCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[2].p);
+}
+
+static ItemTypes StringGetter (int row, Item_p item) {
+  char **ptrs = (char**) item->c.seq->data[0].p;
+  item->s = ptrs[row];
+  return IT_string;
+}
+
+static ItemTypes BytesGetter (int row, Item_p item) {
+  char **ptrs = (char**) item->c.seq->data[0].p;
+  item->u.ptr = (const uint8_t*) ptrs[row];
+  item->u.len = ptrs[row+1] - ptrs[row];
+  return IT_bytes;
+}
+
+Column NewStringColumn (int maxitems, int maxbytes, int istext) {
+  int ptrbytes;
+  char **ptrs;
+  Column result;
+
+  ptrbytes = (maxitems + 1) * sizeof(char*);
+  result = InitColumn(0, istext ? StringGetter : BytesGetter,
+                                                        ptrbytes + maxbytes);
+  result.seq->head.cleaner = (Cleaner) StringCleaner;
+  /* data[0] is a vector of string pointers */
+  /* data[1] is not used */
+  /* data[2] is an optional pointer to a hash map sequence, see StringLookup */
+  /* data[3] is the optional prime factor used in hash map, see StringLookup */
+  result.seq->data[1].i = 0;
+  
+  /* last pointer points to first unused byte */
+  ptrs = (char**) result.seq->data[0].p;
+  ptrs[0] = (char*) ptrs + ptrbytes;
+  return result;
+}
+
+void AppendToStringColumn (const void *string, int bytes, Column_p column) {
+  char **ptrs = (char**) column->seq->data[0].p;
+  char *bufend = ptrs[S_Count(column->seq)];
+
+  if (bytes < 0)
+    bytes = strlen((const char*) string) + 1;
+  memcpy(bufend, string, bytes);
+  ptrs[++S_Count(column->seq)] = bufend + bytes;
+}
+
+static int PreflightStringLengths (Column column) {
+  int i, count = S_Count(column.seq), total = 0;
+
+  for (i = 0; i < count; ++i)
+    total +=  strlen(GetTypedItem(i, column, IT_string).s) + 1;
+
+  return total;
+}
+
+Column ForceStringColumn (Column column) {
+  int r, rows;
+  Column result;
+  
+  /* this code is needed to always make name column of meta views string cols */
+  
+  if (column.seq == NULL || column.seq->getter == StringGetter)
+    return column;
+    
+  rows = S_Count(column.seq);
+  result = NewStringColumn(rows, PreflightStringLengths(column), 1);
+  
+  for (r = 0; r < rows; ++r)
+    AppendToStringColumn(GetTypedItem(r, column, IT_string).s, -1, &result);
+  
+  return result;
+}
+
+static ItemTypes IotaGetter (int row, Item_p item) {
+  item->i = row;
+  return IT_int;
+}
+
+Column NewIotaColumn (int count) {
+  return InitColumn(count, IotaGetter, 0);
+}
+
+static void SequenceCleaner (Sequence_p seq) {
+  int i;
+  View_p *items = seq->data[0].p;
+
+  for (i = 0; i < S_Count(seq); ++i)
+    DecRefCount(items[i]);
+}
+
+static ItemTypes SequenceGetter (int row, Item_p item) {
+  void **items = (void**) item->c.seq->data[0].p;
+  ItemTypes type = item->c.seq->data[1].i;
+
+  switch (type) {
+
+    case IT_view:
+      item->v = items[row];
+      return IT_view;
+
+    case IT_column:
+      item->c.seq = items[row];
+      item->c.pos = INVALID_COUNT;
+      return IT_column;
+
+    default:
+      return IT_unknown;
+  }
+}
+
+Column NewSequenceColumn (ItemTypes type, const Sequence_p *items, int count) {
+  int i, bytes;
+  Column result;
+
+  bytes = count * sizeof(View_p);
+  result = InitColumn(count, SequenceGetter, bytes);
+  result.seq->head.cleaner = (Cleaner) SequenceCleaner;
+
+  /* data[0] points a list of pointers */
+  /* data[1] is the type of the returned items */
+  result.seq->data[1].i = type;
+
+  if (items != NULL) {
+    memcpy(result.seq->data[0].p, items, bytes);
+    for (i = 0; i < count; ++i)
+      IncRefCount(items[i]);
+  }
+
+  return result;
+}
+
+static ItemTypes CountsGetter (int row, Item_p item) {
+  const View_p *items = (const View_p*) item->c.seq->data[0].p;
+
+  item->i = ViewSize(items[row]);
+  return IT_int;
+}
+
+Column NewCountsColumn (Column column) {
+  int r, rows;
+  View_p *items;
+  Column result;
+  
+  rows = S_Count(column.seq);  
+  result = NewSequenceColumn(IT_view, NULL, rows);
+  result.seq->getter = CountsGetter;
+
+  items = result.seq->data[0].p;
+  for (r = 0; r < rows; ++r)
+    items[r] = IncRefCount(GetTypedItem(r, column, IT_view).v);
+
+  return result;
+}
+
+Column OmitColumn (Column omit, int size) {
+  int i, *data, next = 0, omitcount = S_Count(omit.seq), limit;
+  Column result;
+  
+  result = NewIntVec(size - omitcount, &data);
+  for (i = 0; i < omitcount; ++i) {
+    limit = GetTypedItem(i, omit, IT_int).i;
+    while (next < limit) 
+      *data++ = next++;
+    ++next;
+  }
+  while (next < size) 
+    *data++ = next++;
+    
+  return result;
+}
+
+static int StringTotals (Column column, int text) {
+  int i, count, bytes, total = 0;
+  Item item;
+
+  count = S_Count(column.seq);
+
+  for (i = 0; i < count; ++i) {
+    item.c = column;
+    ItemAsObj(GetItem(i, &item), &item);
+    if (text) {
+      if (!ObjToItem(IT_string, &item))
+        Assert(0);
+      bytes = strlen(item.s) + 1;
+    } else {
+      if (!ObjToItem(IT_bytes, &item))
+        Assert(0);
+      bytes = item.u.len;
+    }
+    total += bytes;
+  }
+
+  return total;
+}
+
+static Column CoerceColType (ItemTypes from, ItemTypes to, Column column) {
+  int i, n;
+  void *data;
+  Item item;
+  Column out;
+
+  if (from == to)
+    return column;
+
+  Assert(from == IT_object); /* not sure why this is always the case... */
+
+  n = S_Count(column.seq);
+
+  switch (to) {
+    case IT_int:    out = NewIntVec(n, (int**) &data); break;
+    case IT_wide:   out = InitColumn(n, PickIntGetter(64), 8 * n); break;
+    case IT_float:  out = InitColumn(n, FixedGetter(4, 1, 1, 0), 4 * n); break;
+    case IT_double: out = InitColumn(n, FixedGetter(8, 1, 1, 0), 8 * n); break;
+    case IT_string: out = NewStringColumn(n, StringTotals(column, 1), 1); break;
+    case IT_bytes:  out = NewStringColumn(n, StringTotals(column, 0), 0); break;
+    case IT_view:   out = NewSequenceColumn(IT_view, NULL, n); break;
+    default:        out.seq = NULL; out.pos = -1; return out;
+  }
+
+  data = out.seq->data[0].p;
+  
+  for (i = 0; i < n; ++i) {
+    item.o = GetTypedItem(i, column, IT_object).o;
+    if (!ObjToItem(to, &item)) {
+      out.seq = NULL;
+      out.pos = i;
+    }
+    
+    switch (to) {
+      case IT_int:    ((int*) data)[i] = item.i; break;
+      case IT_wide:   ((int64_t*) data)[i] = item.w; break;
+      case IT_float:  ((float*) data)[i] = item.f; break;
+      case IT_double: ((double*) data)[i] = item.d; break;
+      case IT_string: AppendToStringColumn(item.s, -1, &out); break;
+      case IT_bytes:  AppendToStringColumn(item.u.ptr, item.u.len, &out); break;
+      case IT_view:   ((Sequence_p*) data)[i] = IncRefCount(item.v); break;
+      default:        ;
+    }
+  }
+
+  return out;
+}
+
+Column CoerceColumn (ItemTypes type, Object_p obj) {
+  Item item;
+  Column column = ObjAsColumn(obj);
+
+  /* determine the input column type by fetching one item */
+  if (column.seq != NULL && S_Count(column.seq) > 0) {
+    item.c = column;
+    return CoerceColType(GetItem(0, &item), type, column);
+  }
+
+  return column;
+}
+
+Column CoerceCmd (Object_p obj, const char *str) {
+  return CoerceColumn(CharAsItemType(str[0]), obj);
+}
+
+int CastObjToItem (char type, Item_p item) {
+  switch (type) {
+
+    case 'N':
+      item->i = ColumnByName(V_Meta(item[-1].v), item->o);
+      return item->i >= 0;
+    
+    case 'n': {
+      int *data, r, rows;
+      View_p meta;
+      Column column, result;
+
+      column = ObjAsColumn(item->o);
+      if (column.seq == NULL)
+        return 0;
+        
+      rows = S_Count(column.seq);
+      result = NewIntVec(rows, &data);
+      meta = V_Meta(item[-1].v);
+      
+      for (r = 0; r < rows; ++r) {
+        item->c = column;
+        data[r] = ColumnByName(meta, ItemAsObj(GetItem(r, item), item));
+        if (data[r] < 0)
+          return 0;
+      }
+      
+      item->c = result;
+      break;
+    }
+    
+    default:
+      if (type < 'a' || type > 'z')
+        return ObjToItem(CharAsItemType(type), item);
+
+      item->c = CoerceColumn(CharAsItemType(type +'A'-'a'), item->o);
+      break;
+  }
+
+  return 1; /* cast succeeded */
+}
+/* %include<emit.c>% */
+/*
+ * emit.c - Implementation of file output commands.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*
+ * emit.h - Definition of file output commands.
+ */
+
+typedef enum EmitTypes {
+  ET_mem
+} EmitTypes;
+
+typedef struct EmitItem {
+  EmitTypes type;
+  intptr_t size;
+  const void *data;
+} EmitItem, *EmitItem_p;
+
+intptr_t (EmitFull) (View_p view, Buffer_p buffer);
+void     (EmitView) (View_p view, int describe);
+void     (MetaAsDesc) (View_p meta, Buffer_p buffer);
+
+static void EmitBlock (const void* data, int size) {
+  if (size > 0) {
+    EmitItem item;
+    Shared_p sh = GetShared();
+
+    item.type = ET_mem;
+    item.size = size;
+    item.data = data;
+    AddToBuffer(sh->itembuf, &item, sizeof item);
+
+    sh->position += size;
+  }
+}
+
+static void *EmitCopy (const void* data, int size) {
+  void *buf = NULL;
+  if (size > 0) {
+    buf = memcpy(malloc(size), data, size);
+    EmitBlock(buf, size);
+  }
+  return buf;
+}
+
+static intptr_t EmitAlign (void) {
+  Shared_p sh = GetShared();
+  if (sh->position >= 1024 * 1024)
+    EmitCopy("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 15 & - sh->position);
+  return sh->position;
+}
+
+void MetaAsDesc (View_p meta, Buffer_p buffer) {
+  int r, rows = ViewSize(meta);
+  Column names, types, subvs;
+  char type;
+  const char *name;
+  View_p subv;
+
+  names = ViewCol(meta, MC_name);
+  types = ViewCol(meta, MC_type);
+  subvs = ViewCol(meta, MC_subv);
+
+  for (r = 0; r < rows; ++r) {
+    if (r > 0)
+      ADD_CHAR_TO_BUF(*buffer, ',');
+
+    name = GetTypedItem(r, names, IT_string).s;
+    type = *GetTypedItem(r, types, IT_string).s;
+    subv = GetTypedItem(r, subvs, IT_view).v;
+
+    AddToBuffer(buffer, name, strlen(name));
+    if (type == 'V' && ViewSize(subv) > 0) {
+      ADD_CHAR_TO_BUF(*buffer, '[');
+      MetaAsDesc(subv, buffer);
+      ADD_CHAR_TO_BUF(*buffer, ']');
+    } else {
+      ADD_CHAR_TO_BUF(*buffer, ':');
+      ADD_CHAR_TO_BUF(*buffer, type);
+    }
+  }
+}
+
+static void EmitVarInt (intptr_t value) {
+  int n;
+  Shared_p sh = GetShared();
+
+#if 0
+  if (value < 0) {
+    ADD_CHAR_TO_BUF(*sh->colbuf, 0);
+    value = ~value;
+  }
+#endif
+
+  Assert(value >= 0);
+  for (n = 7; (value >> n) > 0; n += 7)
+    ;
+  while (n > 7) {
+    n -= 7;
+    ADD_CHAR_TO_BUF(*sh->colbuf, (value >> n) & 0x7F);
+  }
+  ADD_CHAR_TO_BUF(*sh->colbuf, (value & 0x7F) | 0x80);
+}
+
+static void EmitPair (intptr_t offset) {
+  intptr_t size;
+  Shared_p sh = GetShared();
+
+  size = sh->position - offset;
+  EmitVarInt(size);
+  if (size > 0)
+    EmitVarInt(offset);
+}
+
+static int TopBit (int v) {
+#define Vn(x) (v < (1<<x))
+  return Vn(16) ? Vn( 8) ? Vn( 4) ? Vn( 2) ? Vn( 1) ? v-1 : 1
+                                           : Vn( 3) ?  2 :  3
+                                  : Vn( 6) ? Vn( 5) ?  4 :  5
+                                           : Vn( 7) ?  6 :  7
+                         : Vn(12) ? Vn(10) ? Vn( 9) ?  8 :  9
+                                           : Vn(11) ? 10 : 11
+                                  : Vn(14) ? Vn(13) ? 12 : 13
+                                           : Vn(15) ? 14 : 15
+                : Vn(24) ? Vn(20) ? Vn(18) ? Vn(17) ? 16 : 17
+                                           : Vn(19) ? 18 : 19
+                                  : Vn(22) ? Vn(21) ? 20 : 21
+                                           : Vn(23) ? 22 : 23
+                         : Vn(28) ? Vn(26) ? Vn(25) ? 24 : 25
+                                           : Vn(27) ? 26 : 27
+                                  : Vn(30) ? Vn(29) ? 28 : 29
+                                           : Vn(31) ? 30 : 31;
+#undef Vn
+}
+
+static int MinWidth (int lo, int hi) {
+  lo = lo > 0 ? 0 : "444444445555555566666666666666666"[TopBit(~lo)+1] & 7;
+  hi = hi < 0 ? 0 : "012334445555555566666666666666666"[TopBit(hi)+1] & 7;
+  return lo > hi ? lo : hi;
+}
+
+static int FixFudge (int n, int w) {
+  static char fudges[3][4] = {  /* n:  1:  2:  3:  4: */
+    {3,3,4,5},      /* 1-bit entries:  1b  2b  3b  4b */
+    {5,5,1,1},      /* 2-bit entries:  2b  4b  6b  8b */
+    {6,1,2,2},      /* 4-bit entries:  4b  8b 12b 16b */
+  };
+  return n <= 4 && w <= 3 ? fudges[w-1][n-1] : ((n<<w)+14)>>4;
+}
+
+static int *PackedIntVec (int *data, int rows, intptr_t *outsize) {
+  int r, width, lo = 0, hi = 0, bits, *limit, *result;
+  intptr_t bytes;
+
+  for (r = 0; r < rows; ++r) {
+    if (data[r] < lo) lo = data[r];
+    if (data[r] > hi) hi = data[r];
+  }
+
+  width = MinWidth(lo, hi);
+
+  if (width >= 6) {
+    bytes = rows * (1 << (width-4));
+    result = malloc(bytes);
+    memcpy(result, data, bytes);
+  } else if (rows > 0 && width > 0) {
+    bytes = FixFudge(rows, width);
+    result = malloc(bytes);
+    memset(result, 0, bytes);
+
+    limit = data + rows;
+    bits = 0;
+
+    switch (width) {
+
+      case 1: { /* 1 bit, 8 per byte */
+        char* q = (char*) result;
+        while (data < limit) {
+          *q |= (*data++ & 1) << bits; ++bits; q += bits >> 3; bits &= 7;
+        }
+        break;
+      }
+
+      case 2: { /* 2 bits, 4 per byte */
+        char* q = (char*) result;
+        while (data < limit) {
+          *q |= (*data++ & 3) << bits; bits += 2; q += bits >> 3; bits &= 7;
+        }
+        break;
+      }
+
+      case 3: { /* 4 bits, 2 per byte */
+        char* q = (char*) result;
+        while (data < limit) {
+          *q |= (*data++ & 15) << bits; bits += 4; q += bits >> 3; bits &= 7;
+        }
+        break;
+      }
+
+      case 4: { /* 1-byte (char) */
+        char* q = (char*) result;
+        while (data < limit)
+          *q++ = (char) *data++;
+        break;
+      }
+
+      case 5: { /* 2-byte (short) */
+        short* q = (short*) result;
+        while (data < limit)
+          *q++ = (short) *data++;
+        break;
+      }
+    }
+  } else {
+    bytes = 0;
+    result = NULL;
+  }
+
+  *outsize = bytes;
+  return result;
+}
+
+static void EmitFixCol (Column column, ItemTypes type) {
+  int r, rows, *tempvec;
+  void *buffer;
+  intptr_t basepos, bufsize;
+  Shared_p sh = GetShared();
+
+  rows = S_Count(column.seq);
+
+  switch (type) {
+
+    case IT_int:
+      bufsize = rows * sizeof(int);
+      tempvec = malloc(bufsize);
+      for (r = 0; r < rows; ++r)
+        tempvec[r] = GetTypedItem(r, column, type).i;
+      buffer = PackedIntVec(tempvec, rows, &bufsize);
+      free((char*) tempvec); /* TODO: avoid extra copy & malloc */
+      break;
+
+    case IT_wide:
+      bufsize = rows * sizeof(int64_t);
+      buffer = malloc(bufsize);
+      for (r = 0; r < rows; ++r)
+        ((int64_t*) buffer)[r] = GetTypedItem(r, column, type).w;
+      break;
+
+    case IT_float:
+      bufsize = rows * sizeof(float);
+      buffer = malloc(bufsize);
+      for (r = 0; r < rows; ++r)
+        ((float*) buffer)[r] = GetTypedItem(r, column, type).f;
+      break;
+
+    case IT_double:
+      bufsize = rows * sizeof(double);
+      buffer = malloc(bufsize);
+      for (r = 0; r < rows; ++r)
+        ((double*) buffer)[r] = GetTypedItem(r, column, type).d;
+      break;
+
+    default: Assert(0); return;
+  }
+
+  /* start using 16-byte alignment once the emitted data reaches 1 Mb */
+  /* only do this for vectors >= 128 bytes, so worst-case waste is under 10% */
+  
+  Assert(!(bufsize > 0 && rows == 0));
+  if (bufsize >= 128 && bufsize / rows >= 2) 
+    EmitAlign();
+    
+  basepos = sh->position;
+  EmitBlock(buffer, bufsize);
+  EmitPair(basepos);
+}
+
+static void EmitVarCol (Column column, int istext) {
+  int r, rows, bytes, *sizevec;
+  intptr_t basepos;
+  Item item;
+  Buffer buffer;
+  Column sizes;
+  Shared_p sh = GetShared();
+
+  InitBuffer(&buffer);
+  rows = S_Count(column.seq);
+  sizes = NewIntVec(rows, &sizevec);
+
+  if (istext)
+    for (r = 0; r < rows; ++r) {
+      item = GetTypedItem(r, column, IT_string);
+      bytes = strlen(item.s);
+      if (bytes > 0)
+        AddToBuffer(&buffer, item.s, ++bytes);
+      sizevec[r] = bytes;
+    }
+  else
+    for (r = 0; r < rows; ++r) {
+      item = GetTypedItem(r, column, IT_bytes);
+      AddToBuffer(&buffer, item.u.ptr, item.u.len);
+      sizevec[r] = item.u.len;
+    }
+
+  basepos = sh->position;
+  EmitBlock(BufferAsPtr(&buffer, 0), BufferFill(buffer));
+  EmitPair(basepos);
+  
+  if (BufferFill(buffer) > 0)
+    EmitFixCol(sizes, 1);
+
+  ReleaseBuffer(&buffer, 1);
+  EmitVarInt(0); /* no memos */
+}
+
+static void EmitSubCol (Column column, int describe) {
+  int r, rows;
+  intptr_t basepos;
+  View_p view;
+  Buffer newcolbuf;
+  Buffer_p origcolbuf;
+  Shared_p sh = GetShared();
+
+  origcolbuf = sh->colbuf;
+  sh->colbuf = &newcolbuf;
+  InitBuffer(sh->colbuf);
+
+  rows = S_Count(column.seq);
+
+  for (r = 0; r < rows; ++r) {
+    view = GetTypedItem(r, column, IT_view).v;
+    EmitView(view, describe);
+  }
+
+  sh->colbuf = origcolbuf;
+
+  basepos = sh->position;
+  EmitBlock(BufferAsPtr(&newcolbuf, 0), BufferFill(newcolbuf));
+  EmitPair(basepos);
+
+  ReleaseBuffer(&newcolbuf, 1);
+}
+
+void EmitView (View_p view, int describe) {
+  int rows;
+  Shared_p sh = GetShared();
+
+  EmitVarInt(0);
+
+  if (describe) {
+    Buffer desc;
+
+    InitBuffer(&desc);
+    MetaAsDesc(V_Meta(view), &desc);
+
+    EmitVarInt(BufferFill(desc));
+    AddToBuffer(sh->colbuf, BufferAsPtr(&desc, 1), BufferFill(desc));
+
+    ReleaseBuffer(&desc, 0);
+  }
+
+  rows = ViewSize(view);
+  EmitVarInt(rows);
+
+  if (rows > 0) {
+    int c, cols = ViewWidth(view);
+    ItemTypes type;
+    Column column;
+    View_p subv, meta = V_Meta(view);
+
+    for (c = 0; c < cols; ++c) {
+      column = ViewCol(view,c);
+      type = ViewColType(view, c);
+      switch (type) {
+        
+        case IT_int:
+        case IT_wide:
+        case IT_float:
+        case IT_double:
+          EmitFixCol(column, type); 
+          break;
+          
+        case IT_string:
+          EmitVarCol(column, 1);
+          break;
+          
+        case IT_bytes:
+          EmitVarCol(column, 0);
+          break;
+          
+        case IT_view:
+          subv = GetTypedItem(c, ViewCol(meta, MC_subv), IT_view).v;
+          EmitSubCol(column, ViewSize(subv) == 0);
+          break;
+          
+        default: Assert(0);
+      }
+    }
+  }
+}
+
+static void SetBigEndian32 (char* dest, intptr_t value) {
+  dest[0] = (char) (value >> 24);
+  dest[1] = (char) (value >> 16);
+  dest[2] = (char) (value >> 8);
+  dest[3] = (char) value;
+}
+
+intptr_t EmitFull (View_p view, Buffer_p buffer) {
+  int overflow;
+  intptr_t rootpos, tailpos, endpos;
+  char tail[16];
+  struct Head { short a; char b; char c; char d[4]; } head, *fixup;
+  Buffer newcolbuf;
+  Shared_p sh = GetShared();
+
+  sh->position = 0;
+  sh->itembuf = buffer;
+
+  head.a = 'J' + ('L' << 8);
+  head.b = 0x1A;
+  head.c = 0;
+  fixup = EmitCopy(&head, sizeof head);
+
+  sh->colbuf = &newcolbuf;
+  InitBuffer(sh->colbuf);
+
+  EmitView(view, 1);
+
+  rootpos = EmitAlign();
+  
+  EmitBlock(BufferAsPtr(sh->colbuf, 0), BufferFill(*sh->colbuf));
+
+  ReleaseBuffer(sh->colbuf, 1);
+
+  sh->colbuf = NULL;
+
+  tailpos = EmitAlign();
+  endpos = tailpos + sizeof tail;
+  
+  /* large files will have bit 8 of head[3] and bit 8 of tail[12] set */
+  overflow = (endpos >> 16) >> 15; /* careful on 32-bit machines */
+
+  /* for file sizes > 2 Gb, store bits 41..31 in tail[2..3] */
+  SetBigEndian32(tail, 0x80000000 + overflow);
+  SetBigEndian32(tail+4, tailpos);
+  SetBigEndian32(tail+8, 0x80000000 + tailpos - rootpos);
+  SetBigEndian32(tail+12, rootpos);
+
+  if (overflow)
+    tail[12] |= 0x80;
+  
+  EmitCopy(tail, sizeof tail);
+  
+  if (overflow) {
+    /* store bits 41..36 in head[3], and bits 35..4 in head[4..7] */
+    Assert((endpos & 15) == 0);
+    fixup->c = 0x80 | ((endpos >> 16) >> 20);
+    SetBigEndian32(fixup->d, endpos >> 4);
+  } else
+    SetBigEndian32(fixup->d, endpos);
+    
+  return endpos;
+}
+/* %include<file.c>% */
+/*
+ * file.c - Implementation of memory-mapped file access.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifdef WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#endif
+
+/*
+ * file.h - Definition of memory-mapped file access.
+ */
+
+typedef Sequence_p MappedFile_p;
+
+#define MF_Data(map) ((const char*) ((map)->data[0].p))
+#define MF_Length(map) ((intptr_t) (map)->data[1].p)
+
+MappedFile_p (InitMappedFile) (const char *data, intptr_t length, Cleaner fun);
+View_p       (MappedToView) (MappedFile_p map);
+View_p       (MapSubview) (MappedFile_p map, intptr_t offset, View_p meta);
+View_p       (OpenDataFile) (const char *filename);
+MappedFile_p (OpenMappedFile) (const char *filename);
+
+MappedFile_p InitMappedFile (const char *data, intptr_t length, Cleaner fun) {
+  MappedFile_p map;
+  
+  /* data[0] points to the current start of the mapped area */
+  /* data[1] is the current length of the mapped area */
+  /* data[2] points to the original mapped area */
+  /* data[3] is available for storing an Object_p, see ext_tcl.c */
+  map = InitColumn(0, NULL, 0).seq;
+  map->data[0].p = (void*) data;
+  map->data[1].p = (void*) length;
+  map->data[2].p = (void*) data;
+  map->head.cleaner = fun;
+  return map;
+}
+
+static void MappedFileCleaner (MappedFile_p map) {
+#if WIN32
+  UnmapViewOfFile(map->data[2].p);
+#else
+  int offset = (char*) map->data[0].p - (char*) map->data[2].p;
+  munmap(map->data[2].p, (intptr_t) map->data[1].p + offset);
+#endif
+}
+
+MappedFile_p OpenMappedFile (const char *filename) {
+  const char *data = NULL;
+  intptr_t length = -1;
+    
+#if WIN32
+  {
+    DWORD n;
+    HANDLE h, f = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, 0,
+                              OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+    if (f != INVALID_HANDLE_VALUE) {
+      h = CreateFileMapping(f, 0, PAGE_READONLY, 0, 0, 0);
+      if (h != INVALID_HANDLE_VALUE) {
+        n = GetFileSize(f, 0);
+        data = MapViewOfFile(h, FILE_MAP_READ, 0, 0, n);
+        if (data != NULL)
+          length = n;
+        CloseHandle(h);
+      }
+      CloseHandle(f);
+    }
+  }
+#else
+  {
+    struct stat sb;
+    int fd = open(filename, O_RDONLY);
+    if (fd != -1) {
+      if (fstat(fd, &sb) == 0) {
+        data = mmap(0, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
+        if (data != MAP_FAILED)
+          length = sb.st_size;
+      }
+      close(fd);
+    }
+  }
+#endif
+
+  if (length < 0)
+    return NULL;
+    
+  return InitMappedFile(data, length, (Cleaner) MappedFileCleaner);
+}
+
+static void AdjustMappedFile (MappedFile_p map, int offset) {
+  map->data[0].p = (void*) (MF_Data(map) + offset);
+  map->data[1].p = (void*) (MF_Length(map) - offset);
+}
+
+static int IsReversedEndian(MappedFile_p map) {
+#if _BIG_ENDIAN
+  return *MF_Data(map) == 'J';
+#else
+  return *MF_Data(map) == 'L';
+#endif
+}
+
+static intptr_t GetVarInt (const char **cp) {
+  int8_t b;
+  intptr_t v = 0;
+  do {
+    b = *(*cp)++;
+    v = (v << 7) + b;
+  } while (b >= 0);
+  return v + 128;
+}
+
+static intptr_t GetVarPair(const char** cp) {
+  intptr_t n = GetVarInt(cp);
+  if (n > 0 && GetVarInt(cp) == 0)
+    *cp += n;
+  return n;
+}
+
+static void MappedViewCleaner (Sequence_p seq) {
+  int i, count;
+  const View_p *subviews = seq->data[0].p;
+  
+  count = S_Count((Sequence_p) seq->data[1].p);
+  for (i = 0; i < count; ++i)
+    DecRefCount(subviews[i]);
+  
+  DecRefCount(seq->data[1].p);
+  DecRefCount(seq->data[2].p);
+  DecRefCount(seq->data[3].p);
+}
+
+static ItemTypes MappedViewGetter (int row, Item_p item) {
+  View_p *subviews = item->c.seq->data[0].p;
+  
+  if (subviews[row] == NULL) {
+    const intptr_t *offsets = ((Sequence_p) item->c.seq->data[1].p)->data[0].p;
+    MappedFile_p map = item->c.seq->data[2].p;
+    View_p meta = item->c.seq->data[3].p;
+    subviews[row] = IncRefCount(MapSubview(map, offsets[row], meta));
+  }
+  
+  item->v = subviews[row];
+  return IT_view;
+}
+
+static Column MappedViewCol (MappedFile_p map, int rows, const char **nextp, View_p meta) {
+  int r, c, cols, subcols;
+  intptr_t colsize, colpos, *offsets;
+  const char *next;
+  Sequence_p offseq;
+  Column result;
+  
+  offseq = NewPtrVec(rows, &offsets).seq;
+  cols = ViewSize(meta);
+  
+  colsize = GetVarInt(nextp);
+  colpos = colsize > 0 ? GetVarInt(nextp) : 0;
+  next = MF_Data(map) + colpos;
+  
+  for (r = 0; r < rows; ++r) {
+    offsets[r] = next - MF_Data(map);
+    GetVarInt(&next);
+    if (cols == 0) {
+      intptr_t desclen = GetVarInt(&next);
+      const char *desc = next;
+      next += desclen;
+      meta = DescAsMeta(&desc, next);
+    }
+    if (GetVarInt(&next) > 0) {
+      subcols = ViewSize(meta);
+      for (c = 0; c < subcols; ++c)
+        switch (GetColType(meta, c)) {
+          case 'B': case 'S': if (GetVarPair(&next)) GetVarPair(&next);
+                              /* fall through */
+          default:            GetVarPair(&next);
+        }
+    }
+  }
+  
+  /* data[0] points to a subview cache */
+  /* data[1] points to a sequence owning the offest vector */
+  /* data[2] points to the mapped file */
+  /* data[3] points to the meta view */
+  result = InitColumn(rows, MappedViewGetter, rows * sizeof(View_p));
+  result.seq->head.cleaner = (Cleaner) MappedViewCleaner;
+  result.seq->data[1].p = IncRefCount(offseq);
+  result.seq->data[2].p = IncRefCount(map);
+  result.seq->data[3].p = IncRefCount(cols > 0 ? meta : EmptyMetaView());
+  
+  /* TODO: could combine subview cache and offsets vector */
+  
+  return result;
+}
+
+static void MappedFixedCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[1].p);
+}
+
+static Column MappedFixedCol (MappedFile_p map, int rows, const char **nextp, int isreal) {
+  intptr_t colsize, colpos;
+  Getter getter;
+  Column result;
+
+  colsize = GetVarInt(nextp);
+  colpos = colsize > 0 ? GetVarInt(nextp) : 0;
+  getter = FixedGetter(colsize, rows, isreal, IsReversedEndian(map));
+  
+  /* data[0] points to the mapped data */
+  /* data[1] points to the mapped file */
+  result = InitColumn(rows, getter, 0);
+  result.seq->head.cleaner = (Cleaner) MappedFixedCleaner;
+  result.seq->data[0].p = (void*) (MF_Data(map) + colpos);
+  result.seq->data[1].p = IncRefCount(map);
+  
+  return result;
+}
+
+static void MappedStringCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[0].p);
+  DecRefCount(seq->data[2].p);
+  DecRefCount(seq->data[3].p);
+}
+
+static ItemTypes MappedStringGetter (int row, Item_p item) {
+  const intptr_t *offsets = item->c.seq->data[1].p;
+  MappedFile_p map = item->c.seq->data[2].p;
+
+  if (offsets[row] == 0)
+    item->s = "";
+  else if (offsets[row] > 0)
+    item->s = MF_Data(map) + offsets[row];
+  else {
+    const char *next = MF_Data(map) - offsets[row];
+    if (GetVarInt(&next) > 0)
+      item->s = MF_Data(map) + GetVarInt(&next);
+    else
+      item->s = "";
+  }
+
+  return IT_string;
+}
+
+static ItemTypes MappedBytesGetter (int row, Item_p item) {
+  const intptr_t *offsets = item->c.seq->data[1].p;
+  MappedFile_p map = item->c.seq->data[2].p;
+  Sequence_p sizes = item->c.seq->data[3].p;
+  Column column;
+  
+  column.seq = sizes;
+  column.pos = -1;
+  item->u.len = GetTypedItem(row, column, IT_int).i;
+  
+  if (offsets[row] >= 0)
+    item->u.ptr = (const uint8_t*) MF_Data(map) + offsets[row];
+  else {
+    const char *next = MF_Data(map) - offsets[row];
+    item->u.len = GetVarInt(&next);
+    item->u.ptr = (const uint8_t*) MF_Data(map) + GetVarInt(&next);
+  }
+
+  return IT_bytes;
+}
+
+static Column MappedStringCol (MappedFile_p map, int rows, const char **nextp, int istext) {
+  int r, len, memopos;
+  intptr_t colsize, colpos, *offsets;
+  const char *next, *limit;
+  Sequence_p offseq;
+  Column sizes, result;
+
+  offseq = NewPtrVec(rows, &offsets).seq;
+
+  colsize = GetVarInt(nextp);
+  colpos = colsize > 0 ? GetVarInt(nextp) : 0;
+
+  if (colsize > 0) {
+    sizes = MappedFixedCol(map, rows, nextp, 0);
+    for (r = 0; r < rows; ++r) {
+      len = GetTypedItem(r, sizes, IT_int).i;
+      if (len > 0) {
+        offsets[r] = colpos;
+        colpos += len;
+      }
+    }
+  } else
+    sizes = InitColumn(rows, FixedGetter(0, rows, 0, 0), 0);
+
+  colsize = GetVarInt(nextp);
+  memopos = colsize > 0 ? GetVarInt(nextp) : 0;
+  next = MF_Data(map) + memopos;
+  limit = next + colsize;
+  
+  /* negated offsets point to the size/pos pair in the map */
+  for (r = 0; next < limit; ++r) {
+    r += (int) GetVarInt(&next);
+    offsets[r] = MF_Data(map) - next; /* always < 0 */
+    GetVarPair(&next);
+  }
+
+  /* data[0] points to a sequence owning the offset vector */
+  /* data[1] points to that vector of subview offsets */
+  /* data[2] points to the mapped file */
+  /* data[3] points to the sizes seq if binary or is null if zero-terminated */
+  result = InitColumn(rows, istext ? MappedStringGetter : MappedBytesGetter, 0);
+  result.seq->head.cleaner = (Cleaner) MappedStringCleaner;
+  result.seq->data[0].p = IncRefCount(offseq);
+  result.seq->data[1].p = offsets;
+  result.seq->data[2].p = IncRefCount(map);
+  result.seq->data[3].p = istext ? NULL : IncRefCount(sizes.seq);
+
+  return result;
+}
+
+View_p MapSubview (MappedFile_p map, intptr_t offset, View_p meta) {
+  int c, cols, rows;
+  const char *next;
+  Column column;
+  View_p result, subview;
+  
+  next = MF_Data(map) + offset;
+  GetVarInt(&next);
+  
+  if (ViewSize(meta) == 0) {
+    intptr_t desclen = GetVarInt(&next);
+    const char *desc = next;
+    next += desclen;
+    meta = DescAsMeta(&desc, next);
+  }
+  
+  rows = (int) GetVarInt(&next);
+  cols = ViewSize(meta);
+  
+  if (cols == 0)
+    return NoColumnView(rows);
+  
+  result = NewView(meta);
+  
+  if (rows > 0)
+    for (c = 0; c < cols; ++c) {
+      switch (ViewColType(result, c)) {
+        
+        case IT_int:
+        case IT_wide:
+          column = MappedFixedCol(map, rows, &next, 0); 
+          break;
+
+        case IT_float:
+        case IT_double:
+          column = MappedFixedCol(map, rows, &next, 1);
+          break;
+          
+        case IT_string:
+          column = MappedStringCol(map, rows, &next, 1); 
+          break;
+          
+        case IT_bytes:
+          column = MappedStringCol(map, rows, &next, 0);
+          break;
+          
+        case IT_view:
+          subview = GetTypedItem(c, ViewCol(meta, MC_subv), IT_view).v;
+          column = MappedViewCol(map, rows, &next, subview); 
+          break;
+          
+        default:
+          Assert(0);
+          return result;
+      }
+      SetViewColumns(result, c, 1, column);
+    }
+
+  return result;
+}
+
+static int BigEndianInt32 (const char *p) {
+  const uint8_t *up = (const uint8_t*) p;
+  return (p[0] << 24) | (up[1] << 16) | (up[2] << 8) | up[3];
+}
+
+View_p MappedToView (MappedFile_p map) {
+  int i, t[4];
+  intptr_t datalen, rootoff;
+  
+  if (MF_Length(map) < 24 || *(MF_Data(map) + MF_Length(map) - 8) != '\x80')
+    return NULL;
+    
+  for (i = 0; i < 4; ++i)
+    t[i] = BigEndianInt32(MF_Data(map) + MF_Length(map) - 16 + i * 4);
+    
+  datalen = t[1] + 16;
+  rootoff = t[3];
+
+  if (rootoff < 0) {
+    const intptr_t mask = 0x7FFFFFFF; 
+    datalen = (datalen & mask) + ((intptr_t) ((t[0] & 0x7FF) << 16) << 15);
+    rootoff = (rootoff & mask) + (datalen & ~mask);
+  }
+  
+  AdjustMappedFile(map, MF_Length(map) - datalen);
+  return MapSubview(map, rootoff, EmptyMetaView());
+}
+
+View_p OpenDataFile (const char *filename) {
+  MappedFile_p map;
+  
+  map = OpenMappedFile(filename);
+  if (map == NULL)
+    return NULL;
+    
+  return MappedToView(map);
+}
+/* %include<getters.c>% */
+/*
+ * getters.c - Implementation of several simple getter functions.
+ */
+
+#include <stdlib.h>
+
+
+static ItemTypes Getter_i0 (int row, Item_p item) {
+  item->i = 0;
+  return IT_int;
+}
+
+static ItemTypes Getter_i1 (int row, Item_p item) {
+  const char *ptr = item->c.seq->data[0].p;
+  item->i = (ptr[row>>3] >> (row&7)) & 1;
+  return IT_int;
+}
+
+static ItemTypes Getter_i2 (int row, Item_p item) {
+  const char *ptr = item->c.seq->data[0].p;
+  item->i = (ptr[row>>2] >> 2*(row&3)) & 3;
+  return IT_int;
+}
+
+static ItemTypes Getter_i4 (int row, Item_p item) {
+  const char *ptr = item->c.seq->data[0].p;
+  item->i = (ptr[row>>1] >> 4*(row&1)) & 15;
+  return IT_int;
+}
+
+static ItemTypes Getter_i8 (int row, Item_p item) {
+  const char *ptr = item->c.seq->data[0].p;
+  item->i = (int8_t) ptr[row];
+  return IT_int;
+}
+
+#if VALUES_MUST_BE_ALIGNED
+
+static ItemTypes Getter_i16 (int row, Item_p item) {
+  const uint8_t *ptr = (const uint8_t*) item->c.seq->data[0].p + row * 2;
+#if _BIG_ENDIAN
+  item->i = (((int8_t) ptr[0]) << 8) | ptr[1];
+#else
+  item->i = (((int8_t) ptr[1]) << 8) | ptr[0];
+#endif
+  return IT_int;
+}
+
+static ItemTypes Getter_i32 (int row, Item_p item) {
+  const char *ptr = (const char*) item->c.seq->data[0].p + row * 4;
+  int i;
+  for (i = 0; i < 4; ++i)
+    item->b[i] = ptr[i];
+  return IT_int;
+}
+
+static ItemTypes Getter_i64 (int row, Item_p item) {
+  const char *ptr = (const char*) item->c.seq->data[0].p + row * 8;
+  int i;
+  for (i = 0; i < 8; ++i)
+    item->b[i] = ptr[i];
+  return IT_wide;
+}
+
+static ItemTypes Getter_f32 (int row, Item_p item) {
+  Getter_i32(row, item);
+  return IT_float;
+}
+
+static ItemTypes Getter_f64 (int row, Item_p item) {
+  Getter_i64(row, item);
+  return IT_double;
+}
+
+#else
+
+static ItemTypes Getter_i16 (int row, Item_p item) {
+  const char *ptr = item->c.seq->data[0].p;
+  item->i = ((short*) ptr)[row];
+  return IT_int;
+}
+
+static ItemTypes Getter_i32 (int row, Item_p item) {
+  const char *ptr = item->c.seq->data[0].p;
+  item->i = ((const int*) ptr)[row];
+  return IT_int;
+}
+
+static ItemTypes Getter_i64 (int row, Item_p item) {
+  const char *ptr = item->c.seq->data[0].p;
+  item->w = ((const int64_t*) ptr)[row];
+  return IT_wide;
+}
+
+static ItemTypes Getter_f32 (int row, Item_p item) {
+  const char *ptr = item->c.seq->data[0].p;
+  item->f = ((const float*) ptr)[row];
+  return IT_float;
+}
+
+static ItemTypes Getter_f64 (int row, Item_p item) {
+  const char *ptr = item->c.seq->data[0].p;
+  item->d = ((const double*) ptr)[row];
+  return IT_double;
+}
+
+#endif
+
+static ItemTypes Getter_i16r (int row, Item_p item) {
+  const uint8_t *ptr = (const uint8_t*) item->c.seq->data[0].p + row * 2;
+#if _BIG_ENDIAN
+  item->i = (((int8_t) ptr[1]) << 8) | ptr[0];
+#else
+  item->i = (((int8_t) ptr[0]) << 8) | ptr[1];
+#endif
+  return IT_int;
+}
+
+static ItemTypes Getter_i32r (int row, Item_p item) {
+  const char *ptr = (const char*) item->c.seq->data[0].p + row * 4;
+  int i;
+  for (i = 0; i < 4; ++i)
+    item->b[i] = ptr[3-i];
+  return IT_int;
+}
+
+static ItemTypes Getter_i64r (int row, Item_p item) {
+  const char *ptr = (const char*) item->c.seq->data[0].p + row * 8;
+  int i;
+  for (i = 0; i < 8; ++i)
+    item->b[i] = ptr[7-i];
+  return IT_wide;
+}
+
+static ItemTypes Getter_f32r (int row, Item_p item) {
+  Getter_i32r(row, item);
+  return IT_float;
+}
+
+static ItemTypes Getter_f64r (int row, Item_p item) {
+  Getter_i64r(row, item);
+  return IT_double;
+}
+
+Getter PickIntGetter (int bits) {
+  switch (bits) {
+    default:  Assert(0); /* fall through */
+    case 0:   return Getter_i0;
+    case 1:   return Getter_i1;
+    case 2:   return Getter_i2;
+    case 4:   return Getter_i4;
+    case 8:   return Getter_i8;
+    case 16:  return Getter_i16;
+    case 32:  return Getter_i32;
+    case 64:  return Getter_i64;
+  }
+}
+
+Getter FixedGetter (int bytes, int rows, int real, int flip) {
+  int bits;
+
+  static char widths[8][7] = {
+    {0,-1,-1,-1,-1,-1,-1},
+    {0, 8,16, 1,32, 2, 4},
+    {0, 4, 8, 1,16, 2,-1},
+    {0, 2, 4, 8, 1,-1,16},
+    {0, 2, 4,-1, 8, 1,-1},
+    {0, 1, 2, 4,-1, 8,-1},
+    {0, 1, 2, 4,-1,-1, 8},
+    {0, 1, 2,-1, 4,-1,-1},
+  };
+
+  bits = rows < 8 && bytes < 7 ? widths[rows][bytes] : (bytes << 3) / rows;
+
+  switch (bits) {
+    case 16:  return flip ? Getter_i16r : Getter_i16;
+    case 32:  return real ? flip ? Getter_f32r : Getter_f32
+                          : flip ? Getter_i32r : Getter_i32;
+    case 64:  return real ? flip ? Getter_f64r : Getter_f64
+                          : flip ? Getter_i64r : Getter_i64;
+  }
+
+  return PickIntGetter(bits);
+}
+/* %include<hash.c>% */
+/*
+ * hash.c - Implementation of hashing functions.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * hash.h - Definition of hashing functions.
+ */
+
+Column (HashCol) (ItemTypes type, Column column);
+int    (HashDoFind) (View_p view, int row, View_p w, Column, Column, Column);
+Column (GetHashInfo) (View_p left, View_p right, int type);
+View_p (GroupCol) (View_p view, Column cols, const char *name);
+Column (HashValues) (View_p view);
+View_p (IjoinView) (View_p left, View_p right);
+Column (IntersectMap) (View_p keys, View_p view);
+View_p (JoinView) (View_p left, View_p right, const char *name);
+int    (RowHash) (View_p view, int row);
+int    (StringLookup) (const char *key, Column values);
+Column (UniqMap) (View_p view);
+/*
+ * sorted.h - Definition of sorting functions.
+ */
+
+int       (RowCompare) (int r1, View_p v1, int r2, View_p v2);
+int       (RowEqual) (int r1, View_p v1, int r2, View_p v2);
+Column    (SortMap) (View_p view);
+/*
+ * indirect.h - Definition of some virtual views.
+ */
+
+View_p (BlockedView) (View_p view);
+View_p (ConcatView) (View_p view1, View_p view2);
+View_p (GroupedView) (View_p view, Column scol, Column gcol, const char *name);
+View_p (RemapSubview) (View_p view, Column mapcol, int start, int count);
+View_p (StepView) (View_p view, int count, int offset, int rate, int step);
+View_p (UngroupView) (View_p view, int col);
+/* wrap_gen.h - generated code, do not edit */
+
+ItemTypes (AppendCmd_VV) (Item_p a);
+ItemTypes (AtRowCmd_OI) (Item_p a);
+ItemTypes (BlockedCmd_V) (Item_p a);
+ItemTypes (CloneCmd_V) (Item_p a);
+ItemTypes (CoerceCmd_OS) (Item_p a);
+ItemTypes (ColConvCmd_C) (Item_p a);
+ItemTypes (ColMapCmd_Vn) (Item_p a);
+ItemTypes (ColOmitCmd_Vn) (Item_p a);
+ItemTypes (CompareCmd_VV) (Item_p a);
+ItemTypes (CompatCmd_VV) (Item_p a);
+ItemTypes (ConcatCmd_VV) (Item_p a);
+ItemTypes (CountsCmd_VN) (Item_p a);
+ItemTypes (CountsColCmd_C) (Item_p a);
+ItemTypes (CountViewCmd_I) (Item_p a);
+ItemTypes (DataCmd_VX) (Item_p a);
+ItemTypes (DefCmd_OO) (Item_p a);
+ItemTypes (DeleteCmd_VII) (Item_p a);
+ItemTypes (EmitCmd_V) (Item_p a);
+ItemTypes (ExceptCmd_VV) (Item_p a);
+ItemTypes (ExceptMapCmd_VV) (Item_p a);
+ItemTypes (FirstCmd_VI) (Item_p a);
+ItemTypes (GetCmd_VX) (Item_p a);
+ItemTypes (GetColCmd_VN) (Item_p a);
+ItemTypes (GetInfoCmd_VVI) (Item_p a);
+ItemTypes (GroupCmd_VnS) (Item_p a);
+ItemTypes (GroupedCmd_ViiS) (Item_p a);
+ItemTypes (GroupInfoCmd_V) (Item_p a);
+ItemTypes (HashColCmd_SO) (Item_p a);
+ItemTypes (HashFindCmd_VIViii) (Item_p a);
+ItemTypes (HashInfoCmd_V) (Item_p a);
+ItemTypes (HashViewCmd_V) (Item_p a);
+ItemTypes (IjoinCmd_VV) (Item_p a);
+ItemTypes (InsertCmd_VIV) (Item_p a);
+ItemTypes (IntersectCmd_VV) (Item_p a);
+ItemTypes (IotaCmd_I) (Item_p a);
+ItemTypes (IsectMapCmd_VV) (Item_p a);
+ItemTypes (JoinCmd_VVS) (Item_p a);
+ItemTypes (JoinInfoCmd_VV) (Item_p a);
+ItemTypes (LastCmd_VI) (Item_p a);
+ItemTypes (LoadCmd_O) (Item_p a);
+ItemTypes (LoopCmd_X) (Item_p a);
+ItemTypes (MaxCmd_VN) (Item_p a);
+ItemTypes (MdefCmd_O) (Item_p a);
+ItemTypes (MdescCmd_S) (Item_p a);
+ItemTypes (MetaCmd_V) (Item_p a);
+ItemTypes (MinCmd_VN) (Item_p a);
+ItemTypes (NameColCmd_V) (Item_p a);
+ItemTypes (NamesCmd_V) (Item_p a);
+ItemTypes (OmitMapCmd_iI) (Item_p a);
+ItemTypes (OpenCmd_S) (Item_p a);
+ItemTypes (PairCmd_VV) (Item_p a);
+ItemTypes (ProductCmd_VV) (Item_p a);
+ItemTypes (RefCmd_OX) (Item_p a);
+ItemTypes (RefsCmd_O) (Item_p a);
+ItemTypes (RemapCmd_Vi) (Item_p a);
+ItemTypes (RemapSubCmd_ViII) (Item_p a);
+ItemTypes (RenameCmd_VO) (Item_p a);
+ItemTypes (RepeatCmd_VI) (Item_p a);
+ItemTypes (ReplaceCmd_VIIV) (Item_p a);
+ItemTypes (ReverseCmd_V) (Item_p a);
+ItemTypes (RowEqCmd_IVIV) (Item_p a);
+ItemTypes (RowHashCmd_VI) (Item_p a);
+ItemTypes (SaveCmd_VS) (Item_p a);
+ItemTypes (SetCmd_VIX) (Item_p a);
+ItemTypes (SizeCmd_V) (Item_p a);
+ItemTypes (SliceCmd_VIII) (Item_p a);
+ItemTypes (SortCmd_V) (Item_p a);
+ItemTypes (SortMapCmd_V) (Item_p a);
+ItemTypes (SpreadCmd_VI) (Item_p a);
+ItemTypes (StepCmd_VIIII) (Item_p a);
+ItemTypes (StrLookupCmd_Ss) (Item_p a);
+ItemTypes (StructDescCmd_V) (Item_p a);
+ItemTypes (StructureCmd_V) (Item_p a);
+ItemTypes (SumCmd_VN) (Item_p a);
+ItemTypes (TagCmd_VS) (Item_p a);
+ItemTypes (TakeCmd_VI) (Item_p a);
+ItemTypes (ToCmd_OO) (Item_p a);
+ItemTypes (TypeCmd_O) (Item_p a);
+ItemTypes (TypesCmd_V) (Item_p a);
+ItemTypes (UngroupCmd_VN) (Item_p a);
+ItemTypes (UnionCmd_VV) (Item_p a);
+ItemTypes (UnionMapCmd_VV) (Item_p a);
+ItemTypes (UniqueCmd_V) (Item_p a);
+ItemTypes (UniqueMapCmd_V) (Item_p a);
+ItemTypes (ViewCmd_X) (Item_p a);
+ItemTypes (ViewAsColCmd_V) (Item_p a);
+ItemTypes (ViewConvCmd_V) (Item_p a);
+ItemTypes (WidthCmd_V) (Item_p a);
+ItemTypes (WriteCmd_VS) (Item_p a);
+
+/* end of generated code */
+
+typedef struct HashInfo *HashInfo_p;
+
+typedef struct HashInfo {
+  View_p  view;     /* input view */
+  int     prime;    /* prime used for hashing */
+  int     fill;     /* used to fill map */
+  int    *map;      /* map of unique rows */
+  Column  mapcol;   /* owner of map */
+  int    *hvec;     /* hash probe vector */
+  Column  veccol;   /* owner of hvec */
+  int    *hashes;   /* hash values, one per view row */
+  Column  hashcol;  /* owner of hashes */
+} HashInfo;
+
+static int StringHash (const char *s, int n) {
+  /* similar to Python's stringobject.c */
+  int i, h = (*s * 0xFF) << 7;
+  if (n == INVALID_COUNT)
+    n = strlen(s);
+  for (i = 0; i < n; ++i)
+    h = (1000003 * h) ^ s[i];
+  return h ^ i;
+}
+
+Column HashCol (ItemTypes type, Column column) {
+  int i, count, *data;
+  Column result;
+  Item item;
+
+/* the folowing is not possible: the result may be xor-ed into!
+  if (type == IT_int && column.seq->getter == PickIntGetter(32))
+    return column;
+*/
+
+  count = S_Count(column.seq);
+  result = NewIntVec(count, &data);
+
+  switch (type) {
+    
+    case IT_int:
+      for (i = 0; i < count; ++i)
+        data[i] = GetTypedItem(i, column, IT_int).i;
+      break;
+        
+    case IT_wide:
+      for (i = 0; i < count; ++i) {
+        item = GetTypedItem(i, column, IT_wide);
+        data[i] = item.q[0] ^ item.q[1];
+      }
+      break;
+        
+    case IT_float:
+      for (i = 0; i < count; ++i)
+        data[i] = GetTypedItem(i, column, IT_float).i;
+      break;
+        
+    case IT_double:
+      for (i = 0; i < count; ++i) {
+        item = GetTypedItem(i, column, IT_double);
+        data[i] = item.q[0] ^ item.q[1];
+      }
+      break;
+        
+    case IT_string:
+      for (i = 0; i < count; ++i) {
+        item = GetTypedItem(i, column, IT_string);
+        data[i] = StringHash(item.s, INVALID_COUNT);
+      }
+      break;
+        
+    case IT_bytes:
+      for (i = 0; i < count; ++i) {
+        item = GetTypedItem(i, column, IT_bytes);
+        data[i] = StringHash((const char*) item.u.ptr, item.u.len);
+      }
+      break;
+        
+    case IT_view:
+      for (i = 0; i < count; ++i) {
+        int j, hcount, hval = 0;
+        const int *hvec;
+        Column hashes;
+        
+        item = GetTypedItem(i, column, IT_view);
+        hashes = HashValues(item.v);
+        hvec = (const int*) hashes.seq->data[0].p;
+        hcount = S_Count(hashes.seq);
+        
+        for (j = 0; j < hcount; ++j)
+          hval ^= hvec[j];
+        /* TODO: release hashes right now */
+      
+        data[i] = hval ^ hcount;
+      }
+      break;
+        
+    default: Assert(0);
+  }
+
+  return result;
+}
+
+ItemTypes HashColCmd_SO (Item args[]) {
+  ItemTypes type;
+  Column column;
+  
+  type = CharAsItemType(args[0].s[0]);
+  column = CoerceColumn(type, args[1].o);
+  if (column.seq == NULL)
+    return IT_unknown;
+    
+  args[0].c = HashCol(type, column);
+  return IT_column;
+}
+
+int RowHash (View_p view, int row) {
+  int c, cols = ViewWidth(view), hash = 0;
+  Item item;
+
+  for (c = 0; c < cols; ++c) {
+    item.c = V_Cols(view)[c];
+    switch (GetItem(row, &item)) {
+
+      case IT_int:
+        hash ^= item.i;
+        break;
+
+      case IT_string:
+        hash ^= StringHash(item.s, INVALID_COUNT);
+        break;
+
+      case IT_bytes:
+        hash ^= StringHash((const char*) item.u.ptr, item.u.len);
+        break;
+
+      default: {
+        View_p rview = StepView(view, 1, row, 1, 1);
+        Column rcol = HashValues(rview);
+        hash = *(const int*) rcol.seq->data[0].p;
+        break;
+      }
+    }
+  }
+
+  return hash;
+}
+
+static void XorWithIntCol (Column src, Column_p dest) {
+  const int *srcdata = (const int*) src.seq->data[0].p;
+  int i, count = S_Count(src.seq), *destdata = (int*) dest->seq->data[0].p;
+
+  for (i = 0; i < count; ++i)
+    destdata[i] ^= srcdata[i];
+}
+
+Column HashValues (View_p view) {
+  int c, rows = ViewSize(view), cols = ViewWidth(view);
+  Column result;
+
+  if (cols == 0 || rows == 0)
+    return NewIntVec(rows, NULL);
+    
+  result = HashCol(ViewColType(view, 0), V_Cols(view)[0]);
+  for (c = 1; c < cols; ++c) {
+    Column auxcol = HashCol(ViewColType(view, c), V_Cols(view)[c]);
+    /* TODO: get rid of the separate xor step by xoring in HashCol */
+    XorWithIntCol(auxcol, &result);
+  }
+  return result;
+}
+
+static int HashFind (View_p keyview, int keyrow, int keyhash, HashInfo_p data) {
+  int probe, datarow, mask, step;
+
+  mask = S_Count(data->veccol.seq) - 1;
+  probe = ~keyhash & mask;
+
+  step = (keyhash ^ (keyhash >> 3)) & mask;
+  if (step == 0)
+    step = mask;
+
+  for (;;) {
+    probe = (probe + step) & mask;
+    if (data->hvec[probe] == 0)
+      break;
+
+    datarow = data->map[data->hvec[probe]-1];
+    if (keyhash == data->hashes[datarow] &&
+        RowEqual(keyrow, keyview, datarow, data->view))
+      return data->hvec[probe] - 1;
+
+    step <<= 1;
+    if (step > mask)
+      step ^= data->prime;
+  }
+
+  if (keyview == data->view) {
+    data->hvec[probe] = data->fill + 1;
+    data->map[data->fill++] = keyrow;
+  }
+
+  return -1;
+}
+
+static int StringHashFind (const char *key, Sequence_p hseq, int prime, Column values) {
+  int probe, datarow, mask, step, keyhash;
+  const int *hvec = (const int*) hseq->data[0].p;
+
+  keyhash = StringHash(key, INVALID_COUNT);
+  mask = S_Count(hseq) - 1;
+  probe = ~keyhash & mask;
+
+  step = (keyhash ^ (keyhash >> 3)) & mask;
+  if (step == 0)
+    step = mask;
+
+  for (;;) {
+    probe = (probe + step) & mask;
+    datarow = hvec[probe] - 1;
+    if (datarow < 0)
+      break;
+
+    /* These string hashes are much simpler than the standard HashFind:
+       no hashes vector, no indirect map, compute all hashes on-the-fly */
+        
+    if (strcmp(key, GetTypedItem(datarow, values, IT_string).s) == 0)
+      return datarow;
+
+    step <<= 1;
+    if (step > mask)
+      step ^= prime;
+  }
+
+  return ~probe;
+}
+
+static int Log2bits (int n) {
+  int bits = 0;
+  while ((1 << bits) < n)
+    ++bits;
+  return bits;
+}
+
+static Column HashVector (int rows) {
+  int bits = Log2bits((4 * rows) / 3);
+  if (bits < 2)
+    bits = 2;
+  return NewIntVec(1 << bits, NULL);
+}
+
+static void InitHashInfo (HashInfo_p info, View_p view, Column hmap, Column hvec, Column hashes) {
+  int size = S_Count(hvec.seq);
+
+  static char slack [] = {
+    0, 0, 3, 3, 3, 5, 3, 3, 29, 17, 9, 5, 83, 27, 43, 3,
+    45, 9, 39, 39, 9, 5, 3, 33, 27, 9, 71, 39, 9, 5, 83, 0
+  };
+
+  info->view = view;
+  info->prime = size + slack[Log2bits(size-1)];
+  info->fill = 0;
+  
+  info->mapcol = hmap;
+  info->map = (int*) hmap.seq->data[0].p;
+
+  info->veccol = hvec;
+  info->hvec = (int*) hvec.seq->data[0].p;
+
+  info->hashcol = hashes;
+  info->hashes = (int*) hashes.seq->data[0].p;
+}
+
+int StringLookup (const char *key, Column values) {
+  int h, r, rows, *hptr;
+  const char *string;
+  Column hvec;
+  HashInfo info;
+  
+  /* adjust data[2] and data[3], this assumes values is a string column */
+  
+  if (values.seq->data[2].p == NULL) {
+    rows = S_Count(values.seq);
+    hvec = HashVector(rows);
+    hptr = (int*) hvec.seq->data[0].p;
+    
+    /* use InitHashInfo to get at the prime number, bit of a hack */
+    InitHashInfo(&info, NULL, hvec, hvec, hvec);
+    
+    for (r = 0; r < rows; ++r) {
+      string = GetTypedItem(r, values, IT_string).s;
+      h = StringHashFind(string, hvec.seq, info.prime, values);
+      if (h < 0) /* silently ignore duplicates */
+        hptr[~h] = r + 1;
+    }
+    
+    values.seq->data[2].p = IncRefCount(hvec.seq);
+    values.seq->data[3].i = info.prime;
+  }
+  
+  h = StringHashFind(key, (Sequence_p) values.seq->data[2].p,
+                           values.seq->data[3].i, values);
+  return h >= 0 ? h : -1;
+}
+
+static void FillHashInfo (HashInfo_p info, View_p view) {
+  int r, rows;
+  Column mapcol;
+  
+  rows = ViewSize(view);
+  mapcol = NewIntVec(rows, NULL);   /* worst-case, don't know #groups yet */
+
+  InitHashInfo(info, view, mapcol, HashVector(rows), HashValues(view));
+
+  for (r = 0; r < rows; ++r)
+    HashFind(view, r, info->hashes[r], info);
+
+  /* TODO: reclaim unused entries at end of map */
+  S_Count(mapcol.seq) = info->fill;
+}
+
+static void ChaseLinks (HashInfo_p info, int count, const int *hmap, const int *lmap) {
+  int groups = info->fill, *smap = info->hvec, *gmap = info->hashes;
+  
+  while (--groups >= 0) {
+    int head = hmap[groups] - 1;
+    smap[groups] = count;
+    while (head >= 0) {
+      gmap[--count] = head;
+      head = lmap[head];
+    }
+  }
+  /* assert(count == 0); */
+}
+
+void FillGroupInfo (HashInfo_p info, View_p view) {
+  int g, r, rows, *hmap, *lmap;
+  Column mapcol, headmap, linkmap;
+  
+  rows = ViewSize(view);
+  mapcol = NewIntVec(rows, NULL);   /* worst-case, don't know #groups yet */
+  headmap = NewIntVec(rows, &hmap); /* worst-case, don't know #groups yet */
+  linkmap = NewIntVec(rows, &lmap);
+
+  InitHashInfo(info, view, mapcol, HashVector(rows), HashValues(view));
+
+  for (r = 0; r < rows; ++r) {
+    g = HashFind(view, r, info->hashes[r], info);
+    if (g < 0)
+      g = info->fill - 1;
+    lmap[r] = hmap[g] - 1;
+    hmap[g] = r + 1;
+  }
+  
+  /* TODO: reclaim unused entries at end of map and hvec */
+  S_Count(info->mapcol.seq) = S_Count(info->veccol.seq) = info->fill;
+  
+  ChaseLinks(info, rows, hmap, lmap);
+
+  /* TODO: could release headmap and linkmap but that's a no-op here */
+  
+  /*  There's probably an opportunity to reduce space usage further,
+      since the grouping map points to the starting row of each group:
+        map[i] == gmap[smap[i]]
+      Perhaps "map" (which starts out with #rows entries) can be re-used
+      to append the gmap entries (if we can reduce it by #groups items).
+      Or just release map[x] for grouping views, and use gmap[smap[x]].
+  */
+}
+
+void GroupInfo (View_p view, Column_p mcol, Column_p scol, Column_p gcol) {
+  /* TODO: get rid of this silly wrapper (due to HashInfo being private) */
+  HashInfo info;
+  FillGroupInfo(&info, view);
+  *mcol = info.mapcol;
+  *scol = info.veccol;
+  *gcol = info.hashcol;
+}
+
+View_p GroupCol (View_p view, Column cols, const char *name) {
+  View_p vkey, vres, gview;
+  HashInfo info;
+  
+  vkey = ColMapView(view, cols);
+  vres = ColMapView(view, OmitColumn(cols, ViewWidth(view)));
+
+  FillGroupInfo(&info, vkey);
+  gview = GroupedView(vres, info.veccol, info.hashcol, name);
+  return PairView(RemapSubview(vkey, info.mapcol, 0, -1), gview);
+}
+
+static void FillJoinInfo (HashInfo_p info, View_p left, View_p right) {
+  int g, r, gleft, nleft, nright, nused = 0, *hmap, *lmap, *jmap;
+  Column mapcol, headmap, linkmap, joincol;
+  
+  nleft = ViewSize(left);
+  mapcol = NewIntVec(nleft, NULL);   /* worst-case, don't know #groups yet */
+  joincol = NewIntVec(nleft, &jmap);
+  
+  InitHashInfo(info, left, mapcol, HashVector(nleft), HashValues(left));
+
+  for (r = 0; r < nleft; ++r) {
+    g = HashFind(left, r, info->hashes[r], info);
+    if (g < 0)
+      g = info->fill - 1;
+    jmap[r] = g;
+  }
+
+  /* TODO: reclaim unused entries at end of map */
+  S_Count(mapcol.seq) = info->fill;
+
+  gleft = S_Count(info->mapcol.seq);
+  nleft = S_Count(info->hashcol.seq);
+  nright = ViewSize(right);
+  
+  headmap = NewIntVec(gleft, &hmap); /* worst-case, don't know #groups yet */
+  linkmap = NewIntVec(nright, &lmap);
+
+  for (r = 0; r < nright; ++r) {
+    g = HashFind(right, r, RowHash(right, r), info);
+    if (g >= 0) {
+      lmap[r] = hmap[g] - 1;
+      hmap[g] = r + 1;
+      ++nused;
+    }
+  }
+
+  /* we're reusing veccol, but it might not be large enough to start with */
+  /* TODO: reclaim unused entries at end of hvec */
+  if (S_Count(info->veccol.seq) < nused)
+    info->veccol = NewIntVec(nused, &info->hvec);
+  else 
+    S_Count(info->veccol.seq) = nused;
+
+  /* reorder output to match results from FillHashInfo and FillGroupInfo */
+  info->hashcol = info->veccol;
+  info->hashes = info->hvec;
+  info->veccol = info->mapcol;
+  info->hvec = info->map;
+  info->mapcol = joincol;
+  info->map = jmap;
+  
+  ChaseLinks(info, nused, hmap, lmap);
+  
+  /*  As with FillGroupInfo, this is most likely not quite optimal yet.  
+      All zero-length groups in smap (info->map, now info->hvec) could be 
+      coalesced into one, and joinmap indices into it adjusted down a bit.
+      Would reduce the size of smap when there are lots of failed matches.
+      Also: FillJoinInfo needs quite a lot of temp vector space right now.
+   */
+}
+
+View_p JoinView (View_p left, View_p right, const char *name) {
+  View_p lnames, rnames, lkey, rkey, rres, gview;
+  Column lmap, rmap;
+  HashInfo info;
+  
+  lnames = NameColView(left);
+  rnames = NameColView(right);
+  lmap = IntersectMap(rnames, lnames);
+  rmap = IntersectMap(lnames, rnames);
+  
+  lkey = ColMapView(left, lmap);
+  rkey = ColMapView(right, rmap);
+  rres = ColMapView(right, OmitColumn(rmap, ViewWidth(right)));
+  
+  FillJoinInfo(&info, lkey, rkey);
+  gview = GroupedView(rres, info.veccol, info.hashcol, name);
+  return PairView(left, RemapSubview(gview, info.mapcol, 0, -1));
+}
+
+Column UniqMap (View_p view) {
+  HashInfo info;
+  FillHashInfo(&info, view);
+  return info.mapcol;
+}
+
+Column IntersectMap (View_p keys, View_p view) {
+  int r, rows, *output, fill = 0;
+  HashInfo info;
+  Column result;
+  
+  FillHashInfo(&info, view);
+  
+  rows = ViewSize(keys);
+  result = NewIntVec(rows, &output);
+  
+  for (r = 0; r < rows; ++r)
+    if (HashFind(keys, r, RowHash(keys, r), &info) >= 0)
+      output[fill++] = r;
+
+  /* TODO: reclaim unused entries at end of map */
+  S_Count(result.seq) = fill;
+  return result;
+}
+
+int HashDoFind (View_p view, int row, View_p w, Column a, Column b, Column c) {
+  HashInfo info;
+  /* TODO: avoid Log2bits call in InitHashInfo, since it's done on each find */
+  InitHashInfo(&info, w, a, b, c);
+  return HashFind(view, row, RowHash(view, row), &info);
+}
+
+Column GetHashInfo (View_p left, View_p right, int type) {
+  HashInfo info;
+  Sequence_p seqvec[3];
+
+  switch (type) {
+    case 0:   FillHashInfo(&info, left); break;
+    case 1:   FillGroupInfo(&info, left); break;
+    default:  FillJoinInfo(&info, left, right); break;
+  }
+    
+  seqvec[0] = info.mapcol.seq;
+  seqvec[1] = info.veccol.seq;
+  seqvec[2] = info.hashcol.seq;
+
+  return NewSequenceColumn(IT_column, seqvec, 3);
+}
+
+View_p IjoinView (View_p left, View_p right) {
+  View_p view = JoinView(left, right, "?");
+  return UngroupView(view, ViewWidth(view)-1);
+}
+/* %include<indirect.c>% */
+/*
+ * indirect.c - Implementation of some virtual views.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * mutable.h - Definition of mutable views.
+ */
+
+View_p (ViewReplace) (View_p view, int row, int count, View_p data);
+View_p (ViewSet) (View_p view, int row, int col, Item_p value);
+
+static void RemapCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[0].p);
+  DecRefCount(seq->data[1].p);
+}
+
+static ItemTypes RemapGetter (int row, Item_p item) {
+  int start;
+  const int* data;
+  View_p parent;
+
+  parent = (View_p) item->c.seq->data[0].p;
+  data = (const int*) ((Sequence_p) item->c.seq->data[1].p)->data[0].p;
+  start = item->c.seq->data[2].i;
+
+  item->c = V_Cols(parent)[item->c.pos];
+  row += start;
+  if (data[row] < 0)
+    row += data[row];
+  return GetItem(data[row], item);
+}
+
+View_p RemapSubview (View_p view, Column mapcol, int start, int count) {
+  Sequence_p seq;
+
+  if (count < 0)
+    count = S_Count(mapcol.seq);
+  
+  if (ViewWidth(view) == 0)
+    return NoColumnView(count);
+    
+  seq = InitColumn(count, RemapGetter, 0).seq;
+  seq->head.cleaner = (Cleaner) RemapCleaner;
+  /* data[0] is the parent view to which the map applies */
+  /* data[1] is the map, as a sequence */
+  /* data[2] is the index offset */
+  seq->data[0].p = IncRefCount(view);
+  seq->data[1].p = IncRefCount(mapcol.seq);
+  seq->data[2].i = start;
+
+  return IndirectView(V_Meta(view), seq);
+}
+
+static View_p MakeMetaSubview (const char *name, View_p view) {
+  View_p meta, result;
+  Column namecol, typecol, subvcol;
+  
+  namecol = NewStringColumn(1, strlen(name) + 1, 1);
+  AppendToStringColumn(name, -1, &namecol);
+
+  typecol = NewStringColumn(1, 2, 1);
+  AppendToStringColumn("V", -1, &typecol);
+  
+  meta = V_Meta(view);
+  subvcol = NewSequenceColumn(IT_view, &meta, 1);
+  
+  result = NewView(V_Meta(meta));
+  SetViewColumns(result, MC_name, 1, namecol);
+  SetViewColumns(result, MC_type, 1, typecol);
+  SetViewColumns(result, MC_subv, 1, subvcol);
+  return result;
+}
+
+static void GroupedCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[0].p);
+  DecRefCount(seq->data[1].p);
+  DecRefCount(seq->data[2].p);
+  DecRefCount(seq->data[3].p);
+}
+
+static ItemTypes GroupedGetter (int row, Item_p item) {
+  View_p *subviews = ((Sequence_p) item->c.seq->data[3].p)->data[0].p;
+  
+  if (subviews[row] == NULL) {
+    int start;
+    const int *sptr;
+    View_p parent;
+    Sequence_p gmap;
+  
+    parent = item->c.seq->data[0].p;
+    sptr = ((Sequence_p) item->c.seq->data[1].p)->data[0].p;
+    gmap = item->c.seq->data[2].p;
+
+    start = row > 0 ? sptr[row-1] : 0;
+    item->c.seq = gmap;
+    subviews[row] = IncRefCount(RemapSubview(parent, item->c,
+                                            start, sptr[row] - start));
+  }
+  
+  item->v = subviews[row];
+  return IT_view;
+}
+
+View_p GroupedView (View_p view, Column startcol, Column groupcol, const char *name) {
+  int groups;
+  Sequence_p seq;
+  Column subviewcol;
+  
+  groups = S_Count(startcol.seq);
+  subviewcol = NewSequenceColumn(IT_view, NULL, groups);
+
+  seq = InitColumn(groups, GroupedGetter, 0).seq;
+  seq->head.cleaner = (Cleaner) GroupedCleaner;
+  /* data[0] is the parent view to which the grouping applies */
+  /* data[1] is the start map, as a sequence */
+  /* data[2] is the group map, as a sequence */
+  /* data[3] is a cache of subviews, as a pointer vector in a sequence */
+  seq->data[0].p = IncRefCount(view);
+  seq->data[1].p = IncRefCount(startcol.seq);
+  seq->data[2].p = IncRefCount(groupcol.seq);
+  seq->data[3].p = IncRefCount(subviewcol.seq);
+
+  return IndirectView(MakeMetaSubview(name, view), seq);
+}
+
+static void UnaryCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[0].p);
+}
+
+static ItemTypes StepGetter (int row, Item_p item) {
+  int rows, offs, rate, step;
+  View_p parent;
+  Sequence_p seq;
+
+  seq = item->c.seq;
+  parent = (View_p) seq->data[0].p;
+  offs = seq->data[1].i;
+  rate = seq->data[2].i;
+  step = seq->data[3].i;
+  rows = ViewSize(parent);
+
+  item->c = V_Cols(parent)[item->c.pos];
+  row = (offs + (row / rate) * step) % rows;
+  if (row < 0)
+    row += rows;
+  return GetItem(row, item);
+}
+
+View_p StepView (View_p view, int count, int offset, int rate, int step) {
+  Sequence_p seq;
+
+  /* prevent division by zero if input view is empty */
+  if (ViewSize(view) == 0)
+    return view;
+
+  seq = InitColumn(count * rate, StepGetter, 0).seq;
+  seq->head.cleaner = (Cleaner) UnaryCleaner;
+  /* data[0] is the parent view to which the changes apply */
+  /* data[1] is the starting offset */
+  /* data[2] is the rate to repeat an item */
+  /* data[3] is the step to the next item */
+  seq->data[0].p = IncRefCount(view);
+  seq->data[1].i = offset;
+  seq->data[2].i = rate;
+  seq->data[3].i = step;
+
+  return IndirectView(V_Meta(view), seq);
+}
+
+static void BinaryCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[0].p);
+  DecRefCount(seq->data[1].p);
+}
+
+static ItemTypes ConcatGetter (int row, Item_p item) {
+  int rows;
+  View_p view;
+
+  view = (View_p) item->c.seq->data[0].p;
+  rows = ViewSize(view);
+  if (row >= rows) {
+    row -= rows;
+    view = (View_p) item->c.seq->data[1].p;
+  }
+
+  item->c = V_Cols(view)[item->c.pos];
+  return GetItem(row, item);
+}
+
+View_p ConcatView (View_p view1, View_p view2) {
+  int rows1, rows2;
+  Sequence_p seq;
+
+  rows1 = ViewSize(view1);
+  if (rows1 == 0)
+    return view2;
+
+  rows2 = ViewSize(view2);
+  if (rows2 == 0)
+    return view1;
+
+  seq = InitColumn(rows1 + rows2, ConcatGetter, 0).seq;
+  seq->head.cleaner = (Cleaner) BinaryCleaner;
+  /* data[0] is the left-hand view */
+  /* data[1] is the right-hand view */
+  seq->data[0].p = IncRefCount(view1);
+  seq->data[1].p = IncRefCount(view2);
+
+  return IndirectView(V_Meta(view1), seq);
+}
+
+static void UngroupCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[0].p);
+  DecRefCount(seq->data[1].p);
+}
+
+static ItemTypes UngroupGetter (int row, Item_p item) {
+  int col, subcol, subwidth, parentrow;
+  const int *data;
+  View_p view;
+
+  view = (View_p) item->c.seq->data[0].p;
+  data = (const int*) ((Sequence_p) item->c.seq->data[1].p)->data[0].p;
+  subcol = item->c.seq->data[2].i;
+  subwidth = item->c.seq->data[3].i;
+
+  parentrow = data[row];
+  if (parentrow < 0) {
+    parentrow = data[row+parentrow];
+    row = -data[row];
+  } else
+    row = 0;
+  
+  col = item->c.pos;
+
+  if (subcol <= col && col < subcol + subwidth) {
+    view = GetTypedItem(parentrow, ViewCol(view, subcol), IT_view).v;
+    col -= subcol;
+  } else {
+    if (col >= subcol)
+      col -= subwidth - 1;
+    row = parentrow;
+  }
+  
+  item->c = ViewCol(view, col);
+  return GetItem(row, item);
+}
+
+View_p UngroupView (View_p view, int col) {
+  int i, n, r, rows;
+  Buffer buffer;
+  View_p subview, meta, submeta, newmeta;
+  Sequence_p seq;
+  Column column, map;
+  
+  InitBuffer(&buffer);
+
+  column = ViewCol(view, col);
+  rows = S_Count(column.seq);
+  
+  for (r = 0; r < rows; ++r) {
+    subview = GetTypedItem(r, column, IT_view).v;
+    n = ViewSize(subview);
+    if (n > 0) {
+      ADD_INT_TO_BUF(buffer, r);
+      for (i = 1; i < n; ++i)
+        ADD_INT_TO_BUF(buffer, -i);
+    }
+  }
+
+  map = BufferAsIntCol(&buffer);
+  
+  /* result meta view replaces subview column with its actual meta view */
+  meta = V_Meta(view);
+  submeta = GetTypedItem(col, ViewCol(meta, MC_subv), IT_view).v;
+  newmeta = ConcatView(FirstView(meta, col), submeta);
+  newmeta = ConcatView(newmeta, LastView(meta, ViewSize(meta) - (col + 1)));
+  
+  seq = InitColumn(S_Count(map.seq), UngroupGetter, 0).seq;
+  seq->head.cleaner = (Cleaner) UngroupCleaner;
+  /* data[0] is the parent view */
+  /* data[1] is ungroup map as a sequence */
+  /* data[2] is the subview column */
+  /* data[3] is the subview width */
+  seq->data[0].p = IncRefCount(view);
+  seq->data[1].p = IncRefCount(map.seq);
+  seq->data[2].i = col;
+  seq->data[3].i = ViewSize(submeta);
+  
+  return IndirectView(newmeta, seq);
+}
+
+static void BlockedCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[0].p);
+  DecRefCount(seq->data[1].p);
+}
+
+static ItemTypes BlockedGetter (int row, Item_p item) {
+  int block;
+  const int* data;
+  View_p parent, subv;
+
+  parent = (View_p) item->c.seq->data[0].p;
+  data = (const int*) ((Sequence_p) item->c.seq->data[1].p)->data[0].p;
+
+  for (block = 0; block + data[block] < row; ++block)
+    ;
+
+  if (row == block + data[block]) {
+    row = block;
+    block = ViewSize(parent) - 1;
+  } else if (block > 0)
+    row -= block + data[block-1];
+
+  subv = GetTypedItem(block, ViewCol(parent, 0), IT_view).v;
+  item->c = ViewCol(subv, item->c.pos);  
+  return GetItem(row, item);
+}
+
+View_p BlockedView (View_p view) {
+  int r, rows, *limits, tally = 0;
+  View_p submeta;
+  Sequence_p seq;
+  Column blocks, offsets;
+
+  /* view must have exactly one subview column */
+  if (ViewWidth(view) != 1)
+    return NULL;
+  
+  blocks = ViewCol(view, 0);
+  rows = ViewSize(view);
+  
+  offsets = NewIntVec(rows, &limits);
+  for (r = 0; r < rows; ++r) {
+    tally += ViewSize(GetTypedItem(r, blocks, IT_view).v);
+    limits[r] = tally;
+  }
+  
+  seq = InitColumn(tally, BlockedGetter, 0).seq;
+  seq->head.cleaner = (Cleaner) BlockedCleaner;
+  /* data[0] is the parent view */
+  /* data[1] is a cumulative row count, as a sequence */
+  seq->data[0].p = IncRefCount(view);
+  seq->data[1].p = IncRefCount(offsets.seq);
+  
+  submeta = GetTypedItem(0, ViewCol(V_Meta(view), MC_subv), IT_view).v;
+  return IndirectView(submeta, seq);
+}
+/* %include<mutable.c>% */
+/*
+ * mutable.c - Implementation of mutable views.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+
+static void SettableCleaner (Sequence_p seq) {
+  int r, rows;
+  ItemTypes type;
+  
+  type = seq->data[3].i;
+  rows = S_Count(seq);
+  
+  switch (type) {
+
+    case IT_string: {
+      const char **p = (const char**) seq->data[0].p;
+      for (r = 0; r < rows; ++r)
+        if (p[r] != NULL)
+          free((char*) p[r]);
+      break;
+    }
+
+    case IT_bytes: {
+      const Item *p = (const Item*) seq->data[0].p;
+      for (r = 0; r < rows; ++r)
+        if (p[r].u.ptr != NULL)
+          free((char*) p[r].u.ptr);
+      break;
+    }
+
+    case IT_view: {
+      const View_p *p = (const View_p*) seq->data[0].p;
+      for (r = 0; r < rows; ++r)
+        if (p[r] != NULL)
+          DecRefCount(p[r]);
+      break;
+    }
+      
+    default: break;
+  }
+
+  DecRefCount(seq->data[2].p);
+}
+
+static ItemTypes SettableGetter (int row, Item_p item) {
+  ItemTypes type;
+  Sequence_p seq = item->c.seq;
+  const uint8_t *bitmap = seq->data[1].p;
+  
+  if (!BitTest(bitmap, row)) {
+    View_p view = seq->data[2].p;
+    item->c = ViewCol(view, item->c.pos);
+    return GetItem(row, item);
+  }
+  
+  type = seq->data[3].i;
+  
+  switch (type) {
+
+    case IT_int:
+      item->i = ((const int*) seq->data[0].p)[row];
+      break;
+    
+    case IT_wide:
+      item->w = ((const int64_t*) seq->data[0].p)[row];
+      break;
+
+    case IT_float:
+      item->f = ((const float*) seq->data[0].p)[row];
+      break;
+                    
+    case IT_double:
+      item->d = ((const double*) seq->data[0].p)[row];
+      break;
+                    
+    case IT_string:
+      item->s = ((const char**) seq->data[0].p)[row];
+      break;
+                    
+    case IT_bytes:
+      item->u = ((const Item*) seq->data[0].p)[row].u;
+      break;
+                    
+    case IT_view:
+      item->v = ((const View_p*) seq->data[0].p)[row];
+      break;
+                    
+    default: type = IT_unknown;
+  }
+
+  return type;
+}
+ 
+static int SettableSetter (int row, Column column, Item_p item) {
+  int replace;
+  void *data = column.seq->data[0].p;
+  uint8_t *bitmap = column.seq->data[1].p;
+  ItemTypes type = column.seq->data[3].i;
+  
+  replace = BitTest(bitmap, row);
+  BitSet(bitmap, row);
+  
+  switch (type) {
+
+    case IT_int:
+      ((int*) data)[row] = item->i;
+      break;
+    
+    case IT_wide:
+      ((int64_t*) data)[row] = item->w;
+      break;
+
+    case IT_float:
+      ((float*) data)[row] = item->f;
+      break;
+                    
+    case IT_double:
+      ((double*) data)[row] = item->d;
+      break;
+                    
+    case IT_string: {
+      char **p = (char**) data + row;
+      if (replace)
+        free(*p);
+      *p = strdup(item->s);
+      break;
+    }
+    
+    case IT_bytes: {
+      Item *p = (Item*) data + row;
+      int n = item->u.len;
+      if (replace)
+        free((char*) p->u.ptr);
+      p->u.ptr = memcpy(malloc(n), item->u.ptr, n);
+      p->u.len = n;
+      break;
+    }
+    
+    case IT_view: {
+      View_p *p = (View_p*) data + row;
+      if (replace)
+        DecRefCount(*p);
+      *p = IncRefCount(item->v);
+      break;
+    }
+    
+    default: type = IT_unknown;
+  }
+
+  return replace;
+}
+ 
+static Column NewSettableVec (View_p view, int col) {
+  int rows, width = 0, real = 0;
+  ItemTypes type;
+  Column column, result;
+  
+  rows = ViewSize(view);
+  type = ViewColType(view, col);
+  column = ViewCol(view, col);
+  
+  switch (type) {
+    
+    case IT_bytes:  width = sizeof(Item);
+                    break;
+                    
+    case IT_string:
+    case IT_view:   width = sizeof(void*);
+                    break;
+                    
+    case IT_double: real = 1; /* fall through */
+    case IT_wide:   width = 8;
+                    break;
+                    
+    case IT_float:  real = 1; /* fall through */
+    case IT_int:    width = 4;
+                    break;
+                    
+    default: Assert(0);
+  }
+  
+  result = InitColumn(rows, SettableGetter, rows * width + (rows + 7) / 8);
+  result.seq->head.cleaner = (Cleaner) SettableCleaner;
+  
+  /* data[0] points to the column data */
+  /* data[1] points to the bitmap */
+  /* data[2] is the original view */
+  /* data[3] is the type of items in this column */
+  result.seq->data[1].p = (char*) result.seq->data[0].p + rows * width;
+  result.seq->data[2].p = IncRefCount(view);
+  result.seq->data[3].i = type;
+  
+  result.pos = col;
+  return result;
+}
+
+static View_p SettableView (View_p view) {
+  int c, cols;
+  View_p result;
+
+  cols = ViewWidth(view);
+  result = NewView(V_Meta(view));
+  
+  for (c = 0; c < cols; ++c)
+    SetViewColumns(result, c, 1, NewSettableVec(view, c));
+
+  return result;
+}
+
+static void MutableCleaner (Sequence_p seq) {
+  DecRefCount(seq->data[1].p);
+  DecRefCount(seq->data[2].p);
+  DecRefCount(seq->data[3].p);
+}
+
+static int ChooseMutView (Sequence_p mutseq, int *prow) {
+  int index, limit, row = *prow;
+  const int *perm;
+  Sequence_p permseq;
+  
+  permseq = mutseq->data[2].p;
+  perm = permseq->data[0].p;
+  limit = permseq->data[1].i;
+  
+  index = perm[row];
+
+  if (0 <= index && index < limit)
+    row = -1;
+  else if (index < 0) {
+    row = perm[row+index] - limit;
+    index = -index;
+  } else {
+    row = index - limit;
+    index = 0;
+  }
+
+  *prow = row;
+  return index;
+}
+
+static ItemTypes MutableGetter (int row, Item_p item) {
+  int index;
+  View_p view;
+  
+  index = ChooseMutView(item->c.seq, &row);
+
+  if (row >= 0) {
+    Sequence_p mapseq = item->c.seq->data[3].p;
+    view = ((const View_p*) mapseq->data[0].p)[row];
+  } else
+    view = (View_p) item->c.seq->data[1].p;
+
+  item->c = V_Cols(view)[item->c.pos];
+  return GetItem(index, item);
+}
+
+View_p MutableView (View_p view) {
+  int r, rows, *perm;
+  Sequence_p seq;
+  Column permcol;
+
+  rows = ViewSize(view);
+  seq = InitColumn(rows, MutableGetter, 0).seq;
+  seq->head.cleaner = (Cleaner) MutableCleaner;
+  
+  permcol = NewIntVec(rows, &perm);
+  permcol.seq->data[1].i = rows;
+  
+  /* data[0] tracks the number of insertions */
+  /* data[1] is a settable version of the parent view */
+  /* data[2] is the insert/delete permutation map, as a sequence */
+  /* data[3] is a sequence column with all inserted views */
+  seq->data[0].i = 0;
+  seq->data[1].p = IncRefCount(SettableView(view));
+  seq->data[2].p = IncRefCount(permcol.seq);
+  seq->data[3].p = IncRefCount(NewSequenceColumn(IT_view, NULL, 0).seq);
+  
+  for (r = 0; r < rows; ++r)
+    perm[r] = r;
+    
+  return IndirectView(V_Meta(view), seq);
+}
+
+static int IsMutable(View_p view) {
+  return view->head.cleaner == (Cleaner) MutableCleaner;
+}
+
+View_p ViewSet (View_p view, int row, int col, Item_p item) {
+  int index;
+  Sequence_p mutseq;
+  View_p setview;
+  
+  if (!IsMutable(view))
+    view = MutableView(view);
+  
+  mutseq = ViewCol(view, 0).seq;
+  index = ChooseMutView(mutseq, &row);
+
+  if (row >= 0) {
+    Sequence_p insseq = mutseq->data[3].p;
+    View_p *modvec = insseq->data[0].p;
+    View_p oldview = modvec[row];
+
+    if (!IsMutable(oldview)) {
+      modvec[row] = IncRefCount(MutableView(oldview));
+      DecRefCount(oldview);
+    }
+
+    mutseq = ViewCol(modvec[row], 0).seq;
+  }
+
+  setview = mutseq->data[1].p;
+  SettableSetter(index, ViewCol(setview, col), item);
+  
+  return view;
+}
+
+View_p ViewReplace (View_p view, int off, int count, View_p data) {
+  int row, index, grow, rows, nrows, inscount, limit, *perm;
+  Sequence_p mutseq, permseq;
+  
+  inscount = ViewSize(data);
+  if (inscount > 0 && !ViewCompat(view, data))
+    return NULL;
+
+  if (!IsMutable(view))
+    view = MutableView(view);
+  
+  row = off;
+  mutseq = ViewCol(view, 0).seq;
+  if (row < S_Count(mutseq))
+    index = ChooseMutView(mutseq, &row);
+  else {
+    index = row;
+    row = -1;
+  }
+  
+  permseq = (Sequence_p) mutseq->data[2].p;
+  perm = permseq->data[0].p;
+  limit = permseq->data[1].i;
+  rows = S_Count(permseq);
+
+  grow = inscount - count;
+  nrows = rows + grow;
+  
+#if 0
+    /* turn insertion before row 0 of a subview into insertion in main view */
+  if (grow > 0 && row >= 0 && index == 0) {
+    index = row;
+    row = -1;
+  }
+  
+  if (row >= 0) {
+    Sequence_p insseq = mutseq->data[3].p;
+    View_p *modvec = insseq->data[0].p;
+    View_p newview, oldview = modvec[row];
+
+    newview = ViewReplace(oldview, index, count, data);
+    
+    modvec[row] = IncRefCount(newview);
+    DecRefCount(oldview);
+
+    mutseq = ViewCol(newview, 0).seq;
+  }
+#else
+    /* with multiple replaces, bail out with an extra mutable layer for now */
+    if (mutseq->data[0].i > 0)
+      return ViewReplace(MutableView(view), off, count, data);
+#endif
+
+  if (grow != 0) {
+    int *nperm;
+    Column npermcol;
+    
+    npermcol = NewIntVec(nrows, &nperm);
+    npermcol.seq->data[1].i = limit;
+    
+    memcpy(nperm, perm, off * sizeof(int));
+    
+    if (grow > 0)
+      memcpy(nperm + off + grow, perm + off, (rows - off) * sizeof(int));
+    else
+      memcpy(nperm + off, perm + off - grow, (nrows - off) * sizeof(int));
+  
+    DecRefCount(permseq);
+    mutseq->data[2].p = IncRefCount(npermcol.seq);
+    
+    perm = nperm;
+  }
+  
+  if (inscount > 0) {
+    int i, mods;
+    Sequence_p modseq, *modptr, *nmodptr;
+    Column nmodcol;
+
+    mods = mutseq->data[0].i;
+    modseq = mutseq->data[3].p;
+    modptr = modseq->data[0].p;
+    
+    nmodcol = NewSequenceColumn(IT_view, NULL, ++mutseq->data[0].i);
+    nmodptr = nmodcol.seq->data[0].p;
+
+    memcpy(nmodptr, modptr, mods * sizeof(View_p));
+    memset(modptr, 0, mods * sizeof(View_p)); /* prevent decref's later */
+    nmodptr[mods] = IncRefCount(data);
+      
+    DecRefCount(modseq);
+    mutseq->data[3].p = IncRefCount(nmodcol.seq);
+  
+    perm[off] = limit + mods;
+    for (i = 1; i < inscount; ++i)
+      perm[off+i] = -i;
+  }
+
+  S_Count(mutseq) = nrows;
+  return view;
+}
+
+ItemTypes SetCmd_VIX (Item args[]) {
+  int i, col, row, objc;
+  const Object_p *objv;
+  View_p view;
+  Item item;
+  
+  view = args[0].v;
+  row = args[1].i;
+  
+  objv = (const void*) args[2].u.ptr;
+  objc = args[2].u.len;
+
+  if (objc % 2 != 0) {
+    args[0].e = EC_wnoa;
+    return IT_error;
+  }
+
+  for (i = 0; i < objc; i += 2) {
+    col = ColumnByName(V_Meta(view), objv[i]);
+    if (col < 0)
+      return IT_unknown;
+
+    item.o = objv[i+1];
+    if (!CastObjToItem(GetColType(V_Meta(view), col), &item))
+      return IT_unknown;
+
+    view = ViewSet(view, row, col, &item);
+  }
+
+  args[0].v = view;
+  return IT_view;
+}
+/* %include<sorted.c>% */
+/*
+ * sorted.c - Implementation of sorting functions.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+
+static int ItemsEqual (ItemTypes type, Item a, Item b) {
+  switch (type) {
+
+    case IT_int:
+      return a.i == b.i;
+
+    case IT_wide:
+      return a.w == b.w;
+
+    case IT_float:
+      return a.f == b.f;
+
+    case IT_double:
+      return a.d == b.d;
+
+    case IT_string:
+      return strcmp(a.s, b.s) == 0;
+
+    case IT_bytes:
+      return a.u.len == b.u.len && memcmp(a.u.ptr, b.u.ptr, a.u.len) == 0;
+
+    case IT_view:
+      return ViewCompare(a.v, b.v) == 0;
+      
+    default: Assert(0); return -1;
+  }
+}
+
+int RowEqual (int r1, View_p v1, int r2, View_p v2) {
+  int c, cols = ViewWidth(v1);
+  ItemTypes type;
+  Item item1, item2;
+
+  for (c = 0; c < cols; ++c) {
+    type = ViewColType(v1, c);
+    item1 = GetTypedItem(r1, V_Cols(v1)[c], type);
+    item2 = GetTypedItem(r2, V_Cols(v2)[c], type);
+
+    if (!ItemsEqual(type, item1, item2))
+      return 0;
+  }
+
+  return 1;
+}
+
+/* TODO: UTF-8 comparisons, also case-sensitive & insensitive */
+
+static int ItemsCompare (ItemTypes type, Item a, Item b, int lower) {
+  switch (type) {
+
+    case IT_int:
+      return (a.i > b.i) - (a.i < b.i);
+
+    case IT_wide:
+      return (a.w > b.w) - (a.w < b.w);
+
+    case IT_float:
+      return (a.f > b.f) - (a.f < b.f);
+
+    case IT_double:
+      return (a.d > b.d) - (a.d < b.d);
+
+    case IT_string:
+      return (lower ? strcasecmp : strcmp)(a.s, b.s);
+
+    case IT_bytes: {
+      int f;
+
+      if (a.u.len == b.u.len)
+        return memcmp(a.u.ptr, b.u.ptr, a.u.len);
+
+      f = memcmp(a.u.ptr, b.u.ptr, a.u.len < b.u.len ? a.u.len : b.u.len);
+      return f != 0 ? f : a.u.len - b.u.len;
+    }
+    
+    case IT_view:
+      return ViewCompare(a.v, b.v);
+      
+    default: Assert(0); return -1;
+  }
+}
+
+int RowCompare (int r1, View_p v1, int r2, View_p v2) {
+  int c, f, cols = ViewWidth(v1);
+  ItemTypes type;
+  Item item1, item2;
+
+  for (c = 0; c < cols; ++c) {
+    type = ViewColType(v1, c);
+    item1 = GetTypedItem(r1, V_Cols(v1)[c], type);
+    item2 = GetTypedItem(r2, V_Cols(v2)[c], type);
+
+    f = ItemsCompare(type, item1, item2, 0);
+    if (f != 0)
+      return f;
+  }
+
+  return 0;
+}
+
+static int RowIsLess (View_p v, int a, int b) {
+  int c, cols, f;
+  ItemTypes type;
+  Item va, vb;
+
+  if (a != b) {
+    cols = ViewWidth(v);
+    for (c = 0; c < cols; ++c) {
+      type = ViewColType(v, c);
+      va = GetTypedItem(a, V_Cols(v)[c], type);
+      vb = GetTypedItem(b, V_Cols(v)[c], type);
+
+      f = ItemsCompare(type, va, vb, 0);
+      if (f != 0)
+        return f < 0;
+    }
+  }
+
+  return a < b;
+}
+
+static int TestAndSwap (View_p v, int *a, int *b) {
+  if (RowIsLess(v, *b, *a)) {
+    int t = *a;
+    *a = *b;
+    *b = t;
+    return 1;
+  }
+  return 0;
+}
+
+static void MergeSort (View_p v, int *ar, int nr, int *scr) {
+  switch (nr) {
+    case 2:
+      TestAndSwap(v, ar, ar+1);
+      break;
+    case 3:
+      TestAndSwap(v, ar, ar+1);
+      if (TestAndSwap(v, ar+1, ar+2))
+        TestAndSwap(v, ar, ar+1);
+      break;
+    case 4: /* TODO: optimize with if's */
+      TestAndSwap(v, ar, ar+1);
+      TestAndSwap(v, ar+2, ar+3);
+      TestAndSwap(v, ar, ar+2);
+      TestAndSwap(v, ar+1, ar+3);
+      TestAndSwap(v, ar+1, ar+2);
+      break;
+      /* TODO: also special-case 5-item sort? */
+    default: {
+      int s1 = nr / 2, s2 = nr - s1;
+      int *f1 = scr, *f2 = scr + s1, *t1 = f1 + s1, *t2 = f2 + s2;
+      MergeSort(v, f1, s1, ar);
+      MergeSort(v, f2, s2, ar+s1);
+      for (;;)
+        if (RowIsLess(v, *f1, *f2)) {
+          *ar++ = *f1++;
+          if (f1 >= t1) {
+            while (f2 < t2)
+              *ar++ = *f2++;
+            break;
+          }
+        } else {
+          *ar++ = *f2++;
+          if (f2 >= t2) {
+            while (f1 < t1)
+              *ar++ = *f1++;
+            break;
+          }
+        }
+    }
+  }
+}
+
+Column SortMap (View_p view) {
+  int r, rows, *imap, *itmp;
+  Column result;
+
+  rows = ViewSize(view);
+
+  if (rows <= 1 || ViewWidth(view) == 0)
+    return NewIotaColumn(rows);
+
+  result = NewIntVec(rows, &imap);
+  NewIntVec(rows, &itmp);
+  
+  for (r = 0; r < rows; ++r)
+    imap[r] = itmp[r] = r;
+
+  MergeSort(view, imap, rows, itmp);
+
+  return result;
+}
+
+static ItemTypes AggregateMax (ItemTypes type, Column column, Item_p item) {
+  int r, rows;
+  Item temp;
+  
+  rows = S_Count(column.seq);
+  if (rows == 0) {
+    item->e = EC_nalor;
+    return IT_error;
+  }
+  
+  *item = GetTypedItem(0, column, type);
+  for (r = 1; r < rows; ++r) {
+    temp = GetTypedItem(r, column, type);
+    if (ItemsCompare (type, temp, *item, 0) > 0)
+      *item = temp;
+  }
+  
+  return type;
+}
+
+ItemTypes MaxCmd_VN (Item args[]) {
+  Column column = ViewCol(args[0].v, args[1].i);
+  return AggregateMax(ViewColType(args[0].v, args[1].i), column, args);
+}
+
+static ItemTypes AggregateMin (ItemTypes type, Column column, Item_p item) {
+  int r, rows;
+  Item temp;
+  
+  rows = S_Count(column.seq);
+  if (rows == 0) {
+    item->e = EC_nalor;
+    return IT_error;
+  }
+  
+  *item = GetTypedItem(0, column, type);
+  for (r = 1; r < rows; ++r) {
+    temp = GetTypedItem(r, column, type);
+    if (ItemsCompare (type, temp, *item, 0) < 0)
+      *item = temp;
+  }
+  
+  return type;
+}
+
+ItemTypes MinCmd_VN (Item args[]) {
+  Column column = ViewCol(args[0].v, args[1].i);
+  return AggregateMin(ViewColType(args[0].v, args[1].i), column, args);
+}
+
+static ItemTypes AggregateSum (ItemTypes type, Column column, Item_p item) {
+  int r, rows = S_Count(column.seq);
+  
+  switch (type) {
+    
+    case IT_int:
+      item->w = 0; 
+      for (r = 0; r < rows; ++r)
+        item->w += GetTypedItem(r, column, IT_int).i;
+      return IT_wide;
+      
+    case IT_wide:
+      item->w = 0;
+      for (r = 0; r < rows; ++r)
+        item->w += GetTypedItem(r, column, IT_wide).w;
+      return IT_wide;
+      
+    case IT_float:
+      item->d = 0; 
+      for (r = 0; r < rows; ++r)
+        item->d += GetTypedItem(r, column, IT_float).f;
+      return IT_double;
+
+    case IT_double:   
+      item->d = 0; 
+      for (r = 0; r < rows; ++r)
+        item->d += GetTypedItem(r, column, IT_double).d;
+      return IT_double;
+      
+    default:
+      return IT_unknown;
+  }
+}
+
+ItemTypes SumCmd_VN (Item args[]) {
+  Column column = ViewCol(args[0].v, args[1].i);
+  return AggregateSum(ViewColType(args[0].v, args[1].i), column, &args[0]);
+}
+/* %include<view.c>% */
+/*
+ * view.c - Implementation of views.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+
+int ViewSize (View_p view) {
+  Sequence_p seq = V_Cols(view)[0].seq;
+  return seq != NULL ? S_Count(seq) : 0;
+}
+
+char GetColType (View_p meta, int col) {
+  /* TODO: could be a #define */
+  return *GetTypedItem(col, V_Cols(meta)[MC_type], IT_string).s;
+}
+
+static View_p ForceMetaView(View_p meta) {
+  View_p newmeta;
+  Column orignames, names;
+  
+  /* this code is needed so we can always do a hash lookup on the name column */
+  
+  orignames = ViewCol(meta, MC_name);
+  names = ForceStringColumn(orignames);
+  
+  if (names.seq == orignames.seq)
+    return meta;
+    
+    /* need to construct a new meta view with the adjusted names column */
+  newmeta = NewView(V_Meta(meta));
+
+  SetViewColumns(newmeta, MC_name, 1, names);
+  SetViewColumns(newmeta, MC_type, 1, ViewCol(meta, MC_type));
+  SetViewColumns(newmeta, MC_subv, 1, ViewCol(meta, MC_subv));
+
+  return newmeta;
+}
+
+static void ViewCleaner (View_p view) {
+  int c, cols = ViewWidth(view) + 1;
+  for (c = 0; c < cols; ++c)
+    DecRefCount(V_Cols(view)[c].seq);
+  DecRefCount(V_Meta(view));
+}
+
+static ItemTypes ViewGetter (int row, Item_p item) {
+  item->c = V_Cols(item->c.seq)[row];
+  return IT_column;
+}
+
+View_p NewView (View_p meta) {
+  int c, cols, bytes;
+  View_p view;
+
+  /* a view must always be able to store at least one column */
+  cols = ViewSize(meta);
+  bytes = (cols + 1) * (sizeof(Column) + 1);
+
+  view = InitColumn(cols, ViewGetter, bytes).seq;
+  view->head.cleaner = (Cleaner) ViewCleaner;
+
+  /* data[0] points to the types string (allocated inline after the columns) */
+  /* data[1] is the meta view */
+  V_Types(view) = (char*) (V_Cols(view) + cols + 1);
+  V_Meta(view) = IncRefCount(ForceMetaView(meta));
+
+  /* TODO: could optimize by storing the types with the meta view instead */
+  for (c = 0; c < cols; ++c)
+    V_Types(view)[c] = CharAsItemType(GetColType(meta, c));
+
+  return view;
+}
+
+void SetViewColumns (View_p view, int first, int count, Column src) {
+  int c;
+
+  AdjustSeqRefs(src.seq, count);
+  for (c = first; c < first + count; ++c) {
+    DecRefCount(V_Cols(view)[c].seq);
+    V_Cols(view)[c] = src;
+  }
+}
+
+View_p IndirectView (View_p meta, Sequence_p seq) {
+  int c, cols;
+  View_p result;
+  Column column;
+
+  cols = ViewSize(meta);
+  column.seq = seq;
+  column.pos = INVALID_COUNT; /* adjusted below */
+
+  result = NewView(meta);
+  SetViewColumns(result, 0, cols, column);
+
+  for (c = 0; c < cols; ++c)
+    V_Cols(result)[c].pos = c;
+
+  return result;
+}
+
+View_p EmptyMetaView () {
+  int bytes;
+  View_p meta, subs [MC_limit];
+  Column tempcol;
+  Shared_p sh = GetShared();
+  
+  if (sh->empty != NULL)
+    return sh->empty;
+
+  /* meta is recursively defined, so we can't use NewView here */
+  bytes = (MC_limit + 1) * (sizeof(Column) + 1);
+  meta = InitColumn(MC_limit, ViewGetter, bytes).seq;
+  meta->head.cleaner = (Cleaner) ViewCleaner;
+  V_Meta(meta) = IncRefCount(meta); /* circular */
+  
+  V_Types(meta) = (char*) (V_Cols(meta) + MC_limit + 1);
+  V_Types(meta)[0] = V_Types(meta)[1] = IT_string;
+  V_Types(meta)[2] = IT_view;
+
+  /* initialize all but last columns of meta with static pointer contents */
+  tempcol = NewStringColumn(MC_limit, MC_limit * 5, 1);
+  AppendToStringColumn("name", -1, &tempcol);
+  AppendToStringColumn("type", -1, &tempcol);
+  AppendToStringColumn("subv", -1, &tempcol);
+  SetViewColumns(meta, MC_name, 1, tempcol);
+
+  tempcol = NewStringColumn(MC_limit, MC_limit * 2, 1);
+  AppendToStringColumn("S", -1, &tempcol);
+  AppendToStringColumn("S", -1, &tempcol);
+  AppendToStringColumn("V", -1, &tempcol);
+  SetViewColumns(meta, MC_type, 1, tempcol);
+
+  /* same structure as meta but no rows */
+  sh->empty = NewView(meta);
+
+  /* initialize last column of meta, now that empty exists */
+  subs[MC_name] = subs[MC_type] = subs[MC_subv] = sh->empty;
+  SetViewColumns(meta, MC_subv, 1, NewSequenceColumn(IT_view, subs, MC_limit));
+
+  return sh->empty;
+}
+
+View_p NoColumnView (rows) {
+  View_p result = NewView(EmptyMetaView());
+  SetViewColumns(result, 0, 1, InitColumn(rows, NULL, 0));
+  return result;
+}
+
+View_p ColMapView (View_p view, Column mapcol) {
+  int c, cols;
+  const int *map;
+  View_p result;
+
+  map = (const int*) mapcol.seq->data[0].p;
+  cols = S_Count(mapcol.seq);
+
+  if (cols == 0)
+    return NoColumnView(ViewSize(view));
+
+  result = NewView(RemapSubview(V_Meta(view), mapcol, 0, cols));
+
+  for (c = 0; c < cols; ++c)
+    SetViewColumns(result, c, 1, V_Cols(view)[map[c]]);
+
+  return result;
+}
+
+View_p ColOmitView (View_p view, Column omitcol) {
+  int c, d, *map;
+  Column mapcol;
+  
+  mapcol = NewIntVec(ViewWidth(view), &map);
+
+  /* TODO: make this robust, may have to add bounds check */
+  for (c = 0; c < S_Count(omitcol.seq); ++c)
+    map[GetTypedItem(c, omitcol, IT_int).i] = 1;
+  
+  for (c = d = 0; c < S_Count(mapcol.seq); ++c)
+    if (!map[c])
+      map[d++] = c;
+      
+  S_Count(mapcol.seq) = d; /* TODO: truncate unused area */
+  return ColMapView(view, mapcol);
+}
+
+View_p NameColView (View_p view) {
+  View_p meta, result;
+
+  meta = V_Meta(view);
+  result = NewView(FirstView(V_Meta(meta), 1));
+  SetViewColumns(result, 0, 1, V_Cols(meta)[0]);
+
+  return result;
+}
+
+View_p FirstView (View_p view, int count) {
+  if (count >= ViewSize(view))
+    return view;
+  return StepView(view, count, 0, 1, 1);
+}
+
+View_p LastView (View_p view, int count) {
+  int rows = ViewSize(view);
+  if (count >= rows)
+    return view;
+  return StepView(view, count, rows - count, 1, 1);
+}
+
+View_p TakeView (View_p view, int count) {
+  if (count >= 0)
+    return StepView(view, count, 0, 1, 1);
+  else
+    return StepView(view, -count, -1, 1, -1);
+}
+
+View_p CloneView (View_p view) {
+  return NewView(V_Meta(view));
+}
+
+View_p PairView (View_p view1, View_p view2) {
+  int c, cols1, cols2;
+  View_p meta, result;
+
+  cols1 = ViewWidth(view1);
+  if (cols1 == 0)
+    return view2;
+  
+  cols2 = ViewWidth(view2);
+  if (cols2 == 0)
+    return view1;
+
+  meta = ConcatView(V_Meta(view1), V_Meta(view2));
+  result = NewView(meta);
+  
+  for (c = 0; c < cols1; ++c)
+    SetViewColumns(result, c, 1, V_Cols(view1)[c]);
+  for (c = 0; c < cols2; ++c)
+    SetViewColumns(result, cols1 + c, 1, V_Cols(view2)[c]);
+    
+  return result;
+}
+
+void ViewStructure (View_p meta, Buffer_p buffer) {
+  int c, cols = ViewSize(meta);
+  
+  for (c = 0; c < cols; ++c) {
+    char type = GetColType(meta, c);
+    
+    if (type == 'V') {
+      View_p submeta = GetTypedItem(c, V_Cols(meta)[MC_subv], IT_view).v;
+      
+      if (ViewSize(submeta) > 0) {
+        ADD_CHAR_TO_BUF(*buffer, '(');
+        ViewStructure(submeta, buffer);
+        ADD_CHAR_TO_BUF(*buffer, ')');
+        continue;
+      }
+    }
+    ADD_CHAR_TO_BUF(*buffer, type);
+  }
+}
+
+int MetaIsCompatible (View_p meta1, View_p meta2) {
+  if (meta1 != meta2) {
+    int c, cols = ViewSize(meta1);
+
+    if (cols != ViewSize(meta2))
+      return 0;
+    
+    for (c = 0; c < cols; ++c) {
+      char type = GetColType(meta1, c);
+    
+      if (type != GetColType(meta2, c))
+        return 0;
+      
+      if (type == 'V') {
+        View_p v1 = GetTypedItem(c, V_Cols(meta1)[MC_subv], IT_view).v;
+        View_p v2 = GetTypedItem(c, V_Cols(meta2)[MC_subv], IT_view).v;
+
+        if (!MetaIsCompatible(v1, v2))
+          return 0;
+      }
+    }
+  }
+  
+  return 1;
+}
+
+int ViewCompare (View_p view1, View_p view2) {
+  int f, r, rows1, rows2;
+  
+  if (view1 == view2)
+    return 0;
+  
+  f = ViewCompare(V_Meta(view1), V_Meta(view2));
+  if (f != 0)
+    return f;
+    
+  rows1 = ViewSize(view1);
+  rows2 = ViewSize(view2);
+  
+  for (r = 0; r < rows1; ++r) {
+    if (r >= rows2)
+      return 1;
+  
+    f = RowCompare(r, view1, r, view2);
+    if (f != 0)
+      return f < 0 ? -1 : 1;
+  }
+    
+  return rows1 < rows2 ? -1 : 0;
+}
+
+static View_p MakeIotaMeta (const char *name) {
+  View_p result, subv;
+  Column namecol, typecol, subvcol;
+  
+  namecol = NewStringColumn(1, strlen(name) + 1, 1);
+  AppendToStringColumn(name, -1, &namecol);
+
+  typecol = NewStringColumn(1, 2, 1);
+  AppendToStringColumn("I", -1, &typecol);
+
+  subv = EmptyMetaView();
+  subvcol = NewSequenceColumn(IT_view, &subv, 1);
+  
+  result = NewView(V_Meta(EmptyMetaView()));
+  SetViewColumns(result, MC_name, 1, namecol);
+  SetViewColumns(result, MC_type, 1, typecol);
+  SetViewColumns(result, MC_subv, 1, subvcol);
+  return result;
+}
+
+View_p TagView (View_p view, const char* name) {
+  View_p tagview;
+  
+  tagview = NewView(MakeIotaMeta(name));
+  SetViewColumns(tagview, 0, 1, NewIotaColumn(ViewSize(view)));
+  
+  return PairView(view, tagview);
+}
+
+Column ViewAsCol (View_p view) {
+  Column result;
+  result.seq = view;
+  result.pos = -1;
+  return result;
+}
+
+View_p DescAsMeta (const char** desc, const char* end) {
+  int c, len, cols = 0, namebytes = 0;
+  char sep, *buf, *ptr, **strings;
+  Sequence_p *views;
+  Buffer names, types, subvs;
+  Column tempcol;
+  View_p result, empty;
+
+  InitBuffer(&names);
+  InitBuffer(&types);
+  InitBuffer(&subvs);
+  
+  len = end - *desc;
+  buf = memcpy(malloc(len+1), *desc, len);
+  buf[len] = ',';
+  
+  empty = EmptyMetaView();
+  result = NewView(V_Meta(empty));
+  
+  for (ptr = buf; ptr < buf + len; ++ptr) {
+    const char *s = ptr;
+    while (strchr(":,[]", *ptr) == 0)
+      ++ptr;
+    sep = *ptr;
+    *ptr = 0;
+
+    ADD_PTR_TO_BUF(names, s);
+    namebytes += ptr - s + 1;
+     
+    switch (sep) {
+
+      case '[':
+        ADD_PTR_TO_BUF(types, "V");
+        ++ptr;
+        ADD_PTR_TO_BUF(subvs, DescAsMeta((const char**) &ptr, buf + len));
+        sep = *++ptr;
+        break;
+
+      case ':':
+        ptr += 2;
+        sep = *ptr;
+        *ptr = 0;
+        ADD_PTR_TO_BUF(types, ptr - 1);
+        ADD_PTR_TO_BUF(subvs, empty);
+        break;
+
+      default:
+        ADD_PTR_TO_BUF(types, "S");
+        ADD_PTR_TO_BUF(subvs, empty);
+        break;
+    }
+    
+    ++cols;
+    if (sep != ',')
+      break;
+  }
+
+  strings = (char**) BufferAsPtr(&names, 1);
+  tempcol = NewStringColumn(cols, namebytes, 1);
+  for (c = 0; c < cols; ++c)
+    AppendToStringColumn(strings[c], -1, &tempcol);
+  SetViewColumns(result, MC_name, 1, tempcol);
+  ReleaseBuffer(&names, 0);
+  
+  strings = (char**) BufferAsPtr(&types, 1);
+  tempcol = NewStringColumn(cols, 2 * cols, 1);
+  for (c = 0; c < cols; ++c)
+    AppendToStringColumn(strings[c], -1, &tempcol);
+  SetViewColumns(result, MC_type, 1, tempcol);
+  ReleaseBuffer(&types, 0);
+  
+  views = (Sequence_p*) BufferAsPtr(&subvs, 1);
+  tempcol = NewSequenceColumn(IT_view, views, cols);
+  SetViewColumns(result, MC_subv, 1, tempcol);
+  ReleaseBuffer(&subvs, 0);
+  
+  free(buf);
+  *desc += ptr - buf;
+  return result;
+}
+
+View_p DescToMeta (const char *desc) {
+  int len;
+  const char *end;
+  View_p meta;
+
+  len = strlen(desc);
+  end = desc + len;
+  
+  meta = DescAsMeta(&desc, end);
+  if (desc < end)
+    return NULL;
+
+  return meta;
+}
+
+ItemTypes DataCmd_VX (Item args[]) {
+  View_p meta, view;
+  int c, cols, objc;
+  const Object_p *objv;
+  Column column;
+
+  meta = args[0].v;
+  cols = ViewSize(meta);
+  
+  objv = (const void*) args[1].u.ptr;
+  objc = args[1].u.len;
+
+  if (objc != cols) {
+    args[0].e = EC_wnoa;
+    return IT_error;
+  }
+
+  view = NewView(meta);
+  for (c = 0; c < cols; ++c) {
+    column = CoerceColumn(ViewColType(view, c), objv[c]);
+    if (column.seq == NULL)
+      return IT_unknown;
+      
+    SetViewColumns(view, c, 1, column);
+  }
+
+  args[0].v = view;
+  return IT_view;
+}
+/* %include<wrap_gen.c>% */
+/* wrap_gen.c - generated code, do not edit */
+
+#include <stdlib.h>
+
+  
+ItemTypes BlockedCmd_V (Item_p a) {
+  a[0].v = BlockedView(a[0].v);
+  return IT_view;
+}
+
+ItemTypes CloneCmd_V (Item_p a) {
+  a[0].v = CloneView(a[0].v);
+  return IT_view;
+}
+
+ItemTypes CoerceCmd_OS (Item_p a) {
+  a[0].c = CoerceCmd(a[0].o, a[1].s);
+  return IT_column;
+}
+
+ItemTypes ColMapCmd_Vn (Item_p a) {
+  a[0].v = ColMapView(a[0].v, a[1].c);
+  return IT_view;
+}
+
+ItemTypes ColOmitCmd_Vn (Item_p a) {
+  a[0].v = ColOmitView(a[0].v, a[1].c);
+  return IT_view;
+}
+
+ItemTypes CompareCmd_VV (Item_p a) {
+  a[0].i = ViewCompare(a[0].v, a[1].v);
+  return IT_int;
+}
+
+ItemTypes CompatCmd_VV (Item_p a) {
+  a[0].i = ViewCompat(a[0].v, a[1].v);
+  return IT_int;
+}
+
+ItemTypes ConcatCmd_VV (Item_p a) {
+  a[0].v = ConcatView(a[0].v, a[1].v);
+  return IT_view;
+}
+
+ItemTypes CountsColCmd_C (Item_p a) {
+  a[0].c = NewCountsColumn(a[0].c);
+  return IT_column;
+}
+
+ItemTypes CountViewCmd_I (Item_p a) {
+  a[0].v = NoColumnView(a[0].i);
+  return IT_view;
+}
+
+ItemTypes FirstCmd_VI (Item_p a) {
+  a[0].v = FirstView(a[0].v, a[1].i);
+  return IT_view;
+}
+
+ItemTypes GetColCmd_VN (Item_p a) {
+  a[0].c = ViewCol(a[0].v, a[1].i);
+  return IT_column;
+}
+
+ItemTypes GetInfoCmd_VVI (Item_p a) {
+  a[0].c = GetHashInfo(a[0].v, a[1].v, a[2].i);
+  return IT_column;
+}
+
+ItemTypes GroupCmd_VnS (Item_p a) {
+  a[0].v = GroupCol(a[0].v, a[1].c, a[2].s);
+  return IT_view;
+}
+
+ItemTypes GroupedCmd_ViiS (Item_p a) {
+  a[0].v = GroupedView(a[0].v, a[1].c, a[2].c, a[3].s);
+  return IT_view;
+}
+
+ItemTypes HashFindCmd_VIViii (Item_p a) {
+  a[0].i = HashDoFind(a[0].v, a[1].i, a[2].v, a[3].c, a[4].c, a[5].c);
+  return IT_int;
+}
+
+ItemTypes HashViewCmd_V (Item_p a) {
+  a[0].c = HashValues(a[0].v);
+  return IT_column;
+}
+
+ItemTypes IjoinCmd_VV (Item_p a) {
+  a[0].v = IjoinView(a[0].v, a[1].v);
+  return IT_view;
+}
+
+ItemTypes IotaCmd_I (Item_p a) {
+  a[0].c = NewIotaColumn(a[0].i);
+  return IT_column;
+}
+
+ItemTypes IsectMapCmd_VV (Item_p a) {
+  a[0].c = IntersectMap(a[0].v, a[1].v);
+  return IT_column;
+}
+
+ItemTypes JoinCmd_VVS (Item_p a) {
+  a[0].v = JoinView(a[0].v, a[1].v, a[2].s);
+  return IT_view;
+}
+
+ItemTypes LastCmd_VI (Item_p a) {
+  a[0].v = LastView(a[0].v, a[1].i);
+  return IT_view;
+}
+
+ItemTypes MdescCmd_S (Item_p a) {
+  a[0].v = DescToMeta(a[0].s);
+  return IT_view;
+}
+
+ItemTypes MetaCmd_V (Item_p a) {
+  a[0].v = V_Meta(a[0].v);
+  return IT_view;
+}
+
+ItemTypes NameColCmd_V (Item_p a) {
+  a[0].v = NameColView(a[0].v);
+  return IT_view;
+}
+
+ItemTypes OmitMapCmd_iI (Item_p a) {
+  a[0].c = OmitColumn(a[0].c, a[1].i);
+  return IT_column;
+}
+
+ItemTypes PairCmd_VV (Item_p a) {
+  a[0].v = PairView(a[0].v, a[1].v);
+  return IT_view;
+}
+
+ItemTypes RemapSubCmd_ViII (Item_p a) {
+  a[0].v = RemapSubview(a[0].v, a[1].c, a[2].i, a[3].i);
+  return IT_view;
+}
+
+ItemTypes ReplaceCmd_VIIV (Item_p a) {
+  a[0].v = ViewReplace(a[0].v, a[1].i, a[2].i, a[3].v);
+  return IT_view;
+}
+
+ItemTypes RowEqCmd_IVIV (Item_p a) {
+  a[0].i = RowEqual(a[0].i, a[1].v, a[2].i, a[3].v);
+  return IT_int;
+}
+
+ItemTypes RowHashCmd_VI (Item_p a) {
+  a[0].i = RowHash(a[0].v, a[1].i);
+  return IT_int;
+}
+
+ItemTypes SizeCmd_V (Item_p a) {
+  a[0].i = ViewSize(a[0].v);
+  return IT_int;
+}
+
+ItemTypes SortMapCmd_V (Item_p a) {
+  a[0].c = SortMap(a[0].v);
+  return IT_column;
+}
+
+ItemTypes StepCmd_VIIII (Item_p a) {
+  a[0].v = StepView(a[0].v, a[1].i, a[2].i, a[3].i, a[4].i);
+  return IT_view;
+}
+
+ItemTypes StrLookupCmd_Ss (Item_p a) {
+  a[0].i = StringLookup(a[0].s, a[1].c);
+  return IT_int;
+}
+
+ItemTypes TagCmd_VS (Item_p a) {
+  a[0].v = TagView(a[0].v, a[1].s);
+  return IT_view;
+}
+
+ItemTypes TakeCmd_VI (Item_p a) {
+  a[0].v = TakeView(a[0].v, a[1].i);
+  return IT_view;
+}
+
+ItemTypes UngroupCmd_VN (Item_p a) {
+  a[0].v = UngroupView(a[0].v, a[1].i);
+  return IT_view;
+}
+
+ItemTypes UniqueMapCmd_V (Item_p a) {
+  a[0].c = UniqMap(a[0].v);
+  return IT_column;
+}
+
+ItemTypes ViewAsColCmd_V (Item_p a) {
+  a[0].c = ViewAsCol(a[0].v);
+  return IT_column;
+}
+
+ItemTypes WidthCmd_V (Item_p a) {
+  a[0].i = ViewWidth(a[0].v);
+  return IT_int;
+}
+
+/* : append ( VV-V ) over size swap insert ; */
+ItemTypes AppendCmd_VV (Item_p a) {
+  ItemTypes t;
+  /* over 0 */ a[2] = a[0];
+  t = SizeCmd_V(a+2);
+  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
+  t = InsertCmd_VIV(a);
+  return IT_view;
+}
+
+/* : colconv ( C-C )   ; */
+ItemTypes ColConvCmd_C (Item_p a) {
+  return IT_column;
+}
+
+/* : counts ( VN-C ) getcol countscol ; */
+ItemTypes CountsCmd_VN (Item_p a) {
+  ItemTypes t;
+  t = GetColCmd_VN(a);
+  t = CountsColCmd_C(a);
+  return IT_column;
+}
+
+/* : delete ( VII-V ) 0 countview replace ; */
+ItemTypes DeleteCmd_VII (Item_p a) {
+  ItemTypes t;
+  a[3].i = 0;
+  t = CountViewCmd_I(a+3);
+  t = ReplaceCmd_VIIV(a);
+  return IT_view;
+}
+
+/* : except ( VV-V ) over swap exceptmap remap ; */
+ItemTypes ExceptCmd_VV (Item_p a) {
+  ItemTypes t;
+  /* over 0 */ a[2] = a[0];
+  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
+  t = ExceptMapCmd_VV(a+1);
+  t = RemapCmd_Vi(a);
+  return IT_view;
+}
+
+/* : exceptmap ( VV-C ) over swap isectmap swap size omitmap ; */
+ItemTypes ExceptMapCmd_VV (Item_p a) {
+  ItemTypes t;
+  /* over 0 */ a[2] = a[0];
+  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
+  t = IsectMapCmd_VV(a+1);
+  /* swap 0 */ a[2] = a[0]; a[0] = a[1]; a[1] = a[2];
+  t = SizeCmd_V(a+1);
+  t = OmitMapCmd_iI(a);
+  return IT_column;
+}
+
+/* : groupinfo ( V-C ) dup 1 getinfo ; */
+ItemTypes GroupInfoCmd_V (Item_p a) {
+  ItemTypes t;
+  /* dup 0 */ a[1] = a[0];
+  a[2].i = 1;
+  t = GetInfoCmd_VVI(a);
+  return IT_column;
+}
+
+/* : hashinfo ( V-C ) dup 0 getinfo ; */
+ItemTypes HashInfoCmd_V (Item_p a) {
+  ItemTypes t;
+  /* dup 0 */ a[1] = a[0];
+  a[2].i = 0;
+  t = GetInfoCmd_VVI(a);
+  return IT_column;
+}
+
+/* : insert ( VIV-V ) 0 swap replace ; */
+ItemTypes InsertCmd_VIV (Item_p a) {
+  ItemTypes t;
+  a[3].i = 0;
+  /* swap 2 */ a[4] = a[2]; a[2] = a[3]; a[3] = a[4];
+  t = ReplaceCmd_VIIV(a);
+  return IT_view;
+}
+
+/* : intersect ( VV-V ) over swap isectmap remap ; */
+ItemTypes IntersectCmd_VV (Item_p a) {
+  ItemTypes t;
+  /* over 0 */ a[2] = a[0];
+  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
+  t = IsectMapCmd_VV(a+1);
+  t = RemapCmd_Vi(a);
+  return IT_view;
+}
+
+/* : joininfo ( VV-C ) 2 getinfo ; */
+ItemTypes JoinInfoCmd_VV (Item_p a) {
+  ItemTypes t;
+  a[2].i = 2;
+  t = GetInfoCmd_VVI(a);
+  return IT_column;
+}
+
+/* : names ( V-C ) meta 0 getcol ; */
+ItemTypes NamesCmd_V (Item_p a) {
+  ItemTypes t;
+  t = MetaCmd_V(a);
+  a[1].i = 0;
+  t = GetColCmd_VN(a);
+  return IT_column;
+}
+
+/* : product ( VV-V ) over over size spread rrot swap size repeat pair ; */
+ItemTypes ProductCmd_VV (Item_p a) {
+  ItemTypes t;
+  /* over 0 */ a[2] = a[0];
+  /* over 1 */ a[3] = a[1];
+  t = SizeCmd_V(a+3);
+  t = SpreadCmd_VI(a+2);
+  /* rrot 0 */ a[3] = a[2]; a[2] = a[1]; a[1] = a[0]; a[0] = a[3];
+  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
+  t = SizeCmd_V(a+2);
+  t = RepeatCmd_VI(a+1);
+  t = PairCmd_VV(a);
+  return IT_view;
+}
+
+/* : remap ( Vi-V ) 0 -1 remapsub ; */
+ItemTypes RemapCmd_Vi (Item_p a) {
+  ItemTypes t;
+  a[2].i = 0;
+  a[3].i = -1;
+  t = RemapSubCmd_ViII(a);
+  return IT_view;
+}
+
+/* : repeat ( VI-V ) over size imul 0 1 1 step ; */
+ItemTypes RepeatCmd_VI (Item_p a) {
+  ItemTypes t;
+  /* over 0 */ a[2] = a[0];
+  t = SizeCmd_V(a+2);
+  /* imul 1 */ a[1].i *=  a[2].i;
+  a[2].i = 0;
+  a[3].i = 1;
+  a[4].i = 1;
+  t = StepCmd_VIIII(a);
+  return IT_view;
+}
+
+/* : reverse ( V-V ) dup size -1 1 -1 step ; */
+ItemTypes ReverseCmd_V (Item_p a) {
+  ItemTypes t;
+  /* dup 0 */ a[1] = a[0];
+  t = SizeCmd_V(a+1);
+  a[2].i = -1;
+  a[3].i = 1;
+  a[4].i = -1;
+  t = StepCmd_VIIII(a);
+  return IT_view;
+}
+
+/* : slice ( VIII-V ) rrot 1 swap step ; */
+ItemTypes SliceCmd_VIII (Item_p a) {
+  ItemTypes t;
+  /* rrot 1 */ a[4] = a[3]; a[3] = a[2]; a[2] = a[1]; a[1] = a[4];
+  a[4].i = 1;
+  /* swap 3 */ a[5] = a[3]; a[3] = a[4]; a[4] = a[5];
+  t = StepCmd_VIIII(a);
+  return IT_view;
+}
+
+/* : sort ( V-V ) dup sortmap remap ; */
+ItemTypes SortCmd_V (Item_p a) {
+  ItemTypes t;
+  /* dup 0 */ a[1] = a[0];
+  t = SortMapCmd_V(a+1);
+  t = RemapCmd_Vi(a);
+  return IT_view;
+}
+
+/* : spread ( VI-V ) over size 0 rot 1 step ; */
+ItemTypes SpreadCmd_VI (Item_p a) {
+  ItemTypes t;
+  /* over 0 */ a[2] = a[0];
+  t = SizeCmd_V(a+2);
+  a[3].i = 0;
+  /* rot 1 */ a[4] = a[1]; a[1] = a[2]; a[2] = a[3]; a[3] = a[4];
+  a[4].i = 1;
+  t = StepCmd_VIIII(a);
+  return IT_view;
+}
+
+/* : types ( V-C ) meta 1 getcol ; */
+ItemTypes TypesCmd_V (Item_p a) {
+  ItemTypes t;
+  t = MetaCmd_V(a);
+  a[1].i = 1;
+  t = GetColCmd_VN(a);
+  return IT_column;
+}
+
+/* : union ( VV-V ) over except concat ; */
+ItemTypes UnionCmd_VV (Item_p a) {
+  ItemTypes t;
+  /* over 0 */ a[2] = a[0];
+  t = ExceptCmd_VV(a+1);
+  t = ConcatCmd_VV(a);
+  return IT_view;
+}
+
+/* : unionmap ( VV-C ) swap exceptmap ; */
+ItemTypes UnionMapCmd_VV (Item_p a) {
+  ItemTypes t;
+  /* swap 0 */ a[2] = a[0]; a[0] = a[1]; a[1] = a[2];
+  t = ExceptMapCmd_VV(a);
+  return IT_column;
+}
+
+/* : unique ( V-V ) dup uniquemap remap ; */
+ItemTypes UniqueCmd_V (Item_p a) {
+  ItemTypes t;
+  /* dup 0 */ a[1] = a[0];
+  t = UniqueMapCmd_V(a+1);
+  t = RemapCmd_Vi(a);
+  return IT_view;
+}
+
+/* : viewconv ( V-V )   ; */
+ItemTypes ViewConvCmd_V (Item_p a) {
+  return IT_view;
+}
+
+/* end of generated code */
+
+/* end of generated code */