shapelib 0.7.0 → 0.8.0

data/ext/shapelib_ext/shpplus.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <string.h>
@@ -10,6 +11,9 @@
 #include <ruby.h>
 #include "shpplus.h"
 
+/* Match native shapelib's numeric formatting instead of Ruby's substitute. */
+#undef snprintf
+
 #define HAS_DBFMARKRECORDDELETED 0
 #define ATTR_TABLE_DEFAULT	16
 
@@ -80,16 +84,26 @@ static shapefile_t *ShapefileInit(void)
     sfile = xmalloc(sizeof(shapefile_t));
     if (sfile == NULL)
 	return NULL;
+    sfile->hshp = NULL;
+    sfile->hdbf = NULL;
     sfile->nrecs = sfile->nfields = -1;
     sfile->ftab = NULL;
     sfile->irec = 0;
     return sfile;
 }
 
+static void ShapefileFail(shapefile_t *sfile, const char *operation,
+    const char *filename)
+{
+    shapefile_close(sfile);
+    xfree(sfile);
+    rb_raise(rb_eIOError, "%s failed for %s", operation, filename);
+}
+
 static void ShapefileBuildFieldTable(shapefile_t *sfile)
 {
     int i;
-    if (sfile->ftab)
+    if (!sfile->hdbf || sfile->ftab)
 	return;
     sfile->nfields = shapefile_field_count(sfile);
     sfile->ftab = xmalloc(sizeof(field_t) * sfile->nfields);
@@ -107,12 +121,22 @@ static void ShapefileBuildFieldTable(shapefile_t *sfile)
     }
 }
 
+static VALUE ShapefileBuildFieldTableProtected(VALUE ptr)
+{
+    ShapefileBuildFieldTable((shapefile_t *)ptr);
+    return Qnil;
+}
+
 static void ShapefileWriteAttribute(shapefile_t *sfile,
     int irec, int ifield, attrib_t *a)
 {
     int s;
     if (a->type == -1) {
 	rb_bug("supposed to be rejected in shapefile_write");
+#ifdef HAVE_CONST_FTDATE
+    } else if (sfile->ftab[ifield].type == FTDate) {
+	s = DBFWriteAttributeDirectly(sfile->hdbf, irec, ifield, a->val.sval);
+#endif
     } else if (a->type == FTInteger) {
 	s = DBFWriteIntegerAttribute(sfile->hdbf, irec, ifield,
 	    a->val.ival);
@@ -141,12 +165,20 @@ static void ShapefileWriteAttribute(shapefile_t *sfile,
 shapefile_t *shapefile_open(const char *filename, const char *mode)
 {
     shapefile_t *sfile;
+    int state;
     sfile = ShapefileInit();
     sfile->hshp = SHPOpen(filename, mode);
     monitor(("SHPOpen(\"%s\", \"%s\") -> %p", filename, mode, sfile->hshp));
+    if (!sfile->hshp)
+	ShapefileFail(sfile, "SHPOpen", filename);
     sfile->hdbf = DBFOpen(filename, mode);
     monitor(("DBFOpen(\"%s\", \"%s\") -> %p", filename, mode, sfile->hdbf));
-    ShapefileBuildFieldTable(sfile);
+    rb_protect(ShapefileBuildFieldTableProtected, (VALUE)sfile, &state);
+    if (state) {
+	shapefile_close(sfile);
+	xfree(sfile);
+	rb_jump_tag(state);
+    }
     return sfile;
 }
 
@@ -156,8 +188,12 @@ shapefile_t *shapefile_new(const char *filename, int shptype)
     sfile = ShapefileInit();
     sfile->hshp = SHPCreate(filename, shptype);
     monitor(("SHPCreate(\"%s\", %d) -> %p", filename, shptype, sfile->hshp));
+    if (!sfile->hshp)
+	ShapefileFail(sfile, "SHPCreate", filename);
     sfile->hdbf = DBFCreate(filename);
     monitor(("DBFCreate(\"%s\") -> %p", filename, sfile->hdbf));
+    if (!sfile->hdbf)
+	ShapefileFail(sfile, "DBFCreate", filename);
     return sfile;
 }
 
@@ -173,6 +209,16 @@ int shapefile_add_field(shapefile_t *sfile, const char *name,
 	rb_raise(rb_eRuntimeError, "add field before you write a record");
 	return -1;
     }
+    if ((atype == FTInteger || atype == FTDouble) && (decimals < 0 || decimals > 255))
+	rb_raise(rb_eArgError, "numeric field precision must be between 0 and 255");
+#ifdef HAVE_CONST_FTDATE
+    if (atype == FTDate && (width != 8 || decimals != 0))
+	rb_raise(rb_eArgError, "Date fields require width 8 and zero decimal places");
+#endif
+    if (strlen(name) > XBASE_FLDNAME_LEN_WRITE)
+	rb_raise(rb_eArgError, "field name exceeds 10 bytes");
+    if (DBFGetFieldIndex(sfile->hdbf, name) >= 0)
+	rb_raise(rb_eArgError, "field name already exists: %s", name);
     monitor(("DBFAddField(%p, %s, %d, %d, %d)", sfile->hdbf, name,
 	atype, width, decimals));
     r = DBFAddField(sfile->hdbf, name, (DBFFieldType)atype, width, decimals);
@@ -206,7 +252,8 @@ int shapefile_field_decimals(shapefile_t *sfile, unsigned ifield)
     int decimals;
     if (NULL == sfile->hdbf)
 	return -1;
-    DBFGetFieldInfo(sfile->hdbf, ifield, NULL, NULL, &decimals);
+    if (DBFGetFieldInfo(sfile->hdbf, ifield, NULL, NULL, &decimals) == FTInvalid)
+	return -1;
     return decimals;
 }
 
@@ -259,7 +306,8 @@ const char *shapefile_field_name(shapefile_t *sfile, unsigned ifield)
     static char buf[DBF_NAMELEN];
     if (NULL == sfile->hdbf)
 	return NULL;
-    DBFGetFieldInfo(sfile->hdbf, ifield, buf, NULL, NULL);
+    if (DBFGetFieldInfo(sfile->hdbf, ifield, buf, NULL, NULL) == FTInvalid)
+	return NULL;
     return buf;
 }
 
@@ -282,7 +330,8 @@ int shapefile_field_width(shapefile_t *sfile, unsigned ifield)
     int width;
     if (NULL == sfile->hdbf)
 	return -1;
-    DBFGetFieldInfo(sfile->hdbf, ifield, NULL, &width, NULL);
+    if (DBFGetFieldInfo(sfile->hdbf, ifield, NULL, &width, NULL) == FTInvalid)
+	return -1;
     return width;
 }
 
@@ -319,29 +368,19 @@ void shapefile_bound(shapefile_t *sfile, double *minbound, double *maxbound)
     SHPGetInfo(sfile->hshp, NULL, NULL, minbound, maxbound);
 }
 
-shape_t *shapefile_read(shapefile_t *sfile, int ishape)
-{
+struct shapefile_read_attributes_args {
+    shapefile_t *sfile;
     shape_t *shape;
+    int ishape;
+};
+
+static VALUE ShapefileReadAttributesProtected(VALUE ptr)
+{
+    struct shapefile_read_attributes_args *args = (struct shapefile_read_attributes_args *)ptr;
+    shapefile_t *sfile = args->sfile;
+    shape_t *shape = args->shape;
+    int ishape = args->ishape;
     int i, iattr;
-    if (NULL == sfile->hshp)
-	return NULL;
-    if (ishape < 0) {
-	if (sfile->nrecs < 0) {
-	    shapefile_size(sfile);
-	    sfile->irec = 0;
-	}
-	ishape = (sfile->irec)++;
-    } else {
-	sfile->irec = ishape + 1;
-    }
-    shape = shape_init(SHPReadObject(sfile->hshp, ishape));
-    if (shape == NULL)
-	return NULL;
-    monitor(("SHPReadObject(%p) -> %p", sfile->hshp, shape));
-    if (shape->obj->nSHPType == SHPT_NULL) {
-	monitor(("shape type NULL"));
-	return NULL;
-    }
     ShapefileBuildFieldTable(sfile);
     if (NULL == sfile->hdbf)
 	goto no_dbf;
@@ -351,6 +390,12 @@ shape_t *shapefile_read(shapefile_t *sfile, int ishape)
 	goto no_dbf;
     }
 #endif
+    if (sfile->nfields > 0 && DBFReadTuple(sfile->hdbf, ishape) == NULL) {
+	/* A partial read can overwrite the buffer without changing its record number. */
+	if (!sfile->hdbf->bCurrentRecordModified)
+	    sfile->hdbf->nCurrentRecord = -1;
+	rb_raise(rb_eIOError, "cannot read DBF record %d", ishape);
+    }
     ShapeSetAttrTable(shape, sfile->nfields);
     for (i = iattr = 0; i < sfile->nfields; i++) {
 	attrib_t *a;
@@ -381,6 +426,47 @@ shape_t *shapefile_read(shapefile_t *sfile, int ishape)
 	;
     }
 no_dbf:
+    return Qnil;
+}
+
+shape_t *shapefile_read(shapefile_t *sfile, int ishape)
+{
+    shape_t *shape;
+    struct shapefile_read_attributes_args args;
+    int state;
+    int sequential = ishape < 0;
+    if (NULL == sfile->hshp)
+	return NULL;
+    if (ishape < 0) {
+	if (sfile->nrecs < 0) {
+	    shapefile_size(sfile);
+	}
+	ishape = sfile->irec;
+    } else {
+	sfile->irec = ishape + 1;
+    }
+    while (1) {
+	shape = shape_init(SHPReadObject(sfile->hshp, ishape));
+	if (shape == NULL)
+	    return NULL;
+	sfile->irec = ishape + 1;
+	monitor(("SHPReadObject(%p) -> %p", sfile->hshp, shape));
+	if (shape->obj->nSHPType != SHPT_NULL)
+	    break;
+	monitor(("shape type NULL"));
+	shape_close(shape);
+	if (!sequential)
+	    return NULL;
+	ishape = sfile->irec;
+    }
+    args.sfile = sfile;
+    args.shape = shape;
+    args.ishape = ishape;
+    rb_protect(ShapefileReadAttributesProtected, (VALUE)&args, &state);
+    if (state) {
+	shape_close(shape);
+	rb_jump_tag(state);
+    }
     return shape;
 }
 
@@ -417,23 +503,115 @@ int shapefile_size(shapefile_t *sfile)
 int shapefile_write(shapefile_t *sfile, int irec, shape_t *shape)
 {
     int r;
+    int shape_type, file_type, record_count;
+    int ipart;
     int ifield;
     int iattr;
     int *usedfield;
+    VALUE usedfield_storage = 0;
     /* precondition */
     if (!sfile->hshp || !shape->obj)
 	return -1;
+    if (!sfile->hdbf)
+	rb_raise(rb_eIOError, "DBF file is not open for writing");
+    SHPGetInfo(sfile->hshp, &record_count, &file_type, NULL, NULL);
+    if (irec < -1 || (irec >= 0 && irec >= record_count))
+	rb_raise(rb_eArgError,
+	    "write index %d must be -1 (append) or an existing record index (record count: %d)",
+	    irec, record_count);
+    shape_type = shape->obj->nSHPType;
+    switch (shape_type) {
+    case SHPT_NULL:
+    case SHPT_POINT: case SHPT_POINTM: case SHPT_POINTZ:
+    case SHPT_ARC: case SHPT_ARCM: case SHPT_ARCZ:
+    case SHPT_POLYGON: case SHPT_POLYGONM: case SHPT_POLYGONZ:
+    case SHPT_MULTIPOINT: case SHPT_MULTIPOINTM: case SHPT_MULTIPOINTZ:
+    case SHPT_MULTIPATCH:
+	break;
+    default:
+	rb_raise(rb_eArgError, "unsupported shape type %d", shape_type);
+    }
+    if (shape_type != SHPT_NULL && shape_type != file_type)
+	rb_raise(rb_eArgError, "shape type %d does not match ShapeFile type %d", shape_type, file_type);
+    if (shape_type == SHPT_POINT || shape_type == SHPT_POINTM || shape_type == SHPT_POINTZ) {
+	if (shape->obj->nVertices < 1)
+	    rb_raise(rb_eArgError, "point has no vertices");
+	if (shape->obj->nVertices > 1)
+	    rb_raise(rb_eArgError, "point must have exactly one vertex (got %d)", shape->obj->nVertices);
+    }
+    if (shape_type == SHPT_NULL && shape->obj->nVertices != 0)
+	rb_raise(rb_eArgError, "null shape must have no vertices (got %d)", shape->obj->nVertices);
+    /* Match the part-layout checks in SHPReadObject before changing either file. */
+    for (ipart = 0; ipart < shape->obj->nParts; ipart++) {
+	int start = shape->obj->panPartStart[ipart];
+	int vertices = shape->obj->nVertices;
+	if (start < 0 || (vertices > 0 ? start >= vertices : start != 0))
+	    rb_raise(rb_eArgError, "part_start[%d] is out of bounds for %d vertices", ipart, vertices);
+	if (ipart > 0 && start <= shape->obj->panPartStart[ipart - 1])
+	    rb_raise(rb_eArgError, "part_start[%d] must be greater than part_start[%d]", ipart, ipart - 1);
+	if (shape_type == SHPT_MULTIPATCH &&
+	    (shape->obj->panPartType[ipart] < 0 || shape->obj->panPartType[ipart] > 5))
+	    rb_raise(rb_eArgError, "part_type[%d] must be between 0 and 5 (got %d)",
+		ipart, shape->obj->panPartType[ipart]);
+    }
     ShapefileBuildFieldTable(sfile);
+    /* Reject invalid attributes before changing either file. */
+    for (iattr = 0; iattr < shape->nattr; iattr++) {
+	attrib_t *a = &(shape->attr[iattr]);
+	DBFFieldType type;
+	if (a->type == -1)
+	    continue;
+	ifield = DBFGetFieldIndex(sfile->hdbf, a->name);
+	if (ifield == -1)
+	    rb_raise(rb_eArgError, "attribute %s not defined in ShapeFile", a->name);
+	type = sfile->ftab[ifield].type;
+#ifdef HAVE_CONST_FTDATE
+	if (type == FTDate) {
+	    if (a->type != FTString && a->type != FTDate)
+		rb_raise(rb_eTypeError, "attribute %s has incompatible type for ShapeFile field", a->name);
+	    if (shapefile_field_width(sfile, ifield) != 8 || shapefile_field_decimals(sfile, ifield) != 0)
+		rb_raise(rb_eArgError, "Date fields require width 8 and zero decimal places");
+	    if (strlen(a->val.sval) != 8 || strspn(a->val.sval, "0123456789") != 8)
+		rb_raise(rb_eArgError, "attribute %s must be an 8-digit YYYYMMDD string", a->name);
+	    continue;
+	}
+#endif
+	if (!(((type == FTInteger || type == FTDouble) &&
+	       (a->type == FTInteger || a->type == FTDouble)) ||
+	      ((type == FTString || type == FTLogical) &&
+	       (a->type == FTString || a->type == FTLogical
+#ifdef HAVE_CONST_FTDATE
+		|| a->type == FTDate
+#endif
+	       ))))
+	    rb_raise(rb_eTypeError, "attribute %s has incompatible type for ShapeFile field", a->name);
+	if (type == FTLogical && a->val.sval[0] != 'T' && a->val.sval[0] != 'F')
+	    rb_raise(rb_eArgError, "attribute %s must start with T or F for a Logical field", a->name);
+	if (type == FTString && strlen(a->val.sval) > (size_t)shapefile_field_width(sfile, ifield))
+	    rb_raise(rb_eRuntimeError, "attribute %s exceeds field width", a->name);
+	if (type == FTInteger || type == FTDouble) {
+	    int width, decimals, length;
+	    double value = a->type == FTInteger ? (double)a->val.ival : a->val.fval;
+	    DBFGetFieldInfo(sfile->hdbf, ifield, NULL, &width, &decimals);
+	    length = snprintf(NULL, 0, "%.*f", decimals, value);
+	    if (length < 0)
+		rb_raise(rb_eRuntimeError, "cannot format numeric attribute %s", a->name);
+	    if (length > width)
+		rb_raise(rb_eRuntimeError, "attribute %s exceeds field width", a->name);
+	}
+    }
+    /* Ruby can reclaim this temporary buffer if attribute writing raises. */
+    usedfield = ALLOCV_N(int, usedfield_storage, sfile->nfields);
+    for (ifield = 0; ifield < sfile->nfields; ifield++) {
+	usedfield[ifield] = 0;
+    }
     /* write the object */
     r = SHPWriteObject(sfile->hshp, irec, shape->obj);
     monitor(("SHPWriteObject(%p, %d, %p) -> %d", sfile->hshp, irec,
     	shape->obj, r));
-    if (r < 0)
+    if (r < 0) {
+	ALLOCV_END(usedfield_storage);
 	return -1;
-    /* make field table */
-    usedfield = xmalloc(sizeof(int) * sfile->nfields);
-    for (ifield = 0; ifield < sfile->nfields; ifield++) {
-	usedfield[ifield] = 0;
     }
     for (iattr = 0; iattr < shape->nattr; iattr++) {
 	attrib_t	*a;
@@ -442,10 +620,6 @@ int shapefile_write(shapefile_t *sfile, int irec, shape_t *shape)
 	    continue;
 	}
 	ifield = DBFGetFieldIndex(sfile->hdbf, a->name);
-	if (ifield == -1) {
-	    rb_raise(rb_eArgError,
-		"attribute %s not defined in ShapeFile", a->name);
-	}
 	ShapefileWriteAttribute(sfile, r, ifield, a);
 	usedfield[ifield] = 1;
     }
@@ -453,29 +627,35 @@ int shapefile_write(shapefile_t *sfile, int irec, shape_t *shape)
 	int r2;
 	if (usedfield[ifield] == 0) {
 	    r2 = DBFWriteNULLAttribute(sfile->hdbf, r, ifield);
-	    monitor(("DBFWriteNULLAttribute(%p %d %d -> %d",
-		sfile->hdbf, r, ifield, r2));
+	    monitor(("DBFWriteNULLAttribute(%p %d %d -> %d", sfile->hdbf, r, ifield, r2));
 	    if (r2 == 0)
 		rb_raise(rb_eRuntimeError, "write error");
 	}
     }
-    free(usedfield);
+    ALLOCV_END(usedfield_storage);
     return r;
 }
 
+static VALUE ShapeInitProtected(VALUE ptr)
+{
+    shape_t *sh = xmalloc(sizeof(shape_t));
+    sh->obj = (SHPObject *)ptr;
+    sh->attr = NULL;
+    sh->nattr = 0;
+    return (VALUE)sh;
+}
+
 static shape_t *shape_init(SHPObject *objp)
 {
     shape_t *sh;
+    int state;
     if (objp == NULL)
 	return NULL;
-    sh = xmalloc(sizeof(shape_t));
-    if (sh == NULL) {
+    sh = (shape_t *)rb_protect(ShapeInitProtected, (VALUE)objp, &state);
+    if (state) {
 	SHPDestroyObject(objp);
-	return NULL;
+	rb_jump_tag(state);
     }
-    sh->obj = objp;
-    sh->attr = NULL;
-    sh->nattr = 0;
     return sh;
 }
 
@@ -545,20 +725,37 @@ int shape_attrib_index(shape_t *sh, const char *key, int extend)
     }
     for (i = 0; i < sh->nattr; i++) {
 	if (sh->attr[i].type == -1) {
-	    strcpy(sh->attr[i].name, key);
+	    strncpy(sh->attr[i].name, key, sizeof(sh->attr[i].name) - 1);
+	    sh->attr[i].name[sizeof(sh->attr[i].name) - 1] = '\0';
 	    return i;
 	}
     }
     if (extend) {
 	i = sh->nattr;
 	ShapeSetAttrTable(sh, sh->nattr * 2);
-	strcpy(sh->attr[i].name, key);
+	strncpy(sh->attr[i].name, key, sizeof(sh->attr[i].name) - 1);
+	sh->attr[i].name[sizeof(sh->attr[i].name) - 1] = '\0';
 	return i;
     } else {
 	return -1;
     }
 }
 
+void shape_attrib_clear_value(attrib_t *attr)
+{
+    switch (attr->type) {
+	case -1:
+	case FTInteger:
+	case FTDouble:
+	    break;
+	default:
+	    xfree(attr->val.sval);
+	    break;
+    }
+    attr->type = -1;
+    memset(&attr->val, 0, sizeof(attr->val));
+}
+
 int shape_close(shape_t *shape)
 {
     if (shape->obj) {
@@ -569,18 +766,9 @@ int shape_close(shape_t *shape)
     if (shape->attr) {
 	int i;
 	for (i = 0; i < shape->nattr; i++) {
-	    switch (shape->attr[i].type) {
-		case FTInteger:
-		case FTDouble:
-		    break;
-		case FTString:
-		default:
-		    free(shape->attr[i].val.sval);
-		    shape->attr[i].val.ival = 0;
-		    break;
-	    }
+	    shape_attrib_clear_value(&shape->attr[i]);
 	}
-	free(shape->attr);
+	xfree(shape->attr);
 	shape->attr = NULL;
     }
     xfree(shape);

data/ext/shapelib_ext/shpplus.h

@@ -62,6 +62,7 @@ extern shape_t *shape_new_obj(int shapetype,
 	int n_parts, int *part_start, int *part_type, int n_vert,
 	double *x, double *y, double *m, double *z);
 extern int shape_close(shape_t *shape);
+extern void shape_attrib_clear_value(attrib_t *attr);
 extern int shape_attrib_index(shape_t *sh, const char *key, int extend);
 
 /*