shapelib 0.7.0 → 0.8.0

data/ext/shapelib_ext/extconf.rb

@@ -3,17 +3,21 @@ require 'mkmf'
 
 HEADER_DIRS = [
   '/opt/local/include',
+  '/opt/homebrew/include',
   '/usr/local/include',
   '/usr/include',
 ]
 
 LIB_DIRS = [
   '/opt/local/lib',
+  '/opt/homebrew/lib',
   '/usr/local/lib',
   '/usr/lib',
 ]
 
 dir_config('shapelib', HEADER_DIRS, LIB_DIRS)
-have_header('shapefil.h') or have_header('libshp/shapefil.h') or raise 'shapefil.h not found'
+header = %w[shapefil.h libshp/shapefil.h].find { |name| have_header(name) }
+raise 'shapefil.h not found' unless header
 have_library('shp') or raise 'libshp not found'
+have_const('FTDate', header)
 create_makefile('shapelib_ext')

data/ext/shapelib_ext/main.c

@@ -37,6 +37,27 @@ static VALUE cMultiPatch;
 
 /* code begins here */
 
+static void shape_free(void *ptr)
+{
+    shape_close(ptr);
+}
+
+static void shapefile_free(void *ptr)
+{
+    shapefile_close(ptr);
+    xfree(ptr);
+}
+
+static const rb_data_type_t shape_data_type = {
+    "Shapelib::Shape", { 0, shape_free, 0 }
+};
+
+static const rb_data_type_t shapefile_data_type = {
+    "Shapelib::ShapeFile", { 0, shapefile_free, 0 }
+};
+
+static VALUE WrapShape(VALUE klass, shape_t *shape);
+
 #include "valconv.h"
 #include "sfcode.h"
 #include "sflist.h"
@@ -64,20 +85,36 @@ void Init_shapelib_ext()
 {
     mShapeLib = rb_define_module("Shapelib");
     cShapeFile = rb_define_class_under(mShapeLib, "ShapeFile", rb_cObject);
+    rb_undef_alloc_func(cShapeFile);
     cShape = rb_define_class_under(mShapeLib, "Shape", rb_cObject);
+    rb_undef_alloc_func(cShape);
     cPoint = rb_define_class_under(mShapeLib, "Point", cShape);
+    rb_undef_alloc_func(cPoint);
     cPointM = rb_define_class_under(mShapeLib, "PointM", cPoint);
+    rb_undef_alloc_func(cPointM);
     cPointZ = rb_define_class_under(mShapeLib, "PointZ", cPointM);
+    rb_undef_alloc_func(cPointZ);
     cArc = rb_define_class_under(mShapeLib, "Arc", cShape);
+    rb_undef_alloc_func(cArc);
     cArcM = rb_define_class_under(mShapeLib, "ArcM", cArc);
+    rb_undef_alloc_func(cArcM);
     cArcZ = rb_define_class_under(mShapeLib, "ArcZ", cArcM);
+    rb_undef_alloc_func(cArcZ);
     cPolygon = rb_define_class_under(mShapeLib, "Polygon", cShape);
+    rb_undef_alloc_func(cPolygon);
     cPolygonM = rb_define_class_under(mShapeLib, "PolygonM", cPolygon);
+    rb_undef_alloc_func(cPolygonM);
     cPolygonZ = rb_define_class_under(mShapeLib, "PolygonZ", cPolygonM);
+    rb_undef_alloc_func(cPolygonZ);
     cMultiPoint = rb_define_class_under(mShapeLib, "MultiPoint", cShape);
+    rb_undef_alloc_func(cMultiPoint);
     cMultiPointM = rb_define_class_under(mShapeLib, "MultiPointM", cMultiPoint);
+    rb_undef_alloc_func(cMultiPointM);
     cMultiPointZ = rb_define_class_under(mShapeLib, "MultiPointZ", cMultiPointM);
+    rb_undef_alloc_func(cMultiPointZ);
     cMultiPatch = rb_define_class_under(mShapeLib, "MultiPatch", cShape);
+    rb_undef_alloc_func(cMultiPatch);
+
     rb_define_module_function(mShapeLib, "new_point", sl_m_new_point, -1);
     rb_define_singleton_method(cShapeFile, "new", sf_s_new, -1);
     rb_define_singleton_method(cShapeFile, "open", sf_s_open, -1);

data/ext/shapelib_ext/sfcode.h

@@ -11,7 +11,6 @@ static VALUE sf_add_field(int argc, VALUE *args, VALUE obj)
 
     rb_scan_args(argc, args, "31",
 	    &name, &field_type, &field_width, &decimal_place);
-    SECURE(name);
     StringValue(name);
     atype = Ruby2FieldType(field_type);
     width = NUM2INT(field_width);
@@ -19,15 +18,15 @@ static VALUE sf_add_field(int argc, VALUE *args, VALUE obj)
     if (atype == FTDouble && argc == 3) {
 	rb_raise(rb_eArgError, "specify decimal places for Float attribute");
     }
-    Data_Get_Struct(obj, shapefile_t, self);
-    r = shapefile_add_field(self, RSTRING_PTR(name), atype, width, wdeci);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
+    r = shapefile_add_field(self, StringValueCStr(name), atype, width, wdeci);
     return obj;
 }
 
 static VALUE sf_close(VALUE obj)
 {
     shapefile_t *self;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     return INT2FIX(shapefile_close(self));
 }
 
@@ -35,7 +34,7 @@ static VALUE sf_field_count(VALUE obj)
 {
     shapefile_t *self;
     int r;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     r = shapefile_field_count(self);
     return INT2FIX(r);
 }
@@ -45,15 +44,14 @@ static int Ruby2FieldIndex(shapefile_t *sfile, VALUE field)
     if (FIXNUM_P(field)) {
 	return FIX2INT(field);
     } else {
-	SECURE(field);
-	return shapefile_field_index(sfile, StringValuePtr(field));
+	return shapefile_field_index(sfile, StringValueCStr(field));
     }
 }
 
 static VALUE sf_delete_shape(VALUE obj, VALUE ishape)
 {
     shapefile_t *self;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     shapefile_delete_shape(self, NUM2INT(ishape));
     return Qnil;
 }
@@ -62,7 +60,7 @@ static VALUE sf_field_index(VALUE obj, VALUE name)
 {
     shapefile_t *self;
     int ifield;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     ifield = Ruby2FieldIndex(self, name);
     return (ifield < 0) ? Qnil : INT2FIX(ifield);
 }
@@ -71,7 +69,7 @@ static VALUE sf_field_name(VALUE obj, VALUE index)
 {
     shapefile_t *self;
     const char *name;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     name = shapefile_field_name(self, NUM2INT(index));
     return name ? rb_str_new2(name) : Qnil;
 }
@@ -80,7 +78,7 @@ static VALUE sf_field_type(VALUE obj, VALUE field)
 {
     shapefile_t *self;
     int ifield;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     ifield = Ruby2FieldIndex(self, field);
     return FieldType2Ruby(shapefile_field_type(self, ifield));
 }
@@ -89,7 +87,7 @@ static VALUE sf_field_width(VALUE obj, VALUE field)
 {
     shapefile_t *self;
     int ifield;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     ifield = Ruby2FieldIndex(self, field);
     return INT2FIX(shapefile_field_width(self, ifield));
 }
@@ -98,7 +96,7 @@ static VALUE sf_field_decimals(VALUE obj, VALUE field)
 {
     shapefile_t *self;
     int ifield;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     ifield = Ruby2FieldIndex(self, field);
     return INT2FIX(shapefile_field_decimals(self, ifield));
 }
@@ -108,7 +106,7 @@ static VALUE sf_fields(VALUE obj)
     shapefile_t *self;
     VALUE r;
     int fc, i;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     fc = shapefile_field_count(self);
     if (fc < 0)
 	return Qnil;
@@ -126,12 +124,12 @@ static VALUE sf_maxbound(VALUE obj)
     shapefile_t *self;
     double bound[4];
     double z;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     shapefile_bound(self, NULL, bound);
     z = bound[2];
     bound[2] = bound[3];
     bound[3] = z;
-    return DoubleUnpack(bound, 4);
+    return DoubleUnpackM(bound, 4, 2);
 }
 
 static VALUE sf_minbound(VALUE obj)
@@ -139,34 +137,33 @@ static VALUE sf_minbound(VALUE obj)
     shapefile_t *self;
     double bound[4];
     double z;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     shapefile_bound(self, bound, NULL);
     z = bound[2];
     bound[2] = bound[3];
     bound[3] = z;
-    return DoubleUnpack(bound, 4);
+    return DoubleUnpackM(bound, 4, 2);
 }
 
 static VALUE sf_read(int argc, VALUE *args, VALUE obj)
 {
     shapefile_t *self;
     shape_t *s;
-    VALUE ishape, r;
+    VALUE ishape;
     int irec;
     rb_scan_args(argc, args, "01", &ishape);
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     irec = NIL_P(ishape) ? -1 : NUM2INT(ishape);
     s = shapefile_read(self, irec);
     if (s == NULL)
 	return Qnil;
-    r = Data_Wrap_Struct(cShape, 0, shape_close, s);
-    return r;
+    return WrapShape(cShape, s);
 }
 
 static VALUE sf_rewind(VALUE obj)
 {
     shapefile_t *self;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     self->irec = 0;
     return obj;
 }
@@ -187,7 +184,7 @@ static VALUE sf_each(VALUE obj)
 static VALUE sf_shape_type(VALUE obj)
 {
     shapefile_t *self;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     return ShapeType2Ruby(shapefile_shape_type(self));
 }
 
@@ -195,7 +192,7 @@ static VALUE sf_size(VALUE obj)
 {
     shapefile_t *self;
     int r;
-    Data_Get_Struct(obj, shapefile_t, self);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
     r = shapefile_size(self);
     if (r < 0)
 	rb_raise(rb_eRuntimeError, "size %d", r);
@@ -210,9 +207,9 @@ static VALUE sf_write(int argc, VALUE *args, VALUE obj)
     if (argc < 1 || argc > 2) {
 	rb_raise(rb_eArgError, "usage: Shapefile#write shape, [irec = -1]");
     }
-    Data_Get_Struct(obj, shapefile_t, self);
-    Data_Get_Struct(args[0], shape_t, shape);
-    irec = ((argc == 2) ? NUM2INT(args[1]) : -1);
+    TypedData_Get_Struct(obj, shapefile_t, &shapefile_data_type, self);
+    TypedData_Get_Struct(args[0], shape_t, &shape_data_type, shape);
+    irec = (argc == 2 && !NIL_P(args[1])) ? NUM2INT(args[1]) : -1;
     r = shapefile_write(self, irec, shape);
     return INT2FIX(r);
 }
@@ -221,12 +218,41 @@ static VALUE sf_write(int argc, VALUE *args, VALUE obj)
  * constructor
  */
 
+struct shapefile_wrap_args {
+    VALUE klass;
+    shapefile_t *sfile;
+};
+
+static VALUE WrapShapeFileProtected(VALUE ptr)
+{
+    struct shapefile_wrap_args *args = (struct shapefile_wrap_args *)ptr;
+    return TypedData_Wrap_Struct(args->klass, &shapefile_data_type, args->sfile);
+}
+
+static VALUE WrapShapeFile(VALUE klass, shapefile_t *sfile)
+{
+    struct shapefile_wrap_args args = { klass, sfile };
+    int state;
+    VALUE sf = rb_protect(WrapShapeFileProtected, (VALUE)&args, &state);
+    if (state) {
+	shapefile_free(sfile);
+	rb_jump_tag(state);
+    }
+    return sf;
+}
+
+static VALUE CallShapeFileBlock(VALUE args)
+{
+    rb_funcall(rb_ary_entry(args, 0), rb_intern("call"), 1,
+	rb_ary_entry(args, 1));
+    return Qnil;
+}
+
 static VALUE YieldIfPossible(VALUE proc, VALUE sf)
 {
     if (!NIL_P(proc)) {
-	rb_funcall(proc, rb_intern("call"), 1, sf);
-	sf_close(sf);
-	return Qnil;
+	return rb_ensure(CallShapeFileBlock, rb_ary_new_from_args(2, proc, sf),
+	    sf_close, sf);
     } else {
 	return sf;
     }
@@ -237,11 +263,14 @@ static VALUE sf_s_open(int argc, VALUE *argv, VALUE klass)
     VALUE fnam, mode, sf, proc;
     shapefile_t *sfile;
     rb_scan_args(argc, argv, "11&", &fnam, &mode, &proc);
-    SECURE(fnam);
-    sfile = shapefile_open(StringValuePtr(fnam), 
-	(NIL_P(mode) ? "rb" : StringValuePtr(mode))
+    /* Finish Ruby callbacks before taking pointers into either string. */
+    StringValue(fnam);
+    if (!NIL_P(mode))
+	StringValue(mode);
+    sfile = shapefile_open(StringValueCStr(fnam),
+	(NIL_P(mode) ? "rb" : StringValueCStr(mode))
 	);
-    sf = Data_Wrap_Struct(klass, 0, shapefile_close, sfile);
+    sf = WrapShapeFile(klass, sfile);
     return YieldIfPossible(proc, sf);
 }
 
@@ -253,11 +282,10 @@ static VALUE sf_s_new(int argc, VALUE *argv, VALUE klass)
     int i;
     if (argc > 3 || argc < 2) {
 	rb_raise(rb_eArgError,
-	"usage: ShapeLib::Shapefile.new filename, shapetype, attrs = []");
+	"usage: Shapelib::ShapeFile.new filename, shapetype, attrs = []");
 	return Qnil;
     }
     rb_scan_args(argc, argv, "21&", &fnam, &shapetype, &attrs, &proc);
-    SECURE(fnam);
     if ((stype = Ruby2ShapeType(shapetype)) == -1) {
 	rb_raise(rb_eArgError, "shapetype must be Shape subclass");
     }
@@ -266,11 +294,11 @@ static VALUE sf_s_new(int argc, VALUE *argv, VALUE klass)
 	    rb_raise(rb_eArgError, "attrs must be Array");
 	}
     }
-    sfile = shapefile_new(StringValuePtr(fnam), stype);
+    sfile = shapefile_new(StringValueCStr(fnam), stype);
     if (sfile == NULL) {
 	rb_raise(rb_eRuntimeError, "shapefile_new failed");
     }
-    sf = Data_Wrap_Struct(klass, 0, shapefile_close, sfile);
+    sf = WrapShapeFile(klass, sfile);
     if (argc > 2) {
 	for (i = 0; i < RARRAY_LEN(attrs); i++) {
 	    VALUE p = RARRAY_PTR(attrs)[i];

data/ext/shapelib_ext/sflist.h

@@ -1,21 +1,21 @@
 static method_table_entry sf_methods[] = {
-    { "add_field", sf_add_field, -1 },
-    { "close", sf_close, 0 },
-    { "delete_shape", sf_delete_shape, 1 },
-    { "each", sf_each, 0 },
-    { "field_count", sf_field_count, 0 },
-    { "field_index", sf_field_index, 1 },
-    { "field_name", sf_field_name, 1 },
-    { "field_type", sf_field_type, 1 },
-    { "field_width", sf_field_width, 1 },
-    { "field_decimals", sf_field_decimals, 1 },
-    { "fields", sf_fields, 0 },
-    { "minbound", sf_minbound, 0 },
-    { "maxbound", sf_maxbound, 0 },
-    { "read", sf_read, -1 },
-    { "rewind", sf_rewind, 0 },
-    { "shape_type", sf_shape_type, 0 },
-    { "size", sf_size, 0 },
-    { "write", sf_write, -1 },
+    { "add_field", RUBY_METHOD_FUNC(sf_add_field), -1 },
+    { "close", RUBY_METHOD_FUNC(sf_close), 0 },
+    { "delete_shape", RUBY_METHOD_FUNC(sf_delete_shape), 1 },
+    { "each", RUBY_METHOD_FUNC(sf_each), 0 },
+    { "field_count", RUBY_METHOD_FUNC(sf_field_count), 0 },
+    { "field_index", RUBY_METHOD_FUNC(sf_field_index), 1 },
+    { "field_name", RUBY_METHOD_FUNC(sf_field_name), 1 },
+    { "field_type", RUBY_METHOD_FUNC(sf_field_type), 1 },
+    { "field_width", RUBY_METHOD_FUNC(sf_field_width), 1 },
+    { "field_decimals", RUBY_METHOD_FUNC(sf_field_decimals), 1 },
+    { "fields", RUBY_METHOD_FUNC(sf_fields), 0 },
+    { "minbound", RUBY_METHOD_FUNC(sf_minbound), 0 },
+    { "maxbound", RUBY_METHOD_FUNC(sf_maxbound), 0 },
+    { "read", RUBY_METHOD_FUNC(sf_read), -1 },
+    { "rewind", RUBY_METHOD_FUNC(sf_rewind), 0 },
+    { "shape_type", RUBY_METHOD_FUNC(sf_shape_type), 0 },
+    { "size", RUBY_METHOD_FUNC(sf_size), 0 },
+    { "write", RUBY_METHOD_FUNC(sf_write), -1 },
     { NULL, NULL, 0 }
 };