rural 0.1.0

data/ext/vlerq_ext.c

@@ -0,0 +1,394 @@
+/*
+ * vlerq_ext.c - Interface to the Ruby scripting language.
+ */
+
+#include <ruby.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "vlerq.h"
+
+typedef struct CmdDispatch {
+  const char *name, *args;
+  ItemTypes (*proc) (Item_p);
+} CmdDispatch;
+
+static CmdDispatch f_commands[] = {
+#include "vlerq_ext.h"
+};
+
+Shared *GetShared () {
+  static Shared f_shared;
+  return &f_shared;
+}
+
+void FailedAssert (const char *msg, const char *file, int line) {
+  rb_fatal("Failed assertion at %s, line %d: %s\n", file, line, msg);
+}
+
+typedef struct { VALUE view; int row; } Row, *Row_p;
+
+static VALUE cRow;
+
+static VALUE row_v (VALUE self) {
+  Row_p p;
+  Data_Get_Struct(self, Row, p);
+  return p->view;
+}
+
+static VALUE row_i (VALUE self) {
+  Row_p p;
+  Data_Get_Struct(self, Row, p);
+  return INT2NUM(p->row);
+}
+
+static void row_mark (Row_p p) {
+  rb_gc_mark(p->view);
+}
+
+static VALUE AtRow (VALUE view, int row) {
+  Row_p p = ALLOC(Row);
+  p->view = view;
+  p->row = row;
+  return Data_Wrap_Struct(cRow, row_mark, 0, p);
+}
+
+ItemTypes AtRowCmd_OI (Item_p args) {
+  args[0].o = AtRow(args[0].o, args[1].i);
+  return IT_object;
+}
+
+static VALUE cCol;
+
+static ItemTypes ListObjGetter (int row, Item_p item) {
+  VALUE ary = (VALUE) item->c.seq->data[0].p;
+  item->o = rb_ary_entry(ary, row);
+  return IT_object;
+}
+
+static void col_mark (Column_p p) {
+  if (p->seq->getter == ListObjGetter)
+    rb_gc_mark((VALUE) p->seq->data[0].p);
+}
+
+static void col_free_keep (Column_p p) {
+  PUSH_KEEP_REFS
+  DecRefCount(p->seq);
+  POP_KEEP_REFS
+}
+
+static VALUE cView;
+
+static void view_free_keep (View_p p) {
+  PUSH_KEEP_REFS
+  DecRefCount(p);
+  POP_KEEP_REFS
+}
+
+static VALUE view_alloc (VALUE klass) {
+  return Data_Wrap_Struct(klass, 0, view_free_keep, 0);
+}
+
+VALUE ItemAsObj (ItemTypes type, Item_p item) {
+  VALUE result;
+  
+  switch (type) {
+    
+    case IT_int:
+      result = INT2NUM(item->i);
+      break;
+      
+    case IT_wide:
+      result = NUM2OFFT(item->w);
+      break;
+      
+    case IT_float:
+      result = NUM2DBL(item->f);
+      break;
+      
+    case IT_double:
+      result = NUM2DBL(item->d);
+      break;
+      
+    case IT_string:
+      result = rb_tainted_str_new(item->s, strlen(item->s));
+      break;
+      
+    case IT_bytes:
+      result = rb_tainted_str_new((const char*) item->u.ptr, item->u.len);
+      break;
+      
+    case IT_column: {
+      Column_p p;
+      result = Data_Make_Struct(cCol, Column, col_mark, col_free_keep, p);
+      *p = item->c;
+      IncRefCount(p->seq);
+      break;
+    }
+    
+    case IT_view:
+      result = Data_Wrap_Struct(cView, 0, view_free_keep, IncRefCount(item->v));
+      break;
+    
+    case IT_object:
+      result = item->o;
+      break;
+      
+    default:
+      rb_raise (rb_eRuntimeError, "unsupported type %d", type);
+  }
+  
+  return result;
+}
+
+static VALUE col_to_a_keep (VALUE self) {
+  int i, count;
+  Column_p column;
+  Item item;
+  VALUE result;
+  
+  Data_Get_Struct(self, Column, column);
+  count = S_Count(column->seq);
+  
+  result = rb_ary_new2(count);
+  
+  PUSH_KEEP_REFS
+  
+  for (i = 0; i < count; ++i) {
+    item.c = *column;
+    rb_ary_store(result, i, ItemAsObj(GetItem(i, &item), &item));
+  }
+    
+  POP_KEEP_REFS
+  return result;
+}
+
+ItemTypes OpenCmd_S (Item_p args) {
+	args[0].v = OpenDataFile(args[0].s);
+	return IT_view;
+}
+
+int ObjToItem (ItemTypes type, Item_p item) {
+  switch (type) {
+    
+    case IT_int:
+      item->i = NUM2INT(item->o);
+      break;
+
+    case IT_wide:
+      item->w = NUM2LL(item->o);
+      break;
+
+    case IT_float:
+      item->f = (float) NUM2DBL(item->o);
+      break;
+
+    case IT_double:
+      item->d = NUM2DBL(item->o);
+      break;
+
+    case IT_string:
+      item->s = STR2CSTR(item->o);
+      break;
+
+    case IT_bytes:
+      item->u.ptr = (const void*) rb_str2cstr(item->o, (long*) &item->u.len);
+      break;
+
+    case IT_object:
+      break;
+
+    case IT_column:
+      if (rb_class_of(item->o) != cCol) 
+        return 0;
+      Data_Get_Struct(item->o, Column, item->p);
+      item->c = *(Column_p) item->p;
+      break;
+
+    case IT_view:
+      if (TYPE(item->o) == T_FIXNUM)
+        item->v = NoColumnView(NUM2INT(item->o));
+      if (rb_class_of(item->o) == cView)
+        Data_Get_Struct(item->o, Sequence, item->v);
+      else 
+        return 0;
+      break;
+
+    default:
+      return 0;
+  }
+  
+  return 1;
+}
+
+int ColumnByName (View_p meta, Object_p obj) {
+  int colnum;
+
+  if (TYPE(obj) == T_FIXNUM) {
+    colnum = NUM2INT(obj);
+    if (colnum < 0)
+      colnum += ViewSize(meta);
+    if (colnum < 0 || colnum >= ViewSize(meta))
+      return -5;
+  } else
+    colnum = StringLookup(STR2CSTR(obj), ViewCol(meta, MC_name));
+    
+  return colnum;
+}
+
+Column ObjAsColumn (VALUE obj) {
+  int objc;
+  Object_p *objv;
+  Column result;
+
+  if (rb_class_of(obj) == cCol) {
+    Item item;
+    item.o = obj;
+    if (!ObjToItem(IT_column, &item))
+      Assert(0);
+    return item.c;
+  }
+  
+  Assert(TYPE(obj) == T_ARRAY);
+  objc = (int) RARRAY(obj)->len;
+
+  result = InitColumn(objc, ListObjGetter, 0);
+  result.seq->data[0].p = (void*) obj;
+
+  result.pos = -1;
+  return result;
+}
+
+static VALUE view_initialize_keep (VALUE self, VALUE arg) {
+  View_p view;
+  Item item;
+  PUSH_KEEP_REFS
+  
+  item.o = arg;
+  if (!ObjToItem(IT_view, &item))
+    Assert(0);
+    
+  DATA_PTR(self) = IncRefCount(item.v);
+  
+  POP_KEEP_REFS
+  return self;
+}
+
+#define MAX_STACK 20
+
+static VALUE vq_dispatch_keep (int argc, VALUE *argv, VALUE self) {
+  int i, index;
+  VALUE result;
+  Item stack [MAX_STACK];
+  ItemTypes type;
+  const char *args;
+  
+  index = NUM2INT(argv[0]);
+  
+  PUSH_KEEP_REFS
+  
+  --argc; ++argv;
+  args = f_commands[index].args + 2; /* skip return type and ':' */
+  
+  for (i = 0; args[i] != 0; ++i) {
+    Assert(i < MAX_STACK);
+    if (args[i] == 'X') {
+      Assert(args[i+1] == 0);
+      stack[i].u.ptr = (const void*) (argv+i);
+      stack[i].u.len = argc-i;
+      break;
+    }
+    if ((args[i] == 0 && i != argc) || (args[i] != 0 && i >= argc))
+      rb_raise(rb_eRuntimeError, "wrong number of arguments");
+    stack[i].o = argv[i];
+    if (!CastObjToItem(args[i], stack+i))
+      rb_raise(rb_eRuntimeError, "%s: error in arg %d",
+                                    f_commands[index].name, i);
+  }
+  
+  type = f_commands[index].proc(stack);
+  if (type == IT_unknown)
+    rb_raise(rb_eRuntimeError, "%s: error in result", f_commands[index].name);
+  
+  result = ItemAsObj(type, stack);
+  
+  POP_KEEP_REFS
+  return result;
+}
+
+static VALUE vq_cmdlist (VALUE self) {
+  int i, ncmds = sizeof f_commands / sizeof f_commands[0];
+  VALUE result = rb_ary_new2(ncmds);
+  
+  for (i = 0; i < ncmds; ++i)
+    rb_ary_store(result, i, rb_str_new2(f_commands[i].name));
+    
+  return result;
+}
+
+static VALUE view_each_keep (VALUE self) {
+  int r, rows;
+  Item item;
+  
+  PUSH_KEEP_REFS
+  
+  item.o = self;
+  if (!ObjToItem(IT_view, &item))
+    Assert(0);
+    
+  rows = ViewSize(item.v);
+  
+  for (r = 0; r < rows; ++r)
+    rb_yield(AtRow(self, r));
+
+  POP_KEEP_REFS
+  return self;
+}
+
+static VALUE row_aref_keep (VALUE self, VALUE index) {
+  int col;
+  Row_p p;
+  View_p v;
+  Item item;
+  VALUE result;
+  
+  Data_Get_Struct(self, Row, p);
+  Data_Get_Struct(p->view, Sequence, v);
+
+  PUSH_KEEP_REFS
+  
+  if (TYPE(index) == T_FIXNUM)
+    col = NUM2INT(index);
+  else
+    col = StringLookup(STR2CSTR(index), ViewCol(V_Meta(v), MC_name));
+  
+  Assert(col >= 0);
+  item.c = ViewCol(v, col);
+  result = ItemAsObj(GetItem(p->row, &item), &item);
+
+  POP_KEEP_REFS
+  return result;
+}
+
+void Init_vlerq () {
+	VALUE vlerq = rb_define_module("Vlerq");
+	rb_define_module_function(vlerq, "cmdlist", vq_cmdlist, 0);
+	rb_define_module_function(vlerq, "dispatch", vq_dispatch_keep, -1);
+
+	cRow = rb_define_class_under(vlerq, "Row", rb_cObject);
+	rb_define_method(cRow, "_v", row_v, 0);
+	rb_define_method(cRow, "_i", row_i, 0);
+	rb_define_method(cRow, "[]", row_aref_keep, 1);
+	
+	cCol = rb_define_class_under(vlerq, "Col", rb_cObject);
+	rb_define_method(cCol, "to_a", col_to_a_keep, 0);
+
+	cView = rb_define_class("View", rb_cObject);
+  rb_include_module(cView, rb_mEnumerable);
+
+  rb_define_alloc_func(cView, view_alloc);
+	
+	rb_define_method(cView, "initialize", view_initialize_keep, 1);
+	rb_define_method(cView, "each", view_each_keep, 0);
+}

data/ext/vlerq_ext.h

@@ -0,0 +1,197 @@
+/* vlerq_ext.h - generated code, do not edit */
+
+/* 73 definitions generated for Ruby:
+
+  # name       in     out    inline-code
+  : drop       U      {}     {}
+  : dup        U      UU     {$1 = $0;}
+  : imul       II     I      {$0.i *=  $1.i;}
+  : nip        UU     U      {$0 = $1;}
+  : over       UU     UUU    {$2 = $0;}
+  : rot        UUU    UUU    {$3 = $0; $0 = $1; $1 = $2; $2 = $3;}
+  : rrot       UUU    UUU    {$3 = $2; $2 = $1; $1 = $0; $0 = $3;}
+  : swap       UU     UU     {$2 = $0; $0 = $1; $1 = $2;}
+  : tuck       UU     UUU    {$1 = $2; $0 = $1; $2 = $0;}
+  
+  # name       in    out
+  : Data       VX     V
+  : HashCol    SO     C
+  : Max        VN     O
+  : Min        VN     O
+  : Open       S      V
+  : Set        VIX    V
+  : Sum        VN     O
+
+  tcl {
+    # name       in    out
+    : Def        OO     V
+    : Emit       V      O
+    : Get        VX     U
+    : Load       O      V
+    : Loop       X      O
+    : Mdef       O      V
+    : Ref        OX     O
+    : Refs       O      I
+    : Rename     VO     V
+    : Save       VS     I
+    : StructDesc V      S
+    : Structure  V      S
+    : To         OO     O
+    : Type       O      O
+    : View       X      O
+    : Write      VS     I
+  }
+  
+  ruby {
+    # name       in    out
+    : AtRow      OI     O
+  }
+  
+  # name       in    out  internal-name
+  : Blocked    V      V   BlockedView
+  : Clone      V      V   CloneView
+  : ColMap     Vn     V   ColMapView
+  : ColOmit    Vn     V   ColOmitView
+  : Coerce     OS     C   CoerceCmd
+  : Compare    VV     I   ViewCompare
+  : Compat     VV     I   ViewCompat
+  : Concat     VV     V   ConcatView
+  : CountsCol  C      C   NewCountsColumn
+  : CountView  I      V   NoColumnView
+  : First      VI     V   FirstView
+  : GetCol     VN     C   ViewCol
+  : Group      VnS    V   GroupCol
+  : HashFind   VIViii I   HashDoFind
+  : Ijoin      VV     V   IjoinView
+  : GetInfo    VVI    C   GetHashInfo
+  : Grouped    ViiS   V   GroupedView
+  : HashView   V      C   HashValues
+  : IsectMap   VV     C   IntersectMap
+  : Iota       I      C   NewIotaColumn
+  : Join       VVS    V   JoinView
+  : Last       VI     V   LastView
+  : Mdesc      S      V   DescToMeta
+  : Meta       V      V   V_Meta
+  : NameCol    V      V   NameColView
+  : OmitMap    iI     C   OmitColumn
+  : Pair       VV     V   PairView
+  : RemapSub   ViII   V   RemapSubview
+  : Replace    VIIV   V   ViewReplace
+  : RowEq      IVIV   I   RowEqual
+  : RowHash    VI     I   RowHash
+  : Size       V      I   ViewSize
+  : SortMap    V      C   SortMap
+  : Step       VIIII  V   StepView
+  : StrLookup  Ss     I   StringLookup
+  : Tag        VS     V   TagView
+  : Take       VI     V   TakeView
+  : Ungroup    VN     V   UngroupView
+  : UniqueMap  V      C   UniqMap
+  : ViewAsCol  V      C   ViewAsCol
+  : Width      V      I   ViewWidth
+               
+  # name       in    out  compound-definition
+  : Append     VV     V   {over size swap insert}
+  : ColConv    C      C   { }
+  : Counts     VN     C   {getcol countscol}
+  : Delete     VII    V   {0 countview replace}
+  : Except     VV     V   {over swap exceptmap remap}
+  : ExceptMap  VV     C   {over swap isectmap swap size omitmap}
+  : GroupInfo  V      C   {dup 1 getinfo}
+  : HashInfo   V      C   {dup 0 getinfo}
+  : Insert     VIV    V   {0 swap replace}
+  : JoinInfo   VV     C   {2 getinfo}
+  : Intersect  VV     V   {over swap isectmap remap}
+  : Names      V      C   {meta 0 getcol}
+  : Product    VV     V   {over over size spread rrot swap size repeat pair}
+  : Repeat     VI     V   {over size imul 0 1 1 step}
+  : Remap      Vi     V   {0 -1 remapsub}
+  : Reverse    V      V   {dup size -1 1 -1 step}
+  : Slice      VIII   V   {rrot 1 swap step}
+  : Sort       V      V   {dup sortmap remap}
+  : Spread     VI     V   {over size 0 rot 1 step}
+  : Types      V      C   {meta 1 getcol}
+  : Unique     V      V   {dup uniquemap remap}
+  : Union      VV     V   {over except concat}
+  : UnionMap   VV     C   {swap exceptmap}
+  : ViewConv   V      V   { }
+  
+  # some operators are omitted from restricted execution environments
+  unsafe Open Save
+*/
+
+  { "append",     "V:VV",     AppendCmd_VV       },
+  { "atrow",      "O:OI",     AtRowCmd_OI        },
+  { "blocked",    "V:V",      BlockedCmd_V       },
+  { "clone",      "V:V",      CloneCmd_V         },
+  { "coerce",     "C:OS",     CoerceCmd_OS       },
+  { "colconv",    "C:C",      ColConvCmd_C       },
+  { "colmap",     "V:Vn",     ColMapCmd_Vn       },
+  { "colomit",    "V:Vn",     ColOmitCmd_Vn      },
+  { "compare",    "I:VV",     CompareCmd_VV      },
+  { "compat",     "I:VV",     CompatCmd_VV       },
+  { "concat",     "V:VV",     ConcatCmd_VV       },
+  { "counts",     "C:VN",     CountsCmd_VN       },
+  { "countscol",  "C:C",      CountsColCmd_C     },
+  { "countview",  "V:I",      CountViewCmd_I     },
+  { "data",       "V:VX",     DataCmd_VX         },
+  { "delete",     "V:VII",    DeleteCmd_VII      },
+  { "except",     "V:VV",     ExceptCmd_VV       },
+  { "exceptmap",  "C:VV",     ExceptMapCmd_VV    },
+  { "first",      "V:VI",     FirstCmd_VI        },
+  { "getcol",     "C:VN",     GetColCmd_VN       },
+  { "getinfo",    "C:VVI",    GetInfoCmd_VVI     },
+  { "group",      "V:VnS",    GroupCmd_VnS       },
+  { "grouped",    "V:ViiS",   GroupedCmd_ViiS    },
+  { "groupinfo",  "C:V",      GroupInfoCmd_V     },
+  { "hashcol",    "C:SO",     HashColCmd_SO      },
+  { "hashfind",   "I:VIViii", HashFindCmd_VIViii },
+  { "hashinfo",   "C:V",      HashInfoCmd_V      },
+  { "hashview",   "C:V",      HashViewCmd_V      },
+  { "ijoin",      "V:VV",     IjoinCmd_VV        },
+  { "insert",     "V:VIV",    InsertCmd_VIV      },
+  { "intersect",  "V:VV",     IntersectCmd_VV    },
+  { "iota",       "C:I",      IotaCmd_I          },
+  { "isectmap",   "C:VV",     IsectMapCmd_VV     },
+  { "join",       "V:VVS",    JoinCmd_VVS        },
+  { "joininfo",   "C:VV",     JoinInfoCmd_VV     },
+  { "last",       "V:VI",     LastCmd_VI         },
+  { "max",        "O:VN",     MaxCmd_VN          },
+  { "mdesc",      "V:S",      MdescCmd_S         },
+  { "meta",       "V:V",      MetaCmd_V          },
+  { "min",        "O:VN",     MinCmd_VN          },
+  { "namecol",    "V:V",      NameColCmd_V       },
+  { "names",      "C:V",      NamesCmd_V         },
+  { "omitmap",    "C:iI",     OmitMapCmd_iI      },
+  { "open",       "V:S",      OpenCmd_S          },
+  { "pair",       "V:VV",     PairCmd_VV         },
+  { "product",    "V:VV",     ProductCmd_VV      },
+  { "remap",      "V:Vi",     RemapCmd_Vi        },
+  { "remapsub",   "V:ViII",   RemapSubCmd_ViII   },
+  { "repeat",     "V:VI",     RepeatCmd_VI       },
+  { "replace",    "V:VIIV",   ReplaceCmd_VIIV    },
+  { "reverse",    "V:V",      ReverseCmd_V       },
+  { "roweq",      "I:IVIV",   RowEqCmd_IVIV      },
+  { "rowhash",    "I:VI",     RowHashCmd_VI      },
+  { "set",        "V:VIX",    SetCmd_VIX         },
+  { "size",       "I:V",      SizeCmd_V          },
+  { "slice",      "V:VIII",   SliceCmd_VIII      },
+  { "sort",       "V:V",      SortCmd_V          },
+  { "sortmap",    "C:V",      SortMapCmd_V       },
+  { "spread",     "V:VI",     SpreadCmd_VI       },
+  { "step",       "V:VIIII",  StepCmd_VIIII      },
+  { "strlookup",  "I:Ss",     StrLookupCmd_Ss    },
+  { "sum",        "O:VN",     SumCmd_VN          },
+  { "tag",        "V:VS",     TagCmd_VS          },
+  { "take",       "V:VI",     TakeCmd_VI         },
+  { "types",      "C:V",      TypesCmd_V         },
+  { "ungroup",    "V:VN",     UngroupCmd_VN      },
+  { "union",      "V:VV",     UnionCmd_VV        },
+  { "unionmap",   "C:VV",     UnionMapCmd_VV     },
+  { "unique",     "V:V",      UniqueCmd_V        },
+  { "uniquemap",  "C:V",      UniqueMapCmd_V     },
+  { "viewascol",  "C:V",      ViewAsColCmd_V     },
+  { "viewconv",   "V:V",      ViewConvCmd_V      },
+  { "width",      "I:V",      WidthCmd_V         },
+
+/* end of generated code */

data/lib/rural.rb

@@ -0,0 +1,65 @@
+require 'vlerq'
+
+module Rural
+  VERSION = '0.1.0'
+end
+
+module Vlerq
+  class Row
+    undef_method :type
+
+    def method_missing(m, *args)
+      self[m.to_s]
+    end
+  end
+end
+
+class View
+  undef_method :clone
+  
+  Map = Hash.new { |h,k| fail "Unknown view operator: #{k}" }
+  Vlerq.cmdlist.each_with_index { |s,i| Map[s.to_sym] = i }
+
+  Map[:[]] = Map[:atrow]
+  Map[:length] = Map[:size]
+
+  def method_missing(m, *args)
+    Vlerq.dispatch(Map[m], self, *args)
+  end
+
+  def self.method_missing(m, *args)
+    Vlerq.dispatch(Map[m], *args)
+  end
+  
+  def dump 
+    out = Array.new(3 + size, '')
+    
+    for cname, ctype in names.to_a.zip(types.to_a)
+      values = [cname, '-']
+      
+      case ctype
+      when 'B'
+        each { |r| values << "#{r[cname].size}b" }
+      when 'V'
+        each { |r| values << "##{r[cname].size}" }
+      else
+        each { |r| values << r[cname].to_s }
+      end
+
+      widths = []
+      values.each { |s| widths << s.size }
+      w = [widths.max, 50].min
+      right = /[BILFDV]/ =~ ctype
+      fmt = "  %#{right ? '' : '-'}#{w}.#{w}s"
+
+      values[0], values[1] = cname.ljust(w), ''.ljust(w, '-')
+      values << values[1]
+      values.each_with_index { |s,i| out[i] += fmt % s }
+    end
+    out.join "\n"
+  end
+
+  def project(*names)
+    colmap(names).unique
+  end
+end