stata 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (C) 2011 by Unspace Interactive
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README

@@ -0,0 +1,21 @@
+
+to make the test C app, run:
+
+  cd ext
+  make -f Makefile_c -B
+  ./stata_c_test file.dta
+
+this will compile the application, read file.dta and create a copy of it from the same data in out.dta
+
+
+to make the test Ruby app, run:
+
+  cd ext
+  ruby extconf.rb
+  make
+  ./test.rb file.dta
+  
+  this will do the same, but using the Ruby extension
+
+
+If the app finds any issues with the data, it will fail an assert, which will give you line numbers to the source.

data/ext/Makefile

@@ -0,0 +1,187 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /Users/aanand/.rvm/rubies/ruby-1.9.2-p136/include/ruby-1.9.1
+hdrdir = /Users/aanand/.rvm/rubies/ruby-1.9.2-p136/include/ruby-1.9.1
+arch_hdrdir = /Users/aanand/.rvm/rubies/ruby-1.9.2-p136/include/ruby-1.9.1/$(arch)
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/Users/aanand/.rvm/rubies/ruby-1.9.2-p136
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_BASE_NAME)-$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitedir = $(rubylibprefix)/site_ruby
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+archdir = $(rubylibdir)/$(arch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitearchdir = $(sitelibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+
+CC = gcc
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+OUTFLAG = -o 
+COUTFLAG = -o 
+
+RUBY_EXTCONF_H = 
+cflags   =  $(optflags) $(debugflags) $(warnflags)
+optflags = -O3
+debugflags = -ggdb
+warnflags = -Wextra -Wno-unused-parameter -Wno-parentheses -Wpointer-arith -Wwrite-strings -Wno-missing-field-initializers -Wshorten-64-to-32 -Wno-long-long
+CFLAGS   = -fno-common -isysroot /Developer/SDKs/MacOSX10.6.sdk -arch i386 -fno-common -pipe 
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags)
+CXXFLAGS = $(CFLAGS) $(cxxflags)
+ldflags  = -L. -Wl,-syslibroot /Developer/SDKs/MacOSX10.6.sdk -arch i386 -L/usr/local/lib
+dldflags = -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress -Wl,-flat_namespace
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags)
+LDSHARED = $(CC) -dynamic -bundle
+LDSHAREDXX = $(CXX) -dynamic -bundle
+AR = ar
+EXEEXT = 
+
+RUBY_BASE_NAME = ruby
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby.1.9.1
+arch = i386-darwin10.5.0
+sitearch = $(arch)
+ruby_version = 1.9.1
+ruby = /Users/aanand/.rvm/rubies/ruby-1.9.2-p136/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = $(RUBY) -run -e rmdir -- -p
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lobjc 
+SRCS = Read.c Read.rb.c Stata.c Stata.rb.c Write.c Write.rb.c
+OBJS = Read.o Read.rb.o Stata.o Stata.rb.o Write.o Write.rb.o
+TARGET = Stata
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-rb
+
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-rb-default clean-rb
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean: clean distclean-so distclean-rb-default distclean-rb
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		@-$(RMDIRS) $(DISTCLEANDIRS)
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	@-$(MAKEDIRS) $(@D)
+	$(INSTALL_PROG) $(DLLIB) $(@D)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	@-$(RM) $(@)
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(hdrdir)/ruby.h $(hdrdir)/ruby/defines.h $(arch_hdrdir)/ruby/config.h

data/ext/Makefile_c

@@ -0,0 +1,9 @@
+
+OBJS = Read.o Write.o Stata.o
+STD = 
+
+%.o: %.c
+	cc $(STD) -Wall $*.c -c -o $@
+
+all: $(OBJS)
+	cc $(STD) $(OBJS) -Wall -o stata_c_test

data/ext/Read.c

@@ -0,0 +1,135 @@
+
+#include "Read.h"
+#include "Stata.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int16_t read_int16_t() { int16_t t=0; fread(&t, sizeof(t), 1, fp); return ((swap_endian_needed==1) ? ((t>>8) | (t<<8)) : t); }
+int32_t read_int32_t() { int32_t t=0; fread(&t, sizeof(t), 1, fp); return (swap_endian_needed==1) ? (int32_t)__builtin_bswap32(t) : t; }
+
+uint16_t read_uint16_t() { uint16_t t=0; fread(&t, sizeof(t), 1, fp); return (swap_endian_needed==1) ? (t>>8)|(t<<8) : t; }
+uint32_t read_uint32_t() { uint32_t t=0; fread(&t, sizeof(t), 1, fp); return (swap_endian_needed==1) ? __builtin_bswap32(t) : t; }
+
+char * read_string(int length) { char * t = (char*)malloc(length+1); fread(t, length, 1, fp); t[length] = 0; return t; }
+char ** read_strings(int num, int length) { char ** t = (char **)malloc(sizeof(char *)*num); int i; for (i = 0 ; i < num ; i++) t[i] = read_string(length); return t; }
+
+float read_float_t() { uint32_t t=0; fread(&t, sizeof(t), 1, fp); if (swap_endian_needed==1) t = __builtin_bswap32(t); return *((float *)(void *)&t); }
+double read_double_t() { uint64_t t=0; fread(&t, sizeof(t), 1, fp); if (swap_endian_needed==1) t = __builtin_bswap64(t); return *((double *)(void *)&t); }
+
+struct stata_file * read_stata_file(char * filename)
+{
+  if (verbose) printf("read file '%s'\n", filename);
+  
+  long i,j;
+  
+  struct stata_file * f = (struct stata_file *)malloc(sizeof(struct stata_file));
+  memset(f, 0, sizeof(struct stata_file));
+  f->filename = (char*)malloc(strlen(filename)+1);
+  strcpy(f->filename, filename);
+  
+  fp = fopen(f->filename, "rb");
+  if (fp == NULL) { set_error(f, "error reading file"); return f; }
+  
+  /*fseek(fp, 0 , SEEK_END);
+  long lSize = ftell(fp);
+  rewind(fp);
+  printf("file is %ld bytes long\n", lSize);*/
+  
+  
+  /* 5.1 Header */
+  f->ds_format = fgetc(fp);  if (f->ds_format != 0x72) { set_error(f, "invalid file ds_format"); return f; }
+  f->byteorder = fgetc(fp);  if (f->byteorder != 0x01 && f->byteorder != 0x02) { set_error(f, "invalid file byteorder"); return f; }
+  if (f->byteorder != get_host_endian()) swap_endian_needed = 1;
+  f->filetype = fgetc(fp);   if (f->filetype != 0x01) { set_error(f, "invalid file filetype"); return f; }
+  f->unused = fgetc(fp);     if (f->unused != 0x00) { set_error(f, "invalid unused values"); return f; }
+  f->nvar = read_uint16_t(); if (f->nvar <= 0) { set_error(f, "invalid nvar (< 1)"); return f; }
+  f->nobs = read_uint32_t(); if (f->nobs <= 0) { set_error(f, "invalid nobs (< 1)"); return f; }
+  fread(&f->data_label, sizeof(f->data_label), 1, fp);
+  fread(&f->time_stamp, sizeof(f->time_stamp), 1, fp);
+  
+  
+  /* 5.2 Descriptors */
+  f->typlist = (uint8_t *)malloc(f->nvar);
+  fread(f->typlist, 1, f->nvar, fp);
+  f->varlist = read_strings(f->nvar, 33);
+  f->srtlist = (uint16_t *)malloc(sizeof(uint16_t)*(f->nvar+1));
+  for (i = 0 ; i <= f->nvar ; i++) f->srtlist[i] = read_uint16_t();
+  f->fmtlist = read_strings(f->nvar, 49);
+  f->lbllist = read_strings(f->nvar, 33);
+  
+  
+  /* 5.3 Variable Labels */
+  f->variable_labels = read_strings(f->nvar, 81);
+  
+  
+  /* 5.4 Expansion Fields */
+  uint8_t data_type;
+  uint32_t len;
+  do {
+    data_type = fgetc(fp);
+    if (fread(&len, 4, 1, fp) != 1) { set_error(f, "fread from file failed"); return f; }
+    if (len > 0) for (i = 0 ; i < len ; i++) fgetc(fp);
+  } while(data_type != 0 || len != 0 || feof(fp));
+  /*printf ("read %d bytes of expansion fields\n", count);*/
+  
+  
+  /* 5.5 Data */
+  /*printf("  read 5.5 Data (%dx%d)\n", f->nobs, f->nvar);*/
+  f->obs = (struct stata_obs *)malloc(sizeof(struct stata_obs)*f->nobs);
+  for (j = 0 ; j < f->nobs ; j++)
+  {
+    f->obs[j].var = (struct stata_var *)malloc(sizeof(struct stata_var)*f->nvar);
+    for (i = 0 ; i < f->nvar ; i++)
+    {
+      struct stata_var * var = &f->obs[j].var[i];
+      memset(var, 0, sizeof(struct stata_var));
+      
+      if (f->typlist[i] != 0 && 
+          f->typlist[i] < 245) { var->v_type = V_STR;    var->v_str = read_string(f->typlist[i]); if (feof(fp)) { set_error(f, "end of file reached too soon"); return f; }; }
+      else if (f->typlist[i] == 251) { var->v_type = V_BYTE;   if (fread(&var->v_byte, sizeof(var->v_byte), 1, fp) != 1) { set_error(f, "fread from file failed"); }; if (feof(fp)) { set_error(f, "end of file reached too soon"); return f; }; }
+      else if (f->typlist[i] == 252) { var->v_type = V_INT;    var->v_int = read_int16_t();     if (feof(fp)) { set_error(f, "end of file reached too soon"); return f; }; }
+      else if (f->typlist[i] == 253) { var->v_type = V_LONG;   var->v_long = read_int32_t();    if (feof(fp)) { set_error(f, "end of file reached too soon"); return f; }; }
+      else if (f->typlist[i] == 254) { var->v_type = V_FLOAT;  var->v_float = read_float_t();   if (feof(fp)) { set_error(f, "end of file reached too soon"); return f; }; }
+      else if (f->typlist[i] == 255) { var->v_type = V_DOUBLE; var->v_double = read_double_t(); if (feof(fp)) { set_error(f, "end of file reached too soon"); return f; }; }
+      else fprintf(stderr, "error.\n");
+      
+      if (ferror(fp)) perror("error occurred");
+      if (feof(fp)) { fprintf(stderr, "eof error at var %ld (error:%d)\n", i, ferror(fp)); break; }
+    }
+    if (feof(fp)) { fprintf(stderr, "eof error at obs %ld (error:%d)\n", j, ferror(fp)); exit(1); }
+  }
+  
+  
+  /* 5.6 Value labels */
+  if (!feof(fp))
+  {
+    while (!feof(fp))
+    {
+      int32_t len = read_int32_t();
+      if (feof(fp) || len == 0) break;
+      
+      f->num_vlt++;
+      f->vlt = (struct stata_vlt *)realloc(f->vlt, sizeof(struct stata_vlt)*f->num_vlt);
+      struct stata_vlt * vlt = &f->vlt[f->num_vlt-1];
+      
+      if (fread(vlt->name, 33, 1, fp) != 1) { set_error(f, "fread from file failed"); return f; };
+      fgetc(fp); fgetc(fp); fgetc(fp); /* padding */
+      
+      vlt->n = read_int32_t();
+      vlt->txtlen = read_int32_t(); if (vlt->txtlen >= 32000) { set_error(f, "value label table txtlen is > 32000"); return f; };
+      vlt->off = (int32_t*)malloc(sizeof(int32_t)*vlt->n);
+      for (i = 0 ; i < vlt->n ; i++) vlt->off[i] = read_int32_t();
+      vlt->val = (int32_t*)malloc(sizeof(int32_t)*vlt->n);
+      for (i = 0 ; i < vlt->n ; i++) vlt->val[i] = read_int32_t();
+      vlt->txtbuf = (char*)malloc(vlt->txtlen);
+      fread(vlt->txtbuf, vlt->txtlen, 1, fp);
+    }
+  }
+  /*printf("  read 5.6 Value labels (%d)\n", f->num_vlt);*/
+
+  
+  fclose(fp);
+  return f;
+}

data/ext/Read.h

@@ -0,0 +1,23 @@
+
+#ifndef STATA_READ_H
+#define STATA_READ_H
+
+#include <inttypes.h>
+
+extern int16_t read_int16_t();
+extern int32_t read_int32_t();
+
+extern uint16_t read_uint16_t();
+extern uint32_t read_uint32_t();
+extern uint64_t read_uint64_t();
+
+extern char * read_string(int length);
+extern char ** read_strings(int num, int length);
+
+extern float read_float_t();
+extern double read_double_t();
+
+struct stata_file;
+extern struct stata_file * read_stata_file(char * filename);
+
+#endif

data/ext/Read.rb.c

@@ -0,0 +1,168 @@
+
+#include <math.h>
+#include <ruby.h>
+#include "Stata.h"
+#include "Read.h"
+
+#ifdef HAVE_RUBY_ENCODING_H
+# include <ruby/encoding.h>
+# define ENCODED_STR_NEW2(str, encoding) \
+   ({ \
+    VALUE _string = rb_str_new2((const char *)str); \
+     int _enc = rb_enc_find_index(encoding); \
+     rb_enc_associate_index(_string, _enc); \
+     _string; \
+   })
+#else
+# define ENCODED_STR_NEW2(str, encoding) \
+   rb_str_new2((const char *)str)
+#endif
+
+VALUE method_read(VALUE self, VALUE file)
+{
+	long i,j;
+  
+  if (TYPE(file) != T_STRING) rb_raise(rb_eArgError, "filename is not a string, but instead of type '%d' (in C)", TYPE(file));
+  
+  struct stata_file * f = read_stata_file(rb_string_value_cstr(&file));
+  if (f == NULL) rb_raise(rb_eRuntimeError, "Read Error");
+  if (f->error) rb_raise(rb_eRuntimeError, "%s", f->error);
+  
+  
+  /* 5.1 Headers */
+  VALUE r = rb_hash_new();
+  rb_hash_aset(r, ENCODED_STR_NEW2("file_name", "ASCII-8BIT"), ENCODED_STR_NEW2(f->filename, "ASCII-8BIT"));
+  rb_hash_aset(r, ENCODED_STR_NEW2("data_label", "ASCII-8BIT"), ENCODED_STR_NEW2(f->data_label, "ASCII-8BIT"));
+  rb_hash_aset(r, ENCODED_STR_NEW2("time_stamp", "ASCII-8BIT"), ENCODED_STR_NEW2(f->time_stamp, "ASCII-8BIT"));
+  rb_hash_aset(r, ENCODED_STR_NEW2("nvar", "ASCII-8BIT"), INT2NUM(f->nvar));
+  rb_hash_aset(r, ENCODED_STR_NEW2("nobs", "ASCII-8BIT"), INT2NUM(f->nobs));
+  
+  VALUE data = rb_ary_new();
+  for (i = 0 ; i < f->nobs ; i++)
+  {
+    VALUE row = rb_ary_new();
+    for (j = 0 ; j < f->nvar ; j++)
+    {
+      char symbol_name[100];
+      sprintf(symbol_name, "%d", f->obs[i].var[j].v_type);
+      VALUE var = Qnil;
+      sprintf(symbol_name, "dot_");
+      
+      if (f->obs[i].var[j].v_type == V_STR && f->obs[i].var[j].v_str != NULL)
+        var = ENCODED_STR_NEW2(f->obs[i].var[j].v_str, "ASCII-8BIT");
+      else if (f->obs[i].var[j].v_type == V_BYTE)
+      {
+        if (f->obs[i].var[j].v_byte >= -127 && f->obs[i].var[j].v_byte <= 100)
+          var = INT2NUM((int)f->obs[i].var[j].v_byte);
+        else if (f->obs[i].var[j].v_byte > 100)
+        {
+          int dot = f->obs[i].var[j].v_byte - 101;
+          if (dot == 0) symbol_name[3] = 0;
+          else symbol_name[4] = dot+96;
+          symbol_name[5] = 0;
+          var = rb_str_intern(ENCODED_STR_NEW2(symbol_name, "ASCII-8BIT"));
+        }
+      }
+      else if (f->obs[i].var[j].v_type == V_INT)
+      {
+        if (f->obs[i].var[j].v_int >= -32767 && f->obs[i].var[j].v_int <= 32740)
+          var = INT2NUM((int)f->obs[i].var[j].v_int);
+        else if (f->obs[i].var[j].v_int > 32740)
+        {
+          int dot = f->obs[i].var[j].v_int - 32741;
+          if (dot == 0) symbol_name[3] = 0;
+          else symbol_name[4] = dot+96;
+          symbol_name[5] = 0;
+          var = rb_str_intern(ENCODED_STR_NEW2(symbol_name, "ASCII-8BIT"));
+        }
+      }
+      else if (f->obs[i].var[j].v_type == V_LONG)
+      {
+        if (f->obs[i].var[j].v_long >= -2147483647 && f->obs[i].var[j].v_long <= 2147483620)
+          var = LONG2NUM((int)f->obs[i].var[j].v_long);
+        else if (f->obs[i].var[j].v_long > 2147483620)
+        {
+          int dot = f->obs[i].var[j].v_long - 2147483621;
+          if (dot == 0) symbol_name[3] = 0;
+          else symbol_name[4] = dot+96;
+          symbol_name[5] = 0;
+          var = rb_str_intern(ENCODED_STR_NEW2(symbol_name, "ASCII-8BIT"));
+        }
+      }
+      else if (f->obs[i].var[j].v_type == V_FLOAT)
+      {
+        if (f->obs[i].var[j].v_float < pow(2, 127))
+        {
+          var = rb_float_new(f->obs[i].var[j].v_float);
+        }
+        else if (f->obs[i].var[j].v_float >= pow(2, 127))
+        {
+          int dot = (f->obs[i].var[j].v_float - (float)pow(2, 127)) / (float)pow(2, 115);
+          if (dot == 0) symbol_name[3] = 0;
+          else symbol_name[4] = dot+96;
+          symbol_name[5] = 0;
+          var = rb_str_intern(ENCODED_STR_NEW2(symbol_name, "ASCII-8BIT"));
+        }
+      }
+      else if (f->obs[i].var[j].v_type == V_DOUBLE)
+      {
+        if (f->obs[i].var[j].v_double < pow(2, 1023))
+        {
+          var = rb_float_new(f->obs[i].var[j].v_double);
+        }
+        else if (f->obs[i].var[j].v_double >= pow(2, 1023))
+        {
+          int dot = (int)((f->obs[i].var[j].v_double - pow(2, 1023)) / pow(2, 1011));
+          if (dot == 0) symbol_name[3] = 0;
+          else symbol_name[4] = dot+96;
+          symbol_name[5] = 0;
+          var = rb_str_intern(ENCODED_STR_NEW2(symbol_name, "ASCII-8BIT"));
+        }
+      }
+      
+      rb_ary_push(row, var);
+    }
+    rb_ary_push(data, row);
+  }
+  rb_hash_aset(r, ENCODED_STR_NEW2("data", "ASCII-8BIT"), data);
+  
+  
+  VALUE fields = rb_ary_new();
+  for (i = 0 ; i < f->nvar ; i++)
+  {
+    VALUE field = rb_hash_new();
+    rb_hash_aset(field, ENCODED_STR_NEW2("id", "ASCII-8BIT"), INT2NUM(i+1));
+    rb_hash_aset(field, ENCODED_STR_NEW2("type", "ASCII-8BIT"), INT2NUM(f->typlist[i]));
+    rb_hash_aset(field, ENCODED_STR_NEW2("name", "ASCII-8BIT"), ENCODED_STR_NEW2(f->varlist[i], "ASCII-8BIT"));
+    rb_hash_aset(field, ENCODED_STR_NEW2("format", "ASCII-8BIT"), ENCODED_STR_NEW2(f->fmtlist[i], "ASCII-8BIT"));
+    rb_hash_aset(field, ENCODED_STR_NEW2("variable_label", "ASCII-8BIT"), ENCODED_STR_NEW2(f->variable_labels[i], "ASCII-8BIT"));
+    rb_hash_aset(field, ENCODED_STR_NEW2("value_label", "ASCII-8BIT"), ENCODED_STR_NEW2(f->lbllist[i], "ASCII-8BIT"));
+    rb_hash_aset(field, ENCODED_STR_NEW2("sort", "ASCII-8BIT"), INT2NUM(f->srtlist[i]));
+    rb_ary_push(fields, field);
+  }
+  rb_hash_aset(r, ENCODED_STR_NEW2("fields", "ASCII-8BIT"), fields);
+  
+  
+  VALUE vlt = rb_ary_new();
+  for (i = 0 ; i < f->num_vlt ; i++)
+  {
+    VALUE v = rb_hash_new();
+    rb_hash_aset(v, ENCODED_STR_NEW2("name", "ASCII-8BIT"), ENCODED_STR_NEW2(f->vlt[i].name, "ASCII-8BIT"));
+    VALUE table = rb_ary_new();
+    for (j = 0 ; j < f->vlt[i].n ; j++)
+    {
+      VALUE row = rb_ary_new();
+      rb_ary_push(row, INT2NUM(f->vlt[i].val[j]));
+      rb_ary_push(row, ENCODED_STR_NEW2(f->vlt[i].txtbuf + f->vlt[i].off[j], "ASCII-8BIT"));
+      
+      rb_ary_push(table, row);
+    }
+    
+    rb_hash_aset(v, ENCODED_STR_NEW2("table", "ASCII-8BIT"), table);
+    rb_ary_push(vlt, v);
+  }
+  rb_hash_aset(r, ENCODED_STR_NEW2("value_labels", "ASCII-8BIT"), vlt);
+  
+  free_stata(f);
+  return r;
+}

data/ext/Stata.c

@@ -0,0 +1,81 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "Stata.h"
+#include "Read.h"
+#include "Write.h"
+
+FILE *fp;
+int swap_endian_needed = 0;
+int verbose = 0;
+
+char get_host_endian()
+{
+  int i = 1;
+  char *p = (char *) &i;
+  return (p[0] == 1) ? 0x02 : 0x01;
+}
+
+int set_error(struct stata_file * f, const char * error)
+{
+  f->error = malloc(strlen(error) + 1);
+  strcpy(f->error, error);
+  return 0;
+}
+
+void free_stata(struct stata_file * f)
+{
+  long i,j;
+  
+  free(f->filename);
+  free(f->error);
+  for (i = 0 ; i < f->nvar ; i++) free(f->varlist[i]);
+  for (i = 0 ; i < f->nvar ; i++) free(f->fmtlist[i]);
+  for (i = 0 ; i < f->nvar ; i++) free(f->lbllist[i]);
+  for (i = 0 ; i < f->nvar ; i++) free(f->variable_labels[i]);
+  free(f->typlist);
+  free(f->varlist);
+  free(f->srtlist);
+  free(f->fmtlist);
+  free(f->lbllist);
+  free(f->variable_labels);
+  
+  for (i = 0 ; i < f->nobs ; i++)
+  {
+    for (j = 0 ; j < f->nvar ; j++)
+      if (f->obs[i].var[j].v_type == V_STR)
+        free(f->obs[i].var[j].v_str);
+    free(f->obs[i].var);
+  }
+  free(f->obs);
+  
+  for (i = 0 ; i < f->num_vlt ; i++)
+  {
+    free(f->vlt[i].off);
+    free(f->vlt[i].val);
+    free(f->vlt[i].txtbuf);
+  }
+  free(f->vlt);
+  
+  free(f);
+}
+
+int main(int argc, char *argv[])
+{
+  if (argc != 2) { fprintf(stderr, "usage:\n ./read [file]\n"); return(0); }
+
+  verbose = 1;
+  
+  char src_file[100];
+  char dst_file[100];
+  sprintf(src_file, "%s.dta", argv[1]);
+  sprintf(dst_file, "%s_resave.dta", argv[1]);
+  
+  struct stata_file * f = read_stata_file(src_file);
+  write_stata_file(dst_file, f);
+  return 0;
+}

data/ext/Stata.h

@@ -0,0 +1,72 @@
+
+#ifndef STATA_H
+#define STATA_H
+
+#include <stdio.h>
+#include <inttypes.h>
+
+extern FILE * fp;
+extern int swap_endian_needed;
+extern int verbose;
+
+enum stata_type {
+  V_INVALID, V_STR, V_BYTE, V_INT, V_LONG, V_FLOAT, V_DOUBLE
+};
+
+struct stata_var {
+  enum stata_type v_type;
+  union {
+    char * v_str;
+    int8_t v_byte;
+    int16_t v_int;
+    int32_t v_long;
+    float v_float;
+    double v_double;
+  };
+};
+
+struct stata_obs {
+  struct stata_var * var;
+};
+
+struct stata_vlt {
+  char name[33];
+  int32_t n;
+  int32_t txtlen;
+  int32_t * off;
+  int32_t * val;
+  char * txtbuf;
+};
+
+struct stata_file {
+  char * filename;
+  
+  int8_t ds_format;
+  int8_t byteorder;
+  int8_t filetype;
+  int8_t unused;
+  uint16_t nvar;
+  uint32_t nobs;
+  char data_label[81];
+  char time_stamp[18];
+  
+  char * error;
+  
+  uint8_t * typlist;
+  char ** varlist;
+  uint16_t * srtlist;
+  char ** fmtlist;
+  char ** lbllist;
+  char ** variable_labels;
+  
+  struct stata_obs * obs;
+  
+  int num_vlt;
+  struct stata_vlt * vlt;
+};
+
+extern char get_host_endian();
+extern int set_error(struct stata_file * f, const char * error);
+extern void free_stata(struct stata_file * f);
+
+#endif

data/ext/Stata.rb.c

@@ -0,0 +1,28 @@
+
+#include <ruby.h>
+#include "Stata.h"
+
+VALUE method_read(VALUE self, VALUE file);
+VALUE method_write(VALUE self, VALUE file);
+VALUE method_get_verbose(VALUE self);
+VALUE method_set_verbose(VALUE self, VALUE value);
+
+void Init_Stata()
+{
+  VALUE Stata_module = rb_define_module("Stata");
+  rb_define_singleton_method(Stata_module, "read", method_read, 1);
+  rb_define_singleton_method(Stata_module, "write", method_write, 2);
+  rb_define_singleton_method(Stata_module, "verbose", method_get_verbose, 0);
+  rb_define_singleton_method(Stata_module, "verbose=", method_set_verbose, 1);
+}
+
+VALUE method_get_verbose(VALUE self)
+{
+  return verbose ? Qtrue : Qfalse;
+}
+
+VALUE method_set_verbose(VALUE self, VALUE value)
+{
+  verbose = RTEST(value);
+  return method_get_verbose(self);
+}

data/ext/Write.c

@@ -0,0 +1,114 @@
+
+#include "Write.h"
+#include "Stata.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+struct stata_file;
+
+int write_stata_file(char * filename, struct stata_file * f)
+{
+  if (verbose) printf("write file '%s'\n", filename);
+  
+  long i,j;
+  
+  if (f == NULL) return 0;
+  
+  fp = fopen(filename, "wb");
+  if (fp == NULL) return set_error(f, "error opening file");
+  
+  if (f->nvar <= 0) return set_error(f, "nvar should be more then 0"); 
+  if (f->nobs <= 0) return set_error(f, "nobs should be more then 0"); 
+  
+  /* 5.1 Headers */
+  char header[4] = {0x72, get_host_endian(), 0x01, 0x00};
+  if (fwrite(header, 4, 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  if (fwrite(&f->nvar, sizeof(f->nvar), 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  if (fwrite(&f->nobs, sizeof(f->nobs), 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  if (fwrite(f->data_label, sizeof(f->data_label), 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  f->time_stamp[17] = 0;
+  if (fwrite(f->time_stamp, sizeof(f->time_stamp), 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  
+  
+  /* 5.2 Descriptors */
+  if (fwrite(f->typlist, 1, f->nvar, fp) != f->nvar) return set_error(f, "fwrite to file failed");
+  for (i = 0 ; i < f->nvar ; i++) if (fwrite(f->varlist[i], 33, 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  if (fwrite(f->srtlist, 2, f->nvar+1, fp) != (unsigned int)f->nvar+1) return set_error(f, "fwrite to file failed");
+  for (i = 0 ; i < f->nvar ; i++) if (fwrite(f->fmtlist[i], 49, 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  for (i = 0 ; i < f->nvar ; i++) if (fwrite(f->lbllist[i], 33, 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  
+  
+  /* 5.3 Variable Labels */
+  for (i = 0 ; i < f->nvar ; i++) if (fwrite(f->variable_labels[i], 81, 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  
+  
+  /* 5.4 Expansion Fields */
+  char zeros[5] = {0,0,0,0,0};
+  if (fwrite(zeros, 5, 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  
+  
+  /* 5.5 Data */
+  /*printf("  write 5.5 Data (%dx%d)\n", f->nobs, f->nvar);*/
+  for (j = 0 ; j < f->nobs ; j++)
+  {
+    for (i = 0 ; i < f->nvar ; i++)
+    {
+      struct stata_var * var = &f->obs[j].var[i];
+      if (f->typlist[i] != 0 && f->typlist[i] < 245) { if (fwrite(var->v_str, f->typlist[i], 1, fp) != 1) return set_error(f, "fwrite to file failed"); }
+      else if (f->typlist[i] == 251) { if (fwrite(&var->v_byte, sizeof(var->v_byte), 1, fp) != 1) return set_error(f, "fwrite to file failed"); }
+      else if (f->typlist[i] == 252) { if (fwrite(&var->v_int, sizeof(var->v_int), 1, fp) != 1) return set_error(f, "fwrite to file failed"); }
+      else if (f->typlist[i] == 253) { if (fwrite(&var->v_long, sizeof(var->v_long), 1, fp) != 1) return set_error(f, "fwrite to file failed"); }
+      else if (f->typlist[i] == 254) { if (fwrite(&var->v_float, sizeof(var->v_float), 1, fp) != 1) return set_error(f, "fwrite to file failed"); }
+      else if (f->typlist[i] == 255) { if (fwrite(&var->v_double, sizeof(var->v_double), 1, fp) != 1) return set_error(f, "fwrite to file failed"); }
+    }
+  }
+  
+  
+  /* 5.6 Value Labels */
+  /*printf("  write 5.6 Value Labels (%d)\n", f->num_vlt);*/
+  for (i = 0 ; i < f->num_vlt ; i++)
+  {
+    struct stata_vlt * vlt = &f->vlt[i];
+    uint32_t len = 4 + 4 + 4*vlt->n + 4*vlt->n + vlt->txtlen;
+    if (fwrite(&len, sizeof(len), 1, fp) != 1) return set_error(f, "fwrite to file failed");
+    if (fwrite(vlt->name, 33, 1, fp) != 1) return set_error(f, "fwrite to file failed");
+    if (fwrite(zeros, 3, 1, fp) != 1) return set_error(f, "fwrite to file failed");
+    if (fwrite(&vlt->n, sizeof(vlt->n), 1, fp) != 1) return set_error(f, "fwrite to file failed");
+    uint32_t txtlen = 0;
+    for (j = 0 ; j < vlt->n ; j++)
+      txtlen += (int)strlen(vlt->txtbuf + vlt->off[j]) + 1;
+    
+    if (fwrite(&txtlen, sizeof(txtlen), 1, fp) != 1) return set_error(f, "fwrite to file failed");
+    if (fwrite(vlt->off, sizeof(uint32_t), vlt->n, fp) != (unsigned int)vlt->n) return set_error(f, "fwrite to file failed");
+    if (fwrite(vlt->val, sizeof(uint32_t), vlt->n, fp) != (unsigned int)vlt->n) return set_error(f, "fwrite to file failed");
+    if (fwrite(vlt->txtbuf, txtlen, 1, fp) != 1) return set_error(f, "fwrite to file failed");
+  }
+  
+  fclose(fp);
+  return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/ext/Write.h

@@ -0,0 +1,10 @@
+
+#ifndef STATA_WRITE_H
+#define STATA_WRITE_H
+
+#include <inttypes.h>
+
+struct stata_file;
+extern int write_stata_file(char * filename, struct stata_file * file);
+
+#endif

data/ext/Write.rb.c

@@ -0,0 +1,259 @@
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <ruby.h>
+#include "Stata.h"
+#include "Write.h"
+
+#ifndef RUBY_19
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(v) (RARRAY(v)->len)
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(v) (RARRAY(v)->ptr)
+#endif
+#endif
+
+int populate_fields_from_ruby_index = 0;
+VALUE populate_fields_from_ruby(VALUE field, struct stata_file * f)
+{
+  VALUE v;
+  
+  v = rb_hash_aref(field, rb_str_new2("type"));
+  if (TYPE(v) != T_FIXNUM) rb_raise(rb_eArgError, "field type is not provided or is not a Fixnum");
+  f->typlist[populate_fields_from_ruby_index] = NUM2INT(v);
+  
+  v = rb_hash_aref(field, rb_str_new2("name"));
+  if (TYPE(v) != T_STRING) rb_raise(rb_eArgError, "field name is not provided or is not a Fixnum");
+  f->varlist[populate_fields_from_ruby_index] = (char*)malloc(33);
+  strncpy(f->varlist[populate_fields_from_ruby_index], rb_string_value_cstr(&v), 33);
+  
+  v = rb_hash_aref(field, rb_str_new2("sort"));
+  if (TYPE(v) != T_FIXNUM) rb_raise(rb_eArgError, "field sort is not provided or is not a Fixnum");
+  f->srtlist[populate_fields_from_ruby_index] = NUM2INT(v);
+  
+  v = rb_hash_aref(field, rb_str_new2("format"));
+  if (TYPE(v) != T_STRING) rb_raise(rb_eArgError, "field format is not provided or is not a Fixnum");
+  f->fmtlist[populate_fields_from_ruby_index] = (char*)malloc(49);
+  strncpy(f->fmtlist[populate_fields_from_ruby_index], rb_string_value_cstr(&v), 49);
+  
+  v = rb_hash_aref(field, rb_str_new2("value_label"));
+  if (TYPE(v) != T_STRING) rb_raise(rb_eArgError, "field value_label is not provided or is not a String");
+  f->lbllist[populate_fields_from_ruby_index] = (char*)malloc(33);
+  strncpy(f->lbllist[populate_fields_from_ruby_index], rb_string_value_cstr(&v), 33);
+  
+  v = rb_hash_aref(field, rb_str_new2("variable_label"));
+  if (TYPE(v) != T_STRING) rb_raise(rb_eArgError, "field variable_label is not provided or is not a String");
+  f->variable_labels[populate_fields_from_ruby_index] = (char*)malloc(81);
+  strncpy(f->variable_labels[populate_fields_from_ruby_index], rb_string_value_cstr(&v), 81);
+  
+  populate_fields_from_ruby_index++;
+}
+
+int populate_data_from_ruby_index = 0;
+VALUE populate_data_from_ruby(VALUE row, struct stata_file * f)
+{
+  VALUE v;
+  int j = 0;//, i = populate_data_from_ruby_index;
+  for (j = 0 ; j < f->nvar ; j++)
+  {
+    v = rb_ary_entry(row, j);
+    struct stata_var * var = &f->obs[populate_data_from_ruby_index].var[j];
+    
+    if (f->typlist[j] == 255) var->v_type = V_DOUBLE;
+    else if (f->typlist[j] == 254) var->v_type = V_FLOAT;
+    else if (f->typlist[j] == 253) var->v_type = V_LONG;
+    else if (f->typlist[j] == 252) var->v_type = V_INT;
+    else if (f->typlist[j] == 251) var->v_type = V_BYTE;
+    else if (f->typlist[j] <= 244) var->v_type = f->typlist[j];
+    else rb_raise(rb_eArgError, "type is %d", f->typlist[j]);
+    
+    switch (TYPE(v)) {
+      case T_SYMBOL:
+        v = rb_str_new2(rb_id2name(SYM2ID(v)));
+        const char * symbol_name = RSTRING_PTR(v);
+        
+        int dot = 0;
+        if (strlen(symbol_name) == 5) dot = symbol_name[4] - 96;
+        if (dot < 0 || dot > 26) { rb_raise(rb_eArgError, "INVALID SYMBOL '%s'", symbol_name); continue; }
+        
+        if (f->typlist[j] == 255) var->v_double = pow(2, 1023) + dot*pow(2, 1011);
+        else if (f->typlist[j] == 254) var->v_float = (float)pow(2, 127) + dot*(float)pow(2, 115);
+        else if (f->typlist[j] == 253) var->v_long = 2147483621 + dot;
+        else if (f->typlist[j] == 252) var->v_int = 32741 + dot;
+        else if (f->typlist[j] == 251) var->v_byte = 101 + dot;
+        else rb_raise(rb_eArgError, "invalid typlist '%d' %d", f->typlist[j], TYPE(v));
+      break;
+      case T_BIGNUM:
+      case T_FIXNUM:
+      case T_FLOAT:
+        if (f->typlist[j] == 255) var->v_double = rb_num2dbl(v);
+        else if (f->typlist[j] == 254) var->v_float = (float)rb_num2dbl(v);
+        else if (f->typlist[j] == 253) var->v_long = (int32_t)FIX2LONG(v);
+        else if (f->typlist[j] == 252) var->v_int = FIX2LONG(v);
+        else if (f->typlist[j] == 251) var->v_byte = FIX2LONG(v);
+        else rb_raise(rb_eArgError, "invalid typlist '%d' %d %f", f->typlist[j], TYPE(v), RFLOAT_VALUE(v));
+      break;
+      case T_STRING:
+        var->v_type = f->typlist[j];
+        var->v_str = (char*)malloc(f->typlist[j]+1);
+        strncpy(var->v_str, RSTRING_PTR(v), f->typlist[j]+1);
+      break;
+      case T_NIL:
+        rb_raise(rb_eArgError, "nil value submitted");
+      break;
+      default:
+        rb_raise(rb_eArgError, "unsupported ruby type: %d", TYPE(v));
+      break;
+    }
+  }
+  populate_data_from_ruby_index++;
+}
+
+int populate_value_labels_from_ruby_index = 0;
+VALUE populate_value_labels_from_ruby(VALUE r_vlt, struct stata_file * f)
+{
+  VALUE v;
+  
+  f->num_vlt++;
+  f->vlt = (struct stata_vlt *)realloc(f->vlt, sizeof(struct stata_vlt)*f->num_vlt);
+  struct stata_vlt * vlt = &f->vlt[f->num_vlt-1];
+  
+  if (TYPE(r_vlt) != T_HASH) rb_raise(rb_eArgError, "Value label table should be a Hash");
+  
+  v = rb_hash_aref(r_vlt, rb_str_new2("name"));
+  if (TYPE(v) != T_STRING) rb_raise(rb_eArgError, "Value label table name isn't provided or isn't a String");
+  strncpy(vlt->name, RSTRING_PTR(v), 33);
+  
+  v = rb_hash_aref(r_vlt, rb_str_new2("table"));
+  if (TYPE(v) != T_ARRAY) rb_raise(rb_eArgError, "Value label table name isn't provided or isn't an Array");
+  
+  vlt->n = (int32_t)RARRAY_LEN(v);
+  vlt->txtlen = 0;
+  vlt->off = (uint32_t*)malloc(sizeof(uint32_t)*vlt->n);
+  vlt->val = (uint32_t*)malloc(sizeof(uint32_t)*vlt->n);
+  vlt->txtbuf = NULL;
+  
+  int i;
+  for (i = 0 ; i < RARRAY_LEN(v) ; i++)
+  {
+    VALUE r = rb_ary_entry(v, i);
+    if (TYPE(r) != T_ARRAY) rb_raise(rb_eArgError, "value label contains a row which isn't an Array");
+    if (TYPE(rb_ary_entry(r, 0)) != T_FIXNUM) rb_raise(rb_eArgError, "value label contains a value which isn't a Fixnum");
+    if (TYPE(rb_ary_entry(r, 1)) != T_STRING) rb_raise(rb_eArgError, "value label contains a label which isn't a String");
+    char * txt = RSTRING_PTR(rb_ary_entry(r, 1));
+    vlt->txtlen += (int32_t)strlen(txt)+1;
+  }
+  vlt->txtbuf = (char*)malloc(vlt->txtlen);
+  
+  vlt->txtlen = 0;
+  for (i = 0 ; i < RARRAY_LEN(v) ; i++)
+  {
+    VALUE r = rb_ary_entry(v, i);
+    vlt->val[i] = NUM2INT(rb_ary_entry(r, 0));
+    char * txt = RSTRING_PTR(rb_ary_entry(r, 1));
+    vlt->txtlen += (int32_t)strlen(txt)+1;
+    
+    vlt->off[i] = vlt->txtlen-((int32_t)strlen(txt)+1);
+    memcpy(vlt->txtbuf+vlt->off[i], txt, strlen(txt)+1);
+  }
+  
+  populate_value_labels_from_ruby_index++;
+}
+
+VALUE method_write(VALUE self, VALUE filename, VALUE data)
+{
+  VALUE v;
+  if (TYPE(data) != T_HASH) rb_raise(rb_eArgError, "Content to be written should be a hash");
+  if (TYPE(filename) != T_STRING) rb_raise(rb_eArgError, "Filename for writing is not a string");
+  
+  if (rb_hash_aref(data, rb_str_new2("nvar")) == Qnil) rb_raise(rb_eArgError, "nvar is required");
+  if (rb_hash_aref(data, rb_str_new2("nobs")) == Qnil) rb_raise(rb_eArgError, "nobs is required");
+  if (rb_hash_aref(data, rb_str_new2("fields")) == Qnil) rb_raise(rb_eArgError, "no fields provided");
+  if (rb_hash_aref(data, rb_str_new2("data")) == Qnil) rb_raise(rb_eArgError, "no data provided");
+  
+  struct stata_file * f = (struct stata_file *)malloc(sizeof(struct stata_file));
+  if (f == NULL) rb_raise(rb_eArgError, "Could not allocate memory for the stata file");
+  memset(f, 0, sizeof(struct stata_file));
+  
+  
+  /* 5.1 Headers */
+  v = rb_hash_aref(data, rb_str_new2("nvar"));
+  if (TYPE(v) != T_FIXNUM) rb_raise(rb_eArgError, "nvar is not provided or is not a fixnum");
+  f->nvar = NUM2UINT(v);
+  
+  v = rb_hash_aref(data, rb_str_new2("nobs"));
+  if (TYPE(v) != T_FIXNUM) rb_raise(rb_eArgError, "nobs is not provided or is not a fixnum");
+  f->nobs = NUM2UINT(v);
+  
+  v = rb_hash_aref(data, rb_str_new2("data_label"));
+  if (TYPE(v) != T_STRING) rb_raise(rb_eArgError, "data_label is not provided or is not a string");
+  strncpy(f->data_label, rb_string_value_cstr(&v), sizeof(f->data_label));
+  
+  v = rb_hash_aref(data, rb_str_new2("time_stamp"));
+  if (TYPE(v) != T_STRING) rb_raise(rb_eArgError, "time_stamp is not provided or is not a string");
+  strncpy(f->time_stamp, rb_string_value_cstr(&v), sizeof(f->time_stamp));
+  
+  
+  /* 5.2 and 5.3, Descriptors and Variable Labels */
+  f->typlist = (uint8_t *)malloc(f->nvar);
+  if (f->typlist == NULL) rb_raise(rb_eRuntimeError, "Could not allocate more memory");
+  f->varlist = (char **)malloc(sizeof(char *)*f->nvar);
+  if (f->varlist == NULL) rb_raise(rb_eRuntimeError, "Could not allocate more memory");
+  f->srtlist = (uint16_t *)malloc(sizeof(uint16_t)*(f->nvar+1));
+  if (f->srtlist == NULL) rb_raise(rb_eRuntimeError, "Could not allocate more memory");
+  f->fmtlist = (char **)malloc(sizeof(char *)*f->nvar);
+  if (f->fmtlist == NULL) rb_raise(rb_eRuntimeError, "Could not allocate more memory");
+  f->lbllist = (char **)malloc(sizeof(char *)*f->nvar);
+  if (f->lbllist == NULL) rb_raise(rb_eRuntimeError, "Could not allocate more memory");
+  f->variable_labels = (char **)malloc(sizeof(char *)*f->nvar);
+  if (f->variable_labels == NULL) rb_raise(rb_eRuntimeError, "Could not allocate more memory");
+  
+  v = rb_hash_aref(data, rb_str_new2("fields"));
+  if (TYPE(v) != T_ARRAY) rb_raise(rb_eArgError, "fields are not provided or are not an array");
+  
+  populate_fields_from_ruby_index = 0;
+  rb_iterate(rb_each, v, populate_fields_from_ruby, (VALUE)f);
+  
+  
+  /* 5.3 Expansion Fields - nothing comes from ruby */
+  
+  
+  /* 5.4 Data */
+  long i, j;
+  f->obs = (struct stata_obs *)malloc(sizeof(struct stata_obs)*f->nobs);
+  for (j = 0 ; j < f->nobs ; j++)
+  {
+    f->obs[j].var = (struct stata_var *)malloc(sizeof(struct stata_var)*f->nvar);
+    for (i = 0 ; i < f->nvar ; i++)
+    {
+      struct stata_var * var = &f->obs[j].var[i];
+      memset(var, 0, sizeof(struct stata_var));
+    }
+  }
+  v = rb_hash_aref(data, rb_str_new2("data"));
+  if (TYPE(v) != T_ARRAY) rb_raise(rb_eArgError, "data is not provided or is not an array");
+  
+  populate_data_from_ruby_index = 0;
+  rb_iterate(rb_each, v, populate_data_from_ruby, (VALUE)f);
+  
+  
+  /* 5.5 Value Label Tables */
+  v = rb_hash_aref(data, rb_str_new2("value_labels"));
+  if (TYPE(v) != T_ARRAY) rb_raise(rb_eArgError, "value labels are not provided or are not an array");
+  
+  populate_value_labels_from_ruby_index = 0;
+  rb_iterate(rb_each, v, populate_value_labels_from_ruby, (VALUE)f);
+  
+  write_stata_file(RSTRING_PTR(filename), f);
+  
+  if (f->error) rb_raise(rb_eRuntimeError, "%s", f->error);
+  
+  free_stata(f);
+  
+  return INT2NUM(1);
+}

data/ext/extconf.rb

@@ -0,0 +1,11 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'Stata'
+
+# The destination
+dir_config(extension_name)
+
+# Do the work
+create_makefile(extension_name)

data/ext/test.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby -w
+#encoding:ASCII-8BIT
+
+$LOAD_PATH << '.'
+require 'Stata'
+
+Stata.verbose = true
+
+files = if ARGV.empty?
+          Dir.glob("test_file_*.dta")
+        else
+          ARGV
+        end
+
+if files.empty?
+  puts "usage: #{$0} file1.dta [file2.dta ...]"
+  exit(-1)
+end
+
+files.each do |original|
+  if original =~ /_resave/
+    puts "skipping #{original.inspect}\n\n"
+    next
+  end
+
+  ext    = File.extname(original)
+  base   = original[0..-(ext.length+1)]
+  resave = "#{base}_resave#{ext}"
+  
+  s1 = Stata.read(original)
+  Stata.write(resave, s1)
+  
+  s2 = Stata.read(resave)
+
+  ['data', 'fields', 'value_labels'].each do |f|
+    if (s1[f] != s2[f])
+      puts "ERROR '#{file}' #{f} did not read/write the same!"
+    end
+  end
+
+  puts "\n"
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: stata
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kevin Branigan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-18 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 4
+        version: "2.4"
+  type: :development
+  version_requirements: *id001
+description: 
+email: 
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- ext/extconf.rb
+- ext/Makefile
+- ext/Makefile_c
+- ext/Read.c
+- ext/Read.h
+- ext/Read.o
+- ext/Read.rb.c
+- ext/Read.rb.o
+- ext/Stata.bundle
+- ext/Stata.c
+- ext/Stata.h
+- ext/Stata.o
+- ext/Stata.rb.c
+- ext/Stata.rb.o
+- ext/stata_c_test
+- ext/test.rb
+- ext/Write.c
+- ext/Write.h
+- ext/Write.o
+- ext/Write.rb.c
+- ext/Write.rb.o
+- LICENSE
+- README
+has_rdoc: true
+homepage: http://github.com/unspace/stata
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Read and write support for the Stata binary format
+test_files: []
+