shapelib 0.7.2 → 0.8.0

data/ext/shapelib_ext/spcode.h

@@ -3,35 +3,72 @@
  */
 #define NUM2DBLo(val) (NIL_P((val)) ? 0.0 : NUM2DBL((val)))
 
-static int *IntPack(VALUE array, int decode_p)
+struct shape_wrap_args {
+    VALUE klass;
+    shape_t *shape;
+};
+
+static VALUE WrapShapeProtected(VALUE ptr)
+{
+    struct shape_wrap_args *args = (struct shape_wrap_args *)ptr;
+    return TypedData_Wrap_Struct(args->klass, &shape_data_type, args->shape);
+}
+
+static VALUE WrapShape(VALUE klass, shape_t *shape)
+{
+    struct shape_wrap_args args = { klass, shape };
+    int state;
+    VALUE obj;
+    if (shape == NULL)
+	rb_raise(rb_eRuntimeError, "SHPCreateObject fails");
+    obj = rb_protect(WrapShapeProtected, (VALUE)&args, &state);
+    if (state) {
+	shape_close(shape);
+	rb_jump_tag(state);
+    }
+    return obj;
+}
+
+static void CheckPartStarts(SHPObject *obj)
 {
-    int *buf;
     int i;
+    for (i = 0; i < obj->nParts; i++) {
+	if (obj->panPartStart[i] < 0 || obj->panPartStart[i] > obj->nVertices)
+	    rb_raise(rb_eArgError, "part_start[%d] must be between 0 and %d", i, obj->nVertices);
+    }
+}
+
+static void CheckPointVertices(SHPObject *obj)
+{
+    if (obj->nVertices < 1)
+	rb_raise(rb_eArgError, "point has no vertices");
+}
+
+static void IntPack(VALUE array, int decode_p, int *buf)
+{
+    long i, length;
     Check_Type(array, T_ARRAY);
-    buf = xmalloc(sizeof(int) * RARRAY_LEN(array));
-    for (i = 0; i < RARRAY_LEN(array); i++) {
+    length = RARRAY_LEN(array);
+    for (i = 0; i < length; i++) {
 	if (decode_p)
 	    buf[i] = Ruby2PartType(RARRAY_PTR(array)[i]);
 	else
 	    buf[i] = NUM2INT(RARRAY_PTR(array)[i]);
     }
-    return buf;
 }
 
-static double *DoublePack(VALUE array, double nilval)
+static void DoublePack(VALUE array, double nilval, double *buf)
 {
-    double *buf;
-    int i;
+    long i, length;
     if (NIL_P(array))
-	return NULL;
+	return;
     Check_Type(array, T_ARRAY);
-    buf = xmalloc(sizeof(double) * RARRAY_LEN(array));
-    for (i = 0; i < RARRAY_LEN(array); i++) {
+    length = RARRAY_LEN(array);
+    for (i = 0; i < length; i++) {
 	VALUE v;
 	v = RARRAY_PTR(array)[i];
 	buf[i] = (NIL_P(v) ? nilval : NUM2DBL(RARRAY_PTR(array)[i]));
     }
-    return buf;
 }
 
 static VALUE HashDeref(VALUE hash, const char *key)
@@ -42,12 +79,19 @@ static VALUE HashDeref(VALUE hash, const char *key)
 	static ID op = 0;
 	if (op == 0)
 	    op = rb_intern("[]");
-	return rb_funcall(hash, op, CSTR2SYM(key));
+	return rb_funcall(hash, op, 1, CSTR2SYM(key));
     }
 }
 
 static VALUE sp_field_set(VALUE obj, VALUE name, VALUE val);
 
+static void CheckArrayLength(VALUE array, int count, const char *name)
+{
+    Check_Type(array, T_ARRAY);
+    if (RARRAY_LEN(array) < count)
+	rb_raise(rb_eArgError, "%s must contain at least %d entries", name, count);
+}
+
 static void HashLoadAttrib(VALUE vshape, VALUE hash)
 {
     VALUE ary, *argv;
@@ -79,6 +123,10 @@ static VALUE sp_s_new(VALUE klass, VALUE hash)
 {
     shape_t *shape;
     VALUE qlass, vshape;
+    VALUE arrays[6];
+    VALUE storage[6] = { 0 };
+    static const char *array_names[] = { "part_type", "part_start", "xvals", "yvals", "zvals", "mvals" };
+    int i;
     int shape_type, shape_id, n_parts, n_vertices;
     int *part_type, *part_start;
     double *xvals, *yvals, *zvals, *mvals;
@@ -87,43 +135,72 @@ static VALUE sp_s_new(VALUE klass, VALUE hash)
     shape_id = NUM2INT_nil(HashDeref(hash, "shape_id"));
     n_parts = NUM2INT(HashDeref(hash, "n_parts"));
     n_vertices = NUM2INT(HashDeref(hash, "n_vertices"));
-    part_type = IntPack(HashDeref(hash, "part_type"), 1);
-    part_start = IntPack(HashDeref(hash, "part_start"), 0);
-    xvals = DoublePack(HashDeref(hash, "xvals"), 0.0);
-    yvals = DoublePack(HashDeref(hash, "yvals"), 0.0);
-    zvals = DoublePack(HashDeref(hash, "zvals"), 0.0);
-    mvals = DoublePack(HashDeref(hash, "mvals"), SHP_NODATA);
-    if (zvals == NULL) rb_raise(rb_eRuntimeError, "missing zvals");
-    if (mvals == NULL) rb_raise(rb_eRuntimeError, "missing mvals");
-    shape = shape_new(shape_type, shape_id,
-	n_parts, part_type, part_start, n_vertices,
-	xvals, yvals, zvals, mvals);
-    if (shape == NULL) rb_raise(rb_eRuntimeError, "SHPCreateObject fails");
-    free(part_type);
-    free(part_start);
-    if (xvals) free(xvals);
-    if (yvals) free(yvals);
-    if (zvals) free(zvals);
-    if (mvals) free(mvals);
-    vshape = TypedData_Wrap_Struct(qlass, &shape_data_type, shape);
+    if (n_parts < 0) rb_raise(rb_eArgError, "n_parts must be nonnegative");
+    if (n_vertices < 0) rb_raise(rb_eArgError, "n_vertices must be nonnegative");
+    for (i = 0; i < 6; i++)
+	arrays[i] = HashDeref(hash, array_names[i]);
+    /* Numeric conversion can mutate any of the caller's arrays. */
+    for (i = 0; i < 6; i++) {
+	if (i < 2 && n_parts == 0 && NIL_P(arrays[i]))
+	    arrays[i] = rb_ary_new();
+	if (!NIL_P(arrays[i])) {
+	    Check_Type(arrays[i], T_ARRAY);
+	    arrays[i] = rb_ary_dup(arrays[i]);
+	}
+    }
+    for (i = 0; i < 6; i++) {
+	if (i < 2 || !NIL_P(arrays[i]))
+	    CheckArrayLength(arrays[i], i < 2 ? n_parts : n_vertices, array_names[i]);
+    }
+    if (NIL_P(arrays[4])) rb_raise(rb_eRuntimeError, "missing zvals");
+    if (NIL_P(arrays[5])) rb_raise(rb_eRuntimeError, "missing mvals");
+    /* Allocate here: ALLOCV_N may use this constructor's stack frame. */
+    part_type = ALLOCV_N(int, storage[0], RARRAY_LEN(arrays[0]));
+    IntPack(arrays[0], 1, part_type);
+    part_start = ALLOCV_N(int, storage[1], RARRAY_LEN(arrays[1]));
+    IntPack(arrays[1], 0, part_start);
+    xvals = NIL_P(arrays[2]) ? NULL : ALLOCV_N(double, storage[2], RARRAY_LEN(arrays[2]));
+    DoublePack(arrays[2], 0.0, xvals);
+    yvals = NIL_P(arrays[3]) ? NULL : ALLOCV_N(double, storage[3], RARRAY_LEN(arrays[3]));
+    DoublePack(arrays[3], 0.0, yvals);
+    zvals = ALLOCV_N(double, storage[4], RARRAY_LEN(arrays[4]));
+    DoublePack(arrays[4], 0.0, zvals);
+    mvals = ALLOCV_N(double, storage[5], RARRAY_LEN(arrays[5]));
+    DoublePack(arrays[5], SHP_NODATA, mvals);
+    shape = shape_new(shape_type, shape_id, n_parts, part_type, part_start, n_vertices,	xvals, yvals, zvals, mvals);
+    for (i = 0; i < 6; i++) {
+	ALLOCV_END(storage[i]);
+	RB_GC_GUARD(arrays[i]);
+    }
+    vshape = WrapShape(qlass, shape);
+    CheckPartStarts(shape->obj);
     HashLoadAttrib(vshape, hash);
     return vshape;
 }
 
-static int CheckPartSize(int argc, VALUE *argv, int *part_start,
-    int *part_type)
+/* Snapshot all coordinate arrays before any numeric conversion can mutate them. */
+static VALUE SnapshotPoints(VALUE points)
+{
+    VALUE snapshot = rb_ary_dup(points);
+    long i;
+    for (i = 0; i < RARRAY_LEN(snapshot); i++) {
+	VALUE point = rb_ary_entry(snapshot, i);
+	if (T_ARRAY == TYPE(point))
+	    rb_ary_store(snapshot, i, rb_ary_dup(point));
+    }
+    return snapshot;
+}
+
+static int CheckPartSize(VALUE parts, int *part_start, int *part_type)
 {    
     int pstart = 0;
     int i;
-    for (i = 0; i < argc; i++) {
+    for (i = 0; i < RARRAY_LEN(parts); i++) {
+	VALUE part = rb_ary_entry(parts, i);
 	VALUE first;
 	int partlen;
-	if (T_ARRAY != TYPE(argv[i])) {
-	    rb_raise(rb_eArgError, "arg %d must be Array", i);
-	    return -1;
-	}
-	partlen = RARRAY_LEN(argv[i]);
-	first = RARRAY_PTR(argv[i])[0];
+	partlen = RARRAY_LEN(part);
+	first = rb_ary_entry(part, 0);
 	switch (TYPE(first)) {
 	    case T_SYMBOL: case T_STRING:
 		part_type[i] = Ruby2PartType(first);
@@ -140,8 +217,7 @@ static int CheckPartSize(int argc, VALUE *argv, int *part_start,
     return pstart;
 }
 
-static void ExtractXYMZ(VALUE v,
-    double *x, double *y, double *m, double *z)
+static void ExtractXYMZ(VALUE v, double *x, double *y, double *m, double *z)
 {
     static int idx = 0, idy, idz, idm;
     if (idx == 0) {
@@ -150,11 +226,10 @@ static void ExtractXYMZ(VALUE v,
     }
     if (T_ARRAY == TYPE(v)) {
 	int argc = RARRAY_LEN(v);
-	VALUE *argv = RARRAY_PTR(v);
-	*x = (argc > 0) ? NUM2DBLo(argv[0]) : 0.0;
-	*y = (argc > 1) ? NUM2DBLo(argv[1]) : 0.0;
-	*m = SHP_NUM2DBL((argc > 2) ? argv[2] : Qnil);
-	*z = (argc > 3) ? NUM2DBL(argv[3]) : 0.0;
+	*x = (argc > 0) ? NUM2DBLo(rb_ary_entry(v, 0)) : 0.0;
+	*y = (argc > 1) ? NUM2DBLo(rb_ary_entry(v, 1)) : 0.0;
+	*m = SHP_NUM2DBL((argc > 2) ? rb_ary_entry(v, 2) : Qnil);
+	*z = (argc > 3) ? NUM2DBL(rb_ary_entry(v, 3)) : 0.0;
     } else {
 	*x = NUM2DBLo(rb_funcall(v, idx, 0));
 	*y = NUM2DBLo(rb_funcall(v, idy, 0));
@@ -171,78 +246,92 @@ static void ExtractXYMZ(VALUE v,
     }
 }
 
-static void CollectPoints(int argc, const VALUE *argv,
-    double *x, double *y, double *m, double *z)
+static void CollectPoints(VALUE points, double *x, double *y, double *m, double *z)
 {
     int i, ofs;
+    int argc = RARRAY_LEN(points);
     ofs = 0;
     if (argc > 0) {
-	switch (TYPE(argv[0])) {
+	switch (TYPE(rb_ary_entry(points, 0))) {
 	case T_SYMBOL: case T_STRING:
 	    ofs++;
 	}
     }
     for (i = 0; i < argc - ofs; i++) {
-	ExtractXYMZ(argv[i + ofs], x + i, y + i, m + i, z + i);
+	ExtractXYMZ(rb_ary_entry(points, i + ofs), x + i, y + i, m + i, z + i);
     }
 }
 
 static shape_t *NewMultiPart(int argc, VALUE *argv, VALUE klass, int shapetype)
 {
     shape_t *shape;
+    VALUE parts = rb_ary_new4(argc, argv);
+    VALUE part_start_storage = 0, part_type_storage = 0, dblock_storage = 0;
     double *dblock, *x, *y, *m, *z;
     int *part_start, *part_type;
     int n_parts, n_vert;
     int ipart;
 
+    for (ipart = 0; ipart < argc; ipart++) {
+	VALUE part = rb_ary_entry(parts, ipart);
+	if (T_ARRAY != TYPE(part))
+	    rb_raise(rb_eArgError, "arg %d must be Array", ipart);
+	if (RARRAY_LEN(part) == 0)
+	    rb_raise(rb_eArgError, "part %d must not be empty", ipart);
+	rb_ary_store(parts, ipart, SnapshotPoints(part));
+    }
     n_parts = argc;
-    part_start = xmalloc(sizeof(int) * n_parts);
-    part_type = xmalloc(sizeof(int) * n_parts);
-    n_vert = CheckPartSize(argc, argv, part_start, part_type);
-    dblock = xmalloc(sizeof(double) * n_vert * 4);
+    part_start = ALLOCV_N(int, part_start_storage, n_parts);
+    part_type = ALLOCV_N(int, part_type_storage, n_parts);
+    n_vert = CheckPartSize(parts, part_start, part_type);
+    dblock = ALLOCV_N(double, dblock_storage, (size_t)n_vert * 4);
     x = dblock;
     y = dblock + n_vert;
     m = dblock + n_vert * 2;
     z = dblock + n_vert * 3;
     for (ipart = 0; ipart < argc; ipart++) {
 	CollectPoints(
-	    RARRAY_LEN(argv[ipart]), RARRAY_PTR(argv[ipart]),
+	    rb_ary_entry(parts, ipart),
 	    x + part_start[ipart], y + part_start[ipart],
 	    m + part_start[ipart], z + part_start[ipart]);
     }
     shape = shape_new_obj(shapetype,
 	n_parts, part_start, part_type, n_vert,
 	x, y, m, z);
-    free(dblock);
-    free(part_start);
-    free(part_type);
+    ALLOCV_END(dblock_storage);
+    ALLOCV_END(part_start_storage);
+    ALLOCV_END(part_type_storage);
+    RB_GC_GUARD(parts);
     return shape;
 }
 
 static shape_t *NewSinglePart(int argc, VALUE *argv, VALUE klass, int shapetype)
 {
     shape_t *shape;
+    VALUE points = SnapshotPoints(rb_ary_new4(argc, argv));
+    VALUE storage = 0;
     double *dblock, *x, *y, *m, *z;
     int n_vert, part_type_buf;
     int part_start_buf = 0;
     n_vert = argc;
-    switch (TYPE(argv[0])) {
+    switch (TYPE(rb_ary_entry(points, 0))) {
 	case T_STRING: case T_SYMBOL:
-	    part_type_buf = Ruby2PartType(argv[0]);
+	    part_type_buf = Ruby2PartType(rb_ary_entry(points, 0));
 	    n_vert--;
 	    break;
 	default:
 	    part_type_buf = SHPP_RING;
     }
-    dblock = xmalloc(sizeof(double) * n_vert * 4);
+    dblock = ALLOCV_N(double, storage, (size_t)n_vert * 4);
     x = dblock;
     y = dblock + n_vert;
     m = dblock + n_vert * 2;
     z = dblock + n_vert * 3;
-    CollectPoints(argc, argv, x, y, m, z);
+    CollectPoints(points, x, y, m, z);
     shape = shape_new_obj(shapetype,
 	1, &part_start_buf, &part_type_buf, n_vert, x, y, m, z);
-    free(dblock);
+    ALLOCV_END(storage);
+    RB_GC_GUARD(points);
     return shape;
 }
 
@@ -262,16 +351,13 @@ static VALUE NewShape(int argc, VALUE *argv, VALUE klass, int shapetype)
     shape_t *shape;
     int multipart;
     monitor(("NewShape"));
+    if (argc == 0)
+	rb_raise(rb_eArgError, "at least one point is required");
     if (T_ARRAY == TYPE(argv[0])) {
-	switch (TYPE( RARRAY_PTR(argv[0])[0] )) {
-	case T_FIXNUM:
-	case T_FLOAT:
-	    multipart = 0;
-	    break;
-	default:
-	    multipart = 1;
-	    break;
-	}
+	VALUE first = rb_ary_entry(argv[0], 0);
+	if (RARRAY_LEN(argv[0]) == 0)
+	    rb_raise(rb_eArgError, "first geometry array must not be empty");
+	multipart = !(RB_INTEGER_TYPE_P(first) || RB_TYPE_P(first, T_FLOAT));
     } else {
 	multipart = 0;
     }
@@ -280,27 +366,42 @@ static VALUE NewShape(int argc, VALUE *argv, VALUE klass, int shapetype)
     } else {
 	shape = NewSinglePart(argc, argv, klass, shapetype);
     }
-    return TypedData_Wrap_Struct(klass, &shape_data_type, shape);
+    return WrapShape(klass, shape);
 }
 
 static VALUE MultiPointNew(int argc, VALUE *argv, VALUE klass, int shapetype)
 {
     shape_t *shape;
+    VALUE points = SnapshotPoints(rb_ary_new4(argc, argv));
+    VALUE storage = 0;
     double *dblock, *x, *y, *m, *z;
     int *part_start;
     int n_vert;
     int part_start_buf = 0;
+    if (argc == 1 && TYPE(rb_ary_entry(points, 0)) == T_ARRAY) {
+	/* Snapshot nested coordinates before point detection can invoke Ruby. */
+	VALUE candidate = SnapshotPoints(rb_ary_entry(points, 0));
+	VALUE first = rb_ary_entry(candidate, 0);
+	if (RARRAY_LEN(candidate) > 0 &&
+	    (TYPE(first) == T_ARRAY ||
+	     (rb_respond_to(first, rb_intern("x")) && rb_respond_to(first, rb_intern("y")))))
+	    points = candidate;
+	RB_GC_GUARD(candidate);
+    }
+    if (TYPE(rb_ary_entry(points, 0)) == T_STRING || TYPE(rb_ary_entry(points, 0)) == T_SYMBOL)
+	rb_raise(rb_eArgError, "MultiPoint does not accept part type labels");
     part_start = &part_start_buf;
-    n_vert = argc;
-    dblock = malloc(sizeof(double) * n_vert * 4);
+    n_vert = RARRAY_LEN(points);
+    dblock = ALLOCV_N(double, storage, (size_t)n_vert * 4);
     x = dblock;
     y = dblock + n_vert;
     m = dblock + n_vert * 2;
     z = dblock + n_vert * 3;
-    CollectPoints(argc, argv, x, y, m, z);
+    CollectPoints(points, x, y, m, z);
     shape = shape_new_obj(shapetype, 1, part_start, NULL, n_vert, x, y, m, z);
-    free(dblock);
-    return TypedData_Wrap_Struct(klass, &shape_data_type, shape);
+    ALLOCV_END(storage);
+    RB_GC_GUARD(points);
+    return WrapShape(klass, shape);
 }
 
 static VALUE arc_s_new(int argc, VALUE *argv, VALUE klass) {
@@ -346,22 +447,21 @@ static VALUE mpz_s_new(int argc, VALUE *argv, VALUE klass) {
 
 static void PointAddAttr(VALUE pt, VALUE attrs)
 {
-    VALUE *argv;
     VALUE ary;
     int i, argc;
     Check_Type(attrs, T_HASH);
     ary = rb_funcall(attrs, rb_intern("to_a"), 0);
     Check_Type(ary, T_ARRAY);
-    argv = RARRAY_PTR(ary);
+    ary = SnapshotPoints(ary);
     argc = RARRAY_LEN(ary);
     for (i = 0; i < argc; i++) {
-	VALUE *pair;
-	Check_Type(argv[i], T_ARRAY);
-	if (RARRAY_LEN(argv[i]) != 2)
-	    rb_bug("hash.to_a member has weird size");
-	pair = RARRAY_PTR(argv[i]);
-	sp_field_set(pt, pair[0], pair[1]);
+	VALUE pair = rb_ary_entry(ary, i);
+	Check_Type(pair, T_ARRAY);
+	if (RARRAY_LEN(pair) != 2)
+	    rb_raise(rb_eArgError, "attribute pair must contain exactly two entries");
+	sp_field_set(pt, rb_ary_entry(pair, 0), rb_ary_entry(pair, 1));
     }
+    RB_GC_GUARD(ary);
 }
 
 
@@ -372,7 +472,7 @@ static VALUE pt_s_new(int argc, VALUE *argv, VALUE klass)
     rb_scan_args(argc, argv, "21", &vx, &vy, &attrs);
     shape = shape_new_point(SHPT_POINT,
 	NUM2DBLo(vx), NUM2DBLo(vy), 0.0, 0.0);
-    pt = TypedData_Wrap_Struct(klass, &shape_data_type, shape);
+    pt = WrapShape(klass, shape);
     if (!NIL_P(attrs)) {
 	PointAddAttr(pt, attrs);
     }
@@ -386,7 +486,7 @@ static VALUE ptm_s_new(int argc, VALUE *argv, VALUE klass)
     rb_scan_args(argc, argv, "31", &vx, &vy, &vm, &attrs);
     shape = shape_new_point(SHPT_POINTM,
 	NUM2DBLo(vx), NUM2DBLo(vy), SHP_NUM2DBL(vm), 0.0);
-    pt = TypedData_Wrap_Struct(klass, &shape_data_type, shape);
+    pt = WrapShape(klass, shape);
     if (!NIL_P(attrs)) {
 	PointAddAttr(pt, attrs);
     }
@@ -400,25 +500,25 @@ static VALUE ptz_s_new(int argc, VALUE *argv, VALUE klass)
     rb_scan_args(argc, argv, "41", &vx, &vy, &vm, &vz, &attrs);
     shape = shape_new_point(SHPT_POINTZ,
 	NUM2DBLo(vx), NUM2DBLo(vy), SHP_NUM2DBL(vm), NUM2DBLo(vz));
-    pt = TypedData_Wrap_Struct(klass, &shape_data_type, shape);
+    pt = WrapShape(klass, shape);
     if (!NIL_P(attrs)) {
 	PointAddAttr(pt, attrs);
     }
     return pt;
 }
 
-/* ShapeLib.new_point */
+/* Shapelib.new_point */
 static VALUE sl_m_new_point(int argc, VALUE *argv, VALUE klass)
 {
     if (2 == argc || (3 == argc && T_HASH == TYPE(argv[2]))) {
 	return pt_s_new(argc, argv, cPoint);
-    } else if (3 == argc || (4 == argc && T_HASH != TYPE(argv[3]))) {
+    } else if (3 == argc || (4 == argc && (T_HASH == TYPE(argv[3]) || NIL_P(argv[3])))) {
 	return ptm_s_new(argc, argv, cPointM);
-    } else if (4 == argc || (5 == argc && T_HASH != TYPE(argv[4]))) {
+    } else if (4 == argc || 5 == argc) {
 	return ptz_s_new(argc, argv, cPointZ);
     } else {
 	rb_raise(rb_eArgError,
-	"usage: ShapeLib::Shape.new_point x, y, m, z, attr_array");
+	"usage: Shapelib.new_point x, y, m, z, attr_array");
 	return Qnil;
     }
 }
@@ -467,7 +567,7 @@ static VALUE sp_field_get(VALUE obj, VALUE name)
     int ofs;
 
     TypedData_Get_Struct(obj, shape_t, &shape_data_type, self);
-    cname = StringValuePtr(name);
+    cname = StringValueCStr(name);
     ofs = shape_attrib_index(self, cname, 0);
     if (ofs < 0) {
 	return Qnil;
@@ -481,6 +581,9 @@ static VALUE sp_field_get(VALUE obj, VALUE name)
 	    return rb_float_new(self->attr[ofs].val.fval);
 	case FTString:
 	case FTLogical:
+#ifdef HAVE_CONST_FTDATE
+	case FTDate:
+#endif
 	    return rb_str_new2(self->attr[ofs].val.sval);
 	default:
 	    rb_raise(rb_eTypeError, "unacceptable field type");
@@ -491,35 +594,42 @@ static VALUE sp_field_get(VALUE obj, VALUE name)
 static VALUE sp_field_set(VALUE obj, VALUE name, VALUE val)
 {
     shape_t *self;
+    attrib_t replacement;
     char *cname;
     int	ofs;
 
     TypedData_Get_Struct(obj, shape_t, &shape_data_type, self);
-    cname = StringValuePtr(name);
+    rb_check_frozen(obj);
+    cname = StringValueCStr(name);
+    rb_check_frozen(obj);
     ofs = shape_attrib_index(self, cname, 1);
     if (ofs < 0) {
 	return Qnil;
     }
+    memset(&replacement.val, 0, sizeof(replacement.val));
     switch (TYPE(val)) {
 	case T_STRING:
-	    self->attr[ofs].type = FTString;
-	    self->attr[ofs].val.sval = StringDup(StringValuePtr(val));
+	    replacement.type = FTString;
+	    replacement.val.sval = StringDup(StringValueCStr(val));
 	    break;
 	case T_FIXNUM:
-	    self->attr[ofs].type = FTInteger;
-	    self->attr[ofs].val.ival = FIX2INT(val);
+	    replacement.type = FTInteger;
+	    replacement.val.ival = FIX2INT(val);
 	    break;
 	case T_FLOAT:
-	    self->attr[ofs].type = FTDouble;
-	    self->attr[ofs].val.fval = RFLOAT_VALUE(val);
+	    replacement.type = FTDouble;
+	    replacement.val.fval = RFLOAT_VALUE(val);
 	    break;
 	case T_NIL:
-	    self->attr[ofs].type = -1;
+	    replacement.type = -1;
 	    break;
 	default:
 	    rb_raise(rb_eTypeError,
 		    "give me String, Integer, or Float");
     }
+    shape_attrib_clear_value(&self->attr[ofs]);
+    self->attr[ofs].type = replacement.type;
+    self->attr[ofs].val = replacement.val;
     return obj;
 }
 
@@ -613,7 +723,12 @@ static VALUE sp_rewind(VALUE obj)
 {
     shape_t *self;
     TypedData_Get_Struct(obj, shape_t, &shape_data_type, self);
-    return SHPRewindObject(NULL, self->obj) ? Qtrue : Qfalse;
+    rb_check_frozen(obj);
+    if (SHPRewindObject(NULL, self->obj)) {
+	rb_iv_set(obj, "@latlngs", Qnil);
+	return Qtrue;
+    }
+    return Qfalse;
 }
 
 static VALUE sp_xvals(VALUE obj)
@@ -649,6 +764,7 @@ static VALUE pt_x(VALUE obj)
 	case SHPT_POINT:
 	case SHPT_POINTM:
 	case SHPT_POINTZ:
+	    CheckPointVertices(self->obj);
 	    return rb_float_new(self->obj->padfX[0]);
 	default:
 	    rb_bug("shape type %d is not Point", self->obj->nSHPType);
@@ -664,6 +780,7 @@ static VALUE pt_y(VALUE obj)
 	case SHPT_POINT:
 	case SHPT_POINTM:
 	case SHPT_POINTZ:
+	    CheckPointVertices(self->obj);
 	    return rb_float_new(self->obj->padfY[0]);
 	default:
 	    rb_bug("shape type %d is not Point", self->obj->nSHPType);
@@ -678,6 +795,7 @@ static VALUE pt_m(VALUE obj)
     switch (self->obj->nSHPType) {
 	case SHPT_POINTM:
 	case SHPT_POINTZ:
+	    CheckPointVertices(self->obj);
 	    return SHP_FLOAT_NEW(self->obj->padfM[0]);
 	case SHPT_POINT:
 	    return Qnil;
@@ -693,7 +811,8 @@ static VALUE pt_z(VALUE obj)
     TypedData_Get_Struct(obj, shape_t, &shape_data_type, self);
     switch (self->obj->nSHPType) {
 	case SHPT_POINTZ:
-	    return rb_float_new(self->obj->padfM[0]);
+	    CheckPointVertices(self->obj);
+	    return rb_float_new(self->obj->padfZ[0]);
 	case SHPT_POINTM:
 	case SHPT_POINT:
 	    return Qnil;

data/ext/shapelib_ext/splist.h

@@ -22,32 +22,32 @@ static VALUE sp_to_h(VALUE obj)
 }
 
 static method_table_entry sp_methods[] = {
-    { "[]",		sp_field_get, 1 },
-    { "[]=",		sp_field_set, 2 },
-    { "maxbound",	sp_maxbound, 0 },
-    { "minbound",	sp_minbound, 0 },
-    { "mvals",		sp_mvals, 0 },
-    { "n_parts",	sp_n_parts, 0 },
-    { "n_vertices",	sp_n_vertices, 0 },
-    { "part_start",	sp_part_start, 0 },
-    { "part_type",	sp_part_type, 0 },
-    { "shape_type",	sp_shape_type, 0 },
-    { "shape_id",	sp_shape_id, 0 },
-    { "to_h",		sp_to_h, 0 },
-    { "to_s",		sp_wkt, 0 },
-    { "rewind_polygon",	sp_rewind, 0 },
-    { "wkt",		sp_wkt, 0 },
-    { "xvals",		sp_xvals, 0 },
-    { "yvals",		sp_yvals, 0 },
-    { "zvals",		sp_zvals, 0 },
+    { "[]",		RUBY_METHOD_FUNC(sp_field_get), 1 },
+    { "[]=",		RUBY_METHOD_FUNC(sp_field_set), 2 },
+    { "maxbound",	RUBY_METHOD_FUNC(sp_maxbound), 0 },
+    { "minbound",	RUBY_METHOD_FUNC(sp_minbound), 0 },
+    { "mvals",		RUBY_METHOD_FUNC(sp_mvals), 0 },
+    { "n_parts",	RUBY_METHOD_FUNC(sp_n_parts), 0 },
+    { "n_vertices",	RUBY_METHOD_FUNC(sp_n_vertices), 0 },
+    { "part_start",	RUBY_METHOD_FUNC(sp_part_start), 0 },
+    { "part_type",	RUBY_METHOD_FUNC(sp_part_type), 0 },
+    { "shape_type",	RUBY_METHOD_FUNC(sp_shape_type), 0 },
+    { "shape_id",	RUBY_METHOD_FUNC(sp_shape_id), 0 },
+    { "to_h",		RUBY_METHOD_FUNC(sp_to_h), 0 },
+    { "to_s",		RUBY_METHOD_FUNC(sp_wkt), 0 },
+    { "rewind_polygon",	RUBY_METHOD_FUNC(sp_rewind), 0 },
+    { "wkt",		RUBY_METHOD_FUNC(sp_wkt), 0 },
+    { "xvals",		RUBY_METHOD_FUNC(sp_xvals), 0 },
+    { "yvals",		RUBY_METHOD_FUNC(sp_yvals), 0 },
+    { "zvals",		RUBY_METHOD_FUNC(sp_zvals), 0 },
     { NULL, NULL, 0 }
 };
 
 static method_table_entry pt_methods[] = {
-    { "m",		pt_m, 0 },
-    { "wkt",		pt_wkt, 0 },
-    { "x",		pt_x, 0 },
-    { "y",		pt_y, 0 },
-    { "z",		pt_z, 0 },
+    { "m",		RUBY_METHOD_FUNC(pt_m), 0 },
+    { "wkt",		RUBY_METHOD_FUNC(pt_wkt), 0 },
+    { "x",		RUBY_METHOD_FUNC(pt_x), 0 },
+    { "y",		RUBY_METHOD_FUNC(pt_y), 0 },
+    { "z",		RUBY_METHOD_FUNC(pt_z), 0 },
     { NULL, NULL, 0 }
 };