rgeo 0.3.2 → 0.3.3

data/ext/geos_c_impl/geometry_collection.c

@@ -59,17 +59,31 @@ RGEO_BEGIN_C
 
 static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
 {
-  VALUE result = Qnil;
+  VALUE result;
+  unsigned int len;
+  GEOSGeometry** geoms;
+  RGeo_FactoryData* factory_data;
+  GEOSContextHandle_t geos_context;
+  VALUE klass;
+  unsigned int i;
+  unsigned int j;
+  VALUE klasses;
+  VALUE cast_type;
+  GEOSGeometry* geom;
+  GEOSGeometry* collection;
+  char problem;
+  GEOSGeometry* igeom;
+  GEOSGeometry* jgeom;
+
+  result = Qnil;
   Check_Type(array, T_ARRAY);
-  unsigned int len = (unsigned int)RARRAY_LEN(array);
-  GEOSGeometry** geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
+  len = (unsigned int)RARRAY_LEN(array);
+  geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
   if (geoms) {
-    RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(factory);
-    GEOSContextHandle_t geos_context = factory_data->geos_context;
-    VALUE klass;
-    unsigned int i,j;
-    VALUE klasses = Qnil;
-    VALUE cast_type = Qnil;
+    factory_data = RGEO_FACTORY_DATA_PTR(factory);
+    geos_context = factory_data->geos_context;
+    klasses = Qnil;
+    cast_type = Qnil;
     switch (type) {
     case GEOS_MULTIPOINT:
       cast_type = factory_data->globals->feature_point;
@@ -82,7 +96,7 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
       break;
     }
     for (i=0; i<len; ++i) {
-      GEOSGeometry* geom = rgeo_convert_to_detached_geos_geometry(rb_ary_entry(array, i), factory, cast_type, &klass);
+      geom = rgeo_convert_to_detached_geos_geometry(rb_ary_entry(array, i), factory, cast_type, &klass);
       if (!geom) {
         break;
       }
@@ -103,15 +117,15 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
       }
     }
     else {
-      GEOSGeometry* collection = GEOSGeom_createCollection_r(geos_context, type, geoms, len);
+      collection = GEOSGeom_createCollection_r(geos_context, type, geoms, len);
       // Due to a limitation of GEOS, the MultiPolygon assertions are not checked.
       // We do that manually here.
       if (collection && type == GEOS_MULTIPOLYGON && (factory_data->flags & 1) == 0) {
-        char problem = 0;
+        problem = 0;
         for (i=1; i<len; ++i) {
           for (j=0; j<i; ++j) {
-            GEOSGeometry* igeom = geoms[i];
-            GEOSGeometry* jgeom = geoms[j];
+            igeom = geoms[i];
+            jgeom = geoms[j];
             problem = GEOSRelatePattern_r(geos_context, igeom, jgeom, "2********");
             if (problem) {
               break;
@@ -151,9 +165,12 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
 
 static VALUE method_geometry_collection_eql(VALUE self, VALUE rhs)
 {
-  VALUE result = rgeo_geos_klasses_and_factories_eql(self, rhs);
+  VALUE result;
+  RGeo_GeometryData* self_data;
+
+  result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
-    RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+    self_data = RGEO_GEOMETRY_DATA_PTR(self);
     result = rgeo_geos_geometry_collections_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
   }
   return result;
@@ -162,8 +179,11 @@ static VALUE method_geometry_collection_eql(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_collection_geometry_type(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  VALUE result;
+  RGeo_GeometryData* self_data;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
     result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_geometry_collection;
   }
@@ -173,9 +193,13 @@ static VALUE method_geometry_collection_geometry_type(VALUE self)
 
 static VALUE method_geometry_collection_num_geometries(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     result = INT2NUM(GEOSGetNumGeometries_r(self_data->geos_context, self_geom));
   }
@@ -185,15 +209,22 @@ static VALUE method_geometry_collection_num_geometries(VALUE self)
 
 static VALUE impl_geometry_n(VALUE self, VALUE n, char allow_negatives)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE klasses;
+  int i;
+  int len;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    VALUE klasses = self_data->klasses;
-    int i = NUM2INT(n);
+    klasses = self_data->klasses;
+    i = NUM2INT(n);
     if (allow_negatives || i >= 0) {
       GEOSContextHandle_t self_context = self_data->geos_context;
-      int len = GEOSGetNumGeometries_r(self_context, self_geom);
+      len = GEOSGetNumGeometries_r(self_context, self_geom);
       if (i < 0) {
         i += len;
       }
@@ -210,29 +241,35 @@ static VALUE impl_geometry_n(VALUE self, VALUE n, char allow_negatives)
 
 static VALUE method_geometry_collection_geometry_n(VALUE self, VALUE n)
 {
-  impl_geometry_n(self, n, 0);
+  return impl_geometry_n(self, n, 0);
 }
 
 
 static VALUE method_geometry_collection_brackets(VALUE self, VALUE n)
 {
-  impl_geometry_n(self, n, 1);
+  return impl_geometry_n(self, n, 1);
 }
 
 
 static VALUE method_geometry_collection_each(VALUE self)
 {
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  int len;
+  VALUE klasses;
+  int i;
+  VALUE elem;
+  const GEOSGeometry* elem_geom;
+
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     GEOSContextHandle_t self_context = self_data->geos_context;
-    int len = GEOSGetNumGeometries_r(self_context, self_geom);
+    len = GEOSGetNumGeometries_r(self_context, self_geom);
     if (len > 0) {
-      VALUE klasses = self_data->klasses;
-      int i;
+      klasses = self_data->klasses;
       for (i=0; i<len; ++i) {
-        VALUE elem;
-        const GEOSGeometry* elem_geom = GEOSGetGeometryN_r(self_context, self_geom, i);
+        elem_geom = GEOSGetGeometryN_r(self_context, self_geom, i);
         elem = rgeo_wrap_geos_geometry_clone(self_data->factory, elem_geom, NIL_P(klasses) ? Qnil : rb_ary_entry(klasses, i));
         if (!NIL_P(elem)) {
           rb_yield(elem);
@@ -246,8 +283,11 @@ static VALUE method_geometry_collection_each(VALUE self)
 
 static VALUE method_multi_point_geometry_type(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  VALUE result;
+  RGeo_GeometryData* self_data;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
     result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_multi_point;
   }
@@ -257,8 +297,11 @@ static VALUE method_multi_point_geometry_type(VALUE self)
 
 static VALUE method_multi_line_string_geometry_type(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  VALUE result;
+  RGeo_GeometryData* self_data;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
     result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_multi_line_string;
   }
@@ -268,11 +311,15 @@ static VALUE method_multi_line_string_geometry_type(VALUE self)
 
 static VALUE method_multi_line_string_length(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  double len;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    double len;
     if (GEOSLength_r(self_data->geos_context, self_geom, &len)) {
       result = rb_float_new(len);
     }
@@ -283,17 +330,24 @@ static VALUE method_multi_line_string_length(VALUE self)
 
 static VALUE method_multi_line_string_is_closed(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSContextHandle_t self_context;
+  int len;
+  int i;
+  const GEOSGeometry* geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    GEOSContextHandle_t self_context = self_data->geos_context;
+    self_context = self_data->geos_context;
     result = Qtrue;
-    int len = GEOSGetNumGeometries_r(self_context, self_geom);
+    len = GEOSGetNumGeometries_r(self_context, self_geom);
     if (len > 0) {
-      int i;
       for (i=0; i<len; ++i) {
-        const GEOSGeometry* geom = GEOSGetGeometryN_r(self_context, self_geom, i);
+        geom = GEOSGetGeometryN_r(self_context, self_geom, i);
         if (geom) {
           result = rgeo_is_geos_line_string_closed(self_context, self_geom);
           if (result != Qtrue) {
@@ -309,8 +363,11 @@ static VALUE method_multi_line_string_is_closed(VALUE self)
 
 static VALUE method_multi_polygon_geometry_type(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  VALUE result;
+  RGeo_GeometryData* self_data;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
     result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_multi_polygon;
   }
@@ -320,11 +377,15 @@ static VALUE method_multi_polygon_geometry_type(VALUE self)
 
 static VALUE method_multi_polygon_area(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  double area;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    double area;
     if (GEOSArea_r(self_data->geos_context, self_geom, &area)) {
       result = rb_float_new(area);
     }
@@ -335,9 +396,13 @@ static VALUE method_multi_polygon_area(VALUE self)
 
 static VALUE method_multi_polygon_centroid(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     result = rgeo_wrap_geos_geometry(self_data->factory, GEOSGetCentroid_r(self_data->geos_context, self_geom), Qnil);
   }
@@ -347,9 +412,13 @@ static VALUE method_multi_polygon_centroid(VALUE self)
 
 static VALUE method_multi_polygon_point_on_surface(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     result = rgeo_wrap_geos_geometry(self_data->factory, GEOSPointOnSurface_r(self_data->geos_context, self_geom), Qnil);
   }
@@ -386,20 +455,25 @@ static VALUE cmethod_multi_polygon_create(VALUE module, VALUE factory, VALUE arr
 
 void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
 {
+  VALUE geos_geometry_collection_class;
+  VALUE geos_multi_point_class;
+  VALUE geos_multi_line_string_class;
+  VALUE geos_multi_polygon_class;
+
   // Create implementation classes
-  VALUE geos_geometry_collection_class = rb_define_class_under(globals->geos_module, "GeometryCollectionImpl", globals->geos_geometry);
+  geos_geometry_collection_class = rb_define_class_under(globals->geos_module, "GeometryCollectionImpl", globals->geos_geometry);
   globals->geos_geometry_collection = geos_geometry_collection_class;
   globals->feature_geometry_collection = rb_const_get_at(globals->feature_module, rb_intern("GeometryCollection"));
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
     globals->feature_geometry_collection, geos_geometry_collection_class);
   
-  VALUE geos_multi_point_class = rb_define_class_under(globals->geos_module, "MultiPointImpl", geos_geometry_collection_class);
+  geos_multi_point_class = rb_define_class_under(globals->geos_module, "MultiPointImpl", geos_geometry_collection_class);
   globals->geos_multi_point = geos_multi_point_class;
   globals->feature_multi_point = rb_const_get_at(globals->feature_module, rb_intern("MultiPoint"));
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
     globals->feature_multi_point, geos_multi_point_class);
   
-  VALUE geos_multi_line_string_class = rb_define_class_under(globals->geos_module, "MultiLineStringImpl", geos_geometry_collection_class);
+  geos_multi_line_string_class = rb_define_class_under(globals->geos_module, "MultiLineStringImpl", geos_geometry_collection_class);
   globals->geos_multi_line_string = geos_multi_line_string_class;
   globals->feature_multi_line_string = rb_const_get_at(globals->feature_module, rb_intern("MultiLineString"));
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
@@ -407,7 +481,7 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
     globals->feature_multi_line_string, geos_multi_line_string_class);
   
-  VALUE geos_multi_polygon_class = rb_define_class_under(globals->geos_module, "MultiPolygonImpl", geos_geometry_collection_class);
+  geos_multi_polygon_class = rb_define_class_under(globals->geos_module, "MultiPolygonImpl", geos_geometry_collection_class);
   globals->geos_multi_polygon = geos_multi_polygon_class;
   globals->feature_multi_polygon = rb_const_get_at(globals->feature_module, rb_intern("MultiPolygon"));
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
@@ -450,20 +524,28 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
 
 VALUE rgeo_geos_geometry_collections_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z)
 {
-  VALUE result = Qnil;
+  VALUE result;
+  int len1;
+  int len2;
+  int i;
+  const GEOSGeometry* sub_geom1;
+  const GEOSGeometry* sub_geom2;
+  int type1;
+  int type2;
+
+  result = Qnil;
   if (geom1 && geom2) {
-    int len1 = GEOSGetNumGeometries_r(context, geom1);
-    int len2 = GEOSGetNumGeometries_r(context, geom2);
+    len1 = GEOSGetNumGeometries_r(context, geom1);
+    len2 = GEOSGetNumGeometries_r(context, geom2);
     if (len1 >= 0 && len2 >= 0) {
       if (len1 == len2) {
         result = Qtrue;
-        int i;
         for (i=0; i<len1; ++i) {
-          const GEOSGeometry* sub_geom1 = GEOSGetGeometryN_r(context, geom1, i);
-          const GEOSGeometry* sub_geom2 = GEOSGetGeometryN_r(context, geom2, i);
+          sub_geom1 = GEOSGetGeometryN_r(context, geom1, i);
+          sub_geom2 = GEOSGetGeometryN_r(context, geom2, i);
           if (sub_geom1 && sub_geom2) {
-            int type1 = GEOSGeomTypeId_r(context, sub_geom1);
-            int type2 = GEOSGeomTypeId_r(context, sub_geom2);
+            type1 = GEOSGeomTypeId_r(context, sub_geom1);
+            type2 = GEOSGeomTypeId_r(context, sub_geom2);
             if (type1 >= 0 && type2 >= 0) {
               if (type1 == type2) {
                 switch (type1) {

data/ext/geos_c_impl/line_string.c

@@ -53,8 +53,11 @@ RGEO_BEGIN_C
 
 static VALUE method_line_string_geometry_type(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  VALUE result;
+  RGeo_GeometryData* self_data;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
     result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_line_string;
   }
@@ -64,8 +67,11 @@ static VALUE method_line_string_geometry_type(VALUE self)
 
 static VALUE method_linear_ring_geometry_type(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  VALUE result;
+  RGeo_GeometryData* self_data;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
     result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_linear_ring;
   }
@@ -75,8 +81,11 @@ static VALUE method_linear_ring_geometry_type(VALUE self)
 
 static VALUE method_line_geometry_type(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  VALUE result;
+  RGeo_GeometryData* self_data;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
     result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_line;
   }
@@ -86,11 +95,15 @@ static VALUE method_line_geometry_type(VALUE self)
 
 static VALUE method_line_string_length(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  double len;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    double len;
     if (GEOSLength_r(self_data->geos_context, self_geom, &len)) {
       result = rb_float_new(len);
     }
@@ -101,9 +114,13 @@ static VALUE method_line_string_length(VALUE self)
 
 static VALUE method_line_string_num_points(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     result = INT2NUM(GEOSGetNumCoordinates_r(self_data->geos_context, self_geom));
   }
@@ -113,10 +130,14 @@ static VALUE method_line_string_num_points(VALUE self)
 
 static VALUE get_point_from_coordseq(VALUE self, const GEOSCoordSequence* coord_seq, unsigned int i, char has_z)
 {
-  VALUE result = Qnil;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  GEOSContextHandle_t self_context;
   double x, y, z;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  GEOSContextHandle_t self_context = self_data->geos_context;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_context = self_data->geos_context;
   if (GEOSCoordSeq_getX_r(self_context, coord_seq, i, &x)) {
     if (GEOSCoordSeq_getY_r(self_context, coord_seq, i, &y)) {
       if (has_z) {
@@ -136,18 +157,27 @@ static VALUE get_point_from_coordseq(VALUE self, const GEOSCoordSequence* coord_
 
 static VALUE method_line_string_point_n(VALUE self, VALUE n)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSContextHandle_t self_context;
+  const GEOSCoordSequence* coord_seq;
+  char has_z;
+  int si;
+  unsigned int i;
+  unsigned int size;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    GEOSContextHandle_t self_context = self_data->geos_context;
-    const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(self_context, self_geom);
+    self_context = self_data->geos_context;
+    coord_seq = GEOSGeom_getCoordSeq_r(self_context, self_geom);
     if (coord_seq) {
-      char has_z = (char)(RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
-      int si = NUM2INT(n);
+      has_z = (char)(RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+      si = NUM2INT(n);
       if (si >= 0) {
-        unsigned int i = si;
-        unsigned int size;
+        i = si;
         if (GEOSCoordSeq_getSize_r(self_context, coord_seq, &size)) {
           if (i < size) {
             result = get_point_from_coordseq(self, coord_seq, i, has_z);
@@ -162,21 +192,31 @@ static VALUE method_line_string_point_n(VALUE self, VALUE n)
 
 static VALUE method_line_string_points(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSContextHandle_t self_context;
+  const GEOSCoordSequence* coord_seq;
+  char has_z;
+  unsigned int size;
+  double x;
+  double y;
+  double z;
+  unsigned int i;
+  VALUE point;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    GEOSContextHandle_t self_context = self_data->geos_context;
-    const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(self_context, self_geom);
+    self_context = self_data->geos_context;
+    coord_seq = GEOSGeom_getCoordSeq_r(self_context, self_geom);
     if (coord_seq) {
-      char has_z = (char)(RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
-      unsigned int size;
+      has_z = (char)(RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
       if (GEOSCoordSeq_getSize_r(self_context, coord_seq, &size)) {
         result = rb_ary_new2(size);
-        double x, y, z;
-        unsigned int i;
         for (i=0; i<size; ++i) {
-          VALUE point = get_point_from_coordseq(self, coord_seq, i, has_z);
+          point = get_point_from_coordseq(self, coord_seq, i, has_z);
           if (!NIL_P(point)) {
             rb_ary_store(result, i, point);
           }
@@ -196,11 +236,16 @@ static VALUE method_line_string_start_point(VALUE self)
 
 static VALUE method_line_string_end_point(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  unsigned int n;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    unsigned int n = GEOSGetNumCoordinates_r(self_data->geos_context, self_geom);
+    n = GEOSGetNumCoordinates_r(self_data->geos_context, self_geom);
     if (n > 0) {
       result = method_line_string_point_n(self, INT2NUM(n-1));
     }
@@ -211,9 +256,13 @@ static VALUE method_line_string_end_point(VALUE self)
 
 static VALUE method_line_string_is_closed(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     result = rgeo_is_geos_line_string_closed(self_data->geos_context, self_geom);
   }
@@ -223,11 +272,16 @@ static VALUE method_line_string_is_closed(VALUE self)
 
 static VALUE method_line_string_is_ring(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  char val;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    char val = GEOSisRing_r(self_data->geos_context, self_geom);
+    val = GEOSisRing_r(self_data->geos_context, self_geom);
     if (val == 0) {
       result = Qfalse;
     }
@@ -241,9 +295,12 @@ static VALUE method_line_string_is_ring(VALUE self)
 
 static VALUE method_line_string_eql(VALUE self, VALUE rhs)
 {
-  VALUE result = rgeo_geos_klasses_and_factories_eql(self, rhs);
+  VALUE result;
+  RGeo_GeometryData* self_data;
+
+  result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
-    RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+    self_data = RGEO_GEOMETRY_DATA_PTR(self);
     result = rgeo_geos_coordseqs_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
   }
   return result;
@@ -252,25 +309,37 @@ static VALUE method_line_string_eql(VALUE self, VALUE rhs)
 
 static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char close)
 {
+  RGeo_FactoryData* factory_data;
+  VALUE point_type;
+  unsigned int len;
+  char has_z;
+  unsigned int dims;
+  double* coords;
+  GEOSContextHandle_t context;
+  unsigned int i;
+  char good;
+  const GEOSGeometry* entry_geom;
+  const GEOSCoordSequence* entry_cs;
+  double x;
+  GEOSCoordSequence* coord_seq;
+
   Check_Type(array, T_ARRAY);
-  RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(factory);
-  VALUE point_type = factory_data->globals->feature_point;
-  unsigned int len = (unsigned int)RARRAY_LEN(array);
-  char has_z = (char)(RGEO_FACTORY_DATA_PTR(factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
-  unsigned int dims = has_z ? 3 : 2;
-  double* coords = ALLOC_N(double, len == 0 ? 1 : len * dims);
+  factory_data = RGEO_FACTORY_DATA_PTR(factory);
+  point_type = factory_data->globals->feature_point;
+  len = (unsigned int)RARRAY_LEN(array);
+  has_z = (char)(RGEO_FACTORY_DATA_PTR(factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+  dims = has_z ? 3 : 2;
+  coords = ALLOC_N(double, len == 0 ? 1 : len * dims);
   if (!coords) {
     return NULL;
   }
-  GEOSContextHandle_t context = factory_data->geos_context;
-  unsigned int i;
+  context = factory_data->geos_context;
   for (i=0; i<len; ++i) {
-    char good = 0;
-    const GEOSGeometry* entry_geom = rgeo_convert_to_geos_geometry(factory, rb_ary_entry(array, i), point_type);
+    good = 0;
+    entry_geom = rgeo_convert_to_geos_geometry(factory, rb_ary_entry(array, i), point_type);
     if (entry_geom) {
-      const GEOSCoordSequence* entry_cs = GEOSGeom_getCoordSeq_r(context, entry_geom);
+      entry_cs = GEOSGeom_getCoordSeq_r(context, entry_geom);
       if (entry_cs) {
-        double x;
         if (GEOSCoordSeq_getX_r(context, entry_cs, 0, &x)) {
           coords[i*dims] = x;
           if (GEOSCoordSeq_getY_r(context, entry_cs, 0, &x)) {
@@ -301,7 +370,7 @@ static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char
   else {
     close = 0;
   }
-  GEOSCoordSequence* coord_seq = GEOSCoordSeq_create_r(context, len + close, 3);
+  coord_seq = GEOSCoordSeq_create_r(context, len + close, 3);
   if (coord_seq) {
     for (i=0; i<len; ++i) {
       GEOSCoordSeq_setX_r(context, coord_seq, i, coords[i*dims]);
@@ -321,11 +390,16 @@ static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char
 
 static VALUE cmethod_create_line_string(VALUE module, VALUE factory, VALUE array)
 {
-  VALUE result = Qnil;
-  GEOSCoordSequence* coord_seq = coord_seq_from_array(factory, array, 0);
+  VALUE result;
+  GEOSCoordSequence* coord_seq;
+  RGeo_FactoryData* factory_data;
+  GEOSGeometry* geom;
+
+  result = Qnil;
+  coord_seq = coord_seq_from_array(factory, array, 0);
   if (coord_seq) {
-    RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(factory);
-    GEOSGeometry* geom = GEOSGeom_createLineString_r(factory_data->geos_context, coord_seq);
+    factory_data = RGEO_FACTORY_DATA_PTR(factory);
+    geom = GEOSGeom_createLineString_r(factory_data->geos_context, coord_seq);
     if (geom) {
       result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_line_string);
     }
@@ -336,11 +410,16 @@ static VALUE cmethod_create_line_string(VALUE module, VALUE factory, VALUE array
 
 static VALUE cmethod_create_linear_ring(VALUE module, VALUE factory, VALUE array)
 {
-  VALUE result = Qnil;
-  GEOSCoordSequence* coord_seq = coord_seq_from_array(factory, array, 1);
+  VALUE result;
+  GEOSCoordSequence* coord_seq;
+  RGeo_FactoryData* factory_data;
+  GEOSGeometry* geom;
+
+  result = Qnil;
+  coord_seq = coord_seq_from_array(factory, array, 1);
   if (coord_seq) {
-    RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(factory);
-    GEOSGeometry* geom = GEOSGeom_createLinearRing_r(factory_data->geos_context, coord_seq);
+    factory_data = RGEO_FACTORY_DATA_PTR(factory);
+    geom = GEOSGeom_createLinearRing_r(factory_data->geos_context, coord_seq);
     if (geom) {
       result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_linear_ring);
     }
@@ -351,8 +430,11 @@ static VALUE cmethod_create_linear_ring(VALUE module, VALUE factory, VALUE array
 
 static void populate_geom_into_coord_seq(GEOSContextHandle_t context, const GEOSGeometry* geom, GEOSCoordSequence* coord_seq, unsigned int i, char has_z)
 {
-  const GEOSCoordSequence* cs = GEOSGeom_getCoordSeq_r(context, geom);
-  double x = 0;
+  const GEOSCoordSequence* cs;
+  double x;
+
+  cs = GEOSGeom_getCoordSeq_r(context, geom);
+  x = 0;
   if (cs) {
     GEOSCoordSeq_getX_r(context, cs, 0, &x);
   }
@@ -372,21 +454,31 @@ static void populate_geom_into_coord_seq(GEOSContextHandle_t context, const GEOS
 
 static VALUE cmethod_create_line(VALUE module, VALUE factory, VALUE start, VALUE end)
 {
-  VALUE result = Qnil;
-  RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(factory);
-  char has_z = (char)(factory_data->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
-  VALUE point_type = factory_data->globals->feature_point;
-  GEOSContextHandle_t context = factory_data->geos_context;
+  VALUE result;
+  RGeo_FactoryData* factory_data;
+  char has_z;
+  VALUE point_type;
+  GEOSContextHandle_t context;
+  const GEOSGeometry* start_geom;
+  const GEOSGeometry* end_geom;
+  GEOSCoordSequence* coord_seq;
+  GEOSGeometry* geom;
+
+  result = Qnil;
+  factory_data = RGEO_FACTORY_DATA_PTR(factory);
+  has_z = (char)(factory_data->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+  point_type = factory_data->globals->feature_point;
+  context = factory_data->geos_context;
   
-  const GEOSGeometry* start_geom = rgeo_convert_to_geos_geometry(factory, start, point_type);
+  start_geom = rgeo_convert_to_geos_geometry(factory, start, point_type);
   if (start_geom) {
-    const GEOSGeometry* end_geom = rgeo_convert_to_geos_geometry(factory, end, point_type);
+    end_geom = rgeo_convert_to_geos_geometry(factory, end, point_type);
     if (end_geom) {
-      GEOSCoordSequence* coord_seq = GEOSCoordSeq_create_r(context, 2, 3);
+      coord_seq = GEOSCoordSeq_create_r(context, 2, 3);
       if (coord_seq) {
         populate_geom_into_coord_seq(context, start_geom, coord_seq, 0, has_z);
         populate_geom_into_coord_seq(context, end_geom, coord_seq, 1, has_z);
-        GEOSGeometry* geom = GEOSGeom_createLineString_r(context, coord_seq);
+        geom = GEOSGeom_createLineString_r(context, coord_seq);
         if (geom) {
           result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_line);
         }
@@ -400,19 +492,26 @@ static VALUE cmethod_create_line(VALUE module, VALUE factory, VALUE start, VALUE
 
 static VALUE impl_copy_from(VALUE klass, VALUE factory, VALUE original, char subtype)
 {
-  VALUE result = Qnil;
-  const GEOSGeometry* original_geom = RGEO_GEOMETRY_DATA_PTR(original)->geom;
+  VALUE result;
+  const GEOSGeometry* original_geom;
+  GEOSContextHandle_t context;
+  const GEOSCoordSequence* original_coord_seq;
+  GEOSCoordSequence* coord_seq;
+  GEOSGeometry* geom;
+
+  result = Qnil;
+  original_geom = RGEO_GEOMETRY_DATA_PTR(original)->geom;
   if (original_geom) {
-    GEOSContextHandle_t context = RGEO_FACTORY_DATA_PTR(factory)->geos_context;
+    context = RGEO_FACTORY_DATA_PTR(factory)->geos_context;
     if (subtype == 1 && GEOSGetNumCoordinates_r(context, original_geom) != 2) {
       original_geom = NULL;
     }
     if (original_geom) {
-      const GEOSCoordSequence* original_coord_seq = GEOSGeom_getCoordSeq_r(context, original_geom);
+      original_coord_seq = GEOSGeom_getCoordSeq_r(context, original_geom);
       if (original_coord_seq) {
-        GEOSCoordSequence* coord_seq = GEOSCoordSeq_clone_r(context, original_coord_seq);
+        coord_seq = GEOSCoordSeq_clone_r(context, original_coord_seq);
         if (coord_seq) {
-          GEOSGeometry* geom = subtype == 2 ? GEOSGeom_createLinearRing_r(context, coord_seq) : GEOSGeom_createLineString_r(context, coord_seq);
+          geom = subtype == 2 ? GEOSGeom_createLinearRing_r(context, coord_seq) : GEOSGeom_createLineString_r(context, coord_seq);
           if (geom) {
             result = rgeo_wrap_geos_geometry(factory, geom, klass);
           }
@@ -444,7 +543,11 @@ static VALUE cmethod_linear_ring_copy_from(VALUE klass, VALUE factory, VALUE ori
 
 void rgeo_init_geos_line_string(RGeo_Globals* globals)
 {
-  VALUE geos_line_string_class = rb_define_class_under(globals->geos_module, "LineStringImpl", globals->geos_geometry);
+  VALUE geos_line_string_class;
+  VALUE geos_linear_ring_class;
+  VALUE geos_line_class;
+
+  geos_line_string_class = rb_define_class_under(globals->geos_module, "LineStringImpl", globals->geos_geometry);
   globals->geos_line_string = geos_line_string_class;
   globals->feature_line_string = rb_const_get_at(globals->feature_module, rb_intern("LineString"));
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
@@ -452,13 +555,13 @@ void rgeo_init_geos_line_string(RGeo_Globals* globals)
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
     globals->feature_line_string, geos_line_string_class);
   
-  VALUE geos_linear_ring_class = rb_define_class_under(globals->geos_module, "LinearRingImpl", geos_line_string_class);
+  geos_linear_ring_class = rb_define_class_under(globals->geos_module, "LinearRingImpl", geos_line_string_class);
   globals->geos_linear_ring = geos_linear_ring_class;
   globals->feature_linear_ring = rb_const_get_at(globals->feature_module, rb_intern("LinearRing"));
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
     globals->feature_linear_ring, geos_linear_ring_class);
   
-  VALUE geos_line_class = rb_define_class_under(globals->geos_module, "LineImpl", geos_line_string_class);
+  geos_line_class = rb_define_class_under(globals->geos_module, "LineImpl", geos_line_string_class);
   globals->geos_line = geos_line_class;
   globals->feature_line = rb_const_get_at(globals->feature_module, rb_intern("Line"));
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
@@ -489,11 +592,15 @@ void rgeo_init_geos_line_string(RGeo_Globals* globals)
 
 VALUE rgeo_is_geos_line_string_closed(GEOSContextHandle_t context, const GEOSGeometry* geom)
 {
-  char result = Qnil;
-  unsigned int n = GEOSGetNumCoordinates_r(context, geom);
+  VALUE result;
+  unsigned int n;
+  double x1, x2, y1, y2, z1, z2;
+  const GEOSCoordSequence* coord_seq;
+
+  result = Qnil;
+  n = GEOSGetNumCoordinates_r(context, geom);
   if (n > 0) {
-    double x1, x2, y1, y2, z1, z2;
-    const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(context, geom);
+    coord_seq = GEOSGeom_getCoordSeq_r(context, geom);
     if (GEOSCoordSeq_getX_r(context, coord_seq, 0, &x1)) {
       if (GEOSCoordSeq_getX_r(context, coord_seq, n-1, &x2)) {
         if (x1 == x2) {