php/geos.c

   1 /***********************************************************************
   2  *
   3  *    GEOS - Geometry Engine Open Source
   4  *    http://trac.osgeo.org/geos
   5  *
   6  *    Copyright (C) 2010 Sandro Santilli <strk@keybit.net>
   7  *
   8  *    This library is free software; you can redistribute it and/or
   9  *    modify it under the terms of the GNU Lesser General Public
  10  *    License as published by the Free Software Foundation; either
  11  *    version 2.1 of the License, or (at your option) any later version.
  12  *
  13  *    This library is distributed in the hope that it will be useful,
  14  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *    Lesser General Public License for more details.
  17  *
  18  *    You should have received a copy of the GNU General Public License
  19  *    along with this program; if not, write to the Free Software
  20  *    Foundation, Inc., 51 Franklin St, Fifth Floor,
  21  *    Boston, MA  02110-1301  USA
  22  *
  23  ***********************************************************************/
  24
  25 /* PHP stuff */
  26 #include "php.h"
  27 #include "ext/standard/info.h" /* for php_info_... */
  28 #include "Zend/zend_exceptions.h" /* for zend_throw_exception_object */
  29
  30 /* GEOS stuff */
  31 #include "geos_c.h"
  32
  33 /* Own stuff */
  34 #include "php_geos.h"
  35
  36 PHP_MINIT_FUNCTION(geos);
  37 PHP_MSHUTDOWN_FUNCTION(geos);
  38 PHP_RINIT_FUNCTION(geos);
  39 PHP_RSHUTDOWN_FUNCTION(geos);
  40 PHP_MINFO_FUNCTION(geos);
  41 PHP_FUNCTION(GEOSVersion);
  42 PHP_FUNCTION(GEOSPolygonize);
  43 PHP_FUNCTION(GEOSLineMerge);
  44 PHP_FUNCTION(GEOSSharedPaths);
  45 PHP_FUNCTION(GEOSRelateMatch);
  46
  47 static function_entry geos_functions[] = {
  48     PHP_FE(GEOSVersion, NULL)
  49     PHP_FE(GEOSPolygonize, NULL)
  50     PHP_FE(GEOSLineMerge, NULL)
  51     PHP_FE(GEOSSharedPaths, NULL)
  52     PHP_FE(GEOSRelateMatch, NULL)
  53     {NULL, NULL, NULL}
  54 };
  55
  56 zend_module_entry geos_module_entry = {
  57     STANDARD_MODULE_HEADER,
  58     PHP_GEOS_EXTNAME,
  59     geos_functions,
  60     PHP_MINIT(geos),              /* module init function */
  61     PHP_MSHUTDOWN(geos),          /* module shutdown function */
  62     PHP_RINIT(geos),              /* request init function */
  63     PHP_RSHUTDOWN(geos),          /* request shutdown function */
  64     PHP_MINFO(geos),              /* module info function */
  65     PHP_GEOS_VERSION,
  66     STANDARD_MODULE_PROPERTIES
  67 };
  68
  69 #ifdef COMPILE_DL_GEOS
  70 ZEND_GET_MODULE(geos)
  71 #endif
  72
  73 /* -- Utility functions ---------------------- */
  74
  75 static void noticeHandler(const char *fmt, ...)
  76 {
  77     char message[256];
  78     va_list args;
  79     va_start(args, fmt);
  80     vsnprintf(message, sizeof(message) - 1, fmt, args);
  81     va_end(args);
  82
  83     php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s", message);
  84 }
  85
  86 static void errorHandler(const char *fmt, ...)
  87 {
  88     char message[256];
  89     va_list args;
  90     va_start(args, fmt);
  91     vsnprintf(message, sizeof(message) - 1, fmt, args);
  92     va_end(args);
  93
  94     /* TODO: use a GEOSException ? */
  95     zend_throw_exception_ex(zend_exception_get_default(TSRMLS_CC),
  96         1 TSRMLS_CC, "%s", message);
  97
  98 }
  99
 100 typedef struct Proxy_t {
 101     zend_object std;
 102     void* relay;
 103 } Proxy;
 104
 105 static void
 106 setRelay(zval* val, void* obj) {
 107     Proxy* proxy = (Proxy*)zend_object_store_get_object(val TSRMLS_CC);
 108     proxy->relay = obj;
 109 }
 110
 111 static inline void *
 112 getRelay(zval* val, zend_class_entry* ce) {
 113     Proxy *proxy =  (Proxy*)zend_object_store_get_object(val TSRMLS_CC);
 114     if ( proxy->std.ce != ce ) {
 115         php_error_docref(NULL TSRMLS_CC, E_ERROR,
 116             "Relay object is not an %s", ce->name);
 117     }
 118     if ( ! proxy->relay ) {
 119         php_error_docref(NULL TSRMLS_CC, E_ERROR,
 120             "Relay object for object of type %s is not set", ce->name);
 121     }
 122     return proxy->relay;
 123 }
 124
 125 static long getZvalAsLong(zval* val)
 126 {
 127     long ret;
 128     zval tmp;
 129
 130     tmp = *val;
 131     zval_copy_ctor(&tmp);
 132     convert_to_long(&tmp);
 133     ret = Z_LVAL(tmp);
 134     zval_dtor(&tmp);
 135     return ret;
 136 }
 137
 138 static long getZvalAsDouble(zval* val)
 139 {
 140     double ret;
 141     zval tmp;
 142
 143     tmp = *val;
 144     zval_copy_ctor(&tmp);
 145     convert_to_double(&tmp);
 146     ret = Z_DVAL(tmp);
 147     zval_dtor(&tmp);
 148     return ret;
 149 }
 150
 151 static zend_object_value
 152 Gen_create_obj (zend_class_entry *type TSRMLS_DC,
 153     zend_objects_free_object_storage_t st, zend_object_handlers* handlers)
 154 {
 155     zval *tmp;
 156     zend_object_value retval;
 157
 158     Proxy *obj = (Proxy *)emalloc(sizeof(Proxy));
 159     memset(obj, 0, sizeof(Proxy));
 160     obj->std.ce = type;
 161
 162     ALLOC_HASHTABLE(obj->std.properties);
 163     zend_hash_init(obj->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
 164     zend_hash_copy(obj->std.properties, &type->default_properties,
 165         (copy_ctor_func_t)zval_add_ref, (void *)&tmp, sizeof(zval *));
 166
 167     retval.handle = zend_objects_store_put(obj, NULL, st, NULL TSRMLS_CC);
 168     retval.handlers = handlers;
 169
 170     return retval;
 171 }
 172
 173
 174 /* -- class GEOSGeometry -------------------- */
 175
 176 PHP_METHOD(Geometry, __construct);
 177 PHP_METHOD(Geometry, __toString);
 178 PHP_METHOD(Geometry, project);
 179 PHP_METHOD(Geometry, interpolate);
 180 PHP_METHOD(Geometry, buffer);
 181 PHP_METHOD(Geometry, offsetCurve);
 182 PHP_METHOD(Geometry, envelope);
 183 PHP_METHOD(Geometry, intersection);
 184 PHP_METHOD(Geometry, convexHull);
 185 PHP_METHOD(Geometry, difference);
 186 PHP_METHOD(Geometry, symDifference);
 187 PHP_METHOD(Geometry, boundary);
 188 PHP_METHOD(Geometry, union); /* also does union cascaded */
 189 PHP_METHOD(Geometry, pointOnSurface);
 190 PHP_METHOD(Geometry, centroid);
 191 PHP_METHOD(Geometry, relate);
 192 PHP_METHOD(Geometry, relateBoundaryNodeRule);
 193 PHP_METHOD(Geometry, simplify); /* also does topology-preserving */
 194 PHP_METHOD(Geometry, extractUniquePoints);
 195 PHP_METHOD(Geometry, disjoint);
 196 PHP_METHOD(Geometry, touches);
 197 PHP_METHOD(Geometry, intersects);
 198 PHP_METHOD(Geometry, crosses);
 199 PHP_METHOD(Geometry, within);
 200 PHP_METHOD(Geometry, contains);
 201 PHP_METHOD(Geometry, overlaps);
 202 PHP_METHOD(Geometry, covers);
 203 PHP_METHOD(Geometry, coveredBy);
 204 PHP_METHOD(Geometry, equals);
 205 PHP_METHOD(Geometry, equalsExact);
 206 PHP_METHOD(Geometry, isEmpty);
 207 PHP_METHOD(Geometry, checkValidity);
 208 PHP_METHOD(Geometry, isSimple);
 209 PHP_METHOD(Geometry, isRing);
 210 PHP_METHOD(Geometry, hasZ);
 211 PHP_METHOD(Geometry, isClosed);
 212 PHP_METHOD(Geometry, typeName);
 213 PHP_METHOD(Geometry, typeId);
 214 PHP_METHOD(Geometry, getSRID);
 215 PHP_METHOD(Geometry, setSRID);
 216 PHP_METHOD(Geometry, numGeometries);
 217 PHP_METHOD(Geometry, geometryN);
 218 PHP_METHOD(Geometry, numInteriorRings);
 219 PHP_METHOD(Geometry, numPoints);
 220 PHP_METHOD(Geometry, getX);
 221 PHP_METHOD(Geometry, getY);
 222 PHP_METHOD(Geometry, interiorRingN);
 223 PHP_METHOD(Geometry, exteriorRing);
 224 PHP_METHOD(Geometry, numCoordinates);
 225 PHP_METHOD(Geometry, dimension);
 226 PHP_METHOD(Geometry, coordinateDimension);
 227 PHP_METHOD(Geometry, pointN);
 228 PHP_METHOD(Geometry, startPoint);
 229 PHP_METHOD(Geometry, endPoint);
 230 PHP_METHOD(Geometry, area);
 231 PHP_METHOD(Geometry, length);
 232 PHP_METHOD(Geometry, distance);
 233 PHP_METHOD(Geometry, hausdorffDistance);
 234 PHP_METHOD(Geometry, snapTo);
 235
 236 static function_entry Geometry_methods[] = {
 237     PHP_ME(Geometry, __construct, NULL, 0)
 238     PHP_ME(Geometry, __toString, NULL, 0)
 239     PHP_ME(Geometry, project, NULL, 0)
 240     PHP_ME(Geometry, interpolate, NULL, 0)
 241     PHP_ME(Geometry, buffer, NULL, 0)
 242     PHP_ME(Geometry, offsetCurve, NULL, 0)
 243     PHP_ME(Geometry, envelope, NULL, 0)
 244     PHP_ME(Geometry, intersection, NULL, 0)
 245     PHP_ME(Geometry, convexHull, NULL, 0)
 246     PHP_ME(Geometry, difference, NULL, 0)
 247     PHP_ME(Geometry, symDifference, NULL, 0)
 248     PHP_ME(Geometry, boundary, NULL, 0)
 249     PHP_ME(Geometry, union, NULL, 0)
 250     PHP_ME(Geometry, pointOnSurface, NULL, 0)
 251     PHP_ME(Geometry, centroid, NULL, 0)
 252     PHP_ME(Geometry, relate, NULL, 0)
 253     PHP_ME(Geometry, relateBoundaryNodeRule, NULL, 0)
 254     PHP_ME(Geometry, simplify, NULL, 0)
 255     PHP_ME(Geometry, extractUniquePoints, NULL, 0)
 256     PHP_ME(Geometry, disjoint, NULL, 0)
 257     PHP_ME(Geometry, touches, NULL, 0)
 258     PHP_ME(Geometry, intersects, NULL, 0)
 259     PHP_ME(Geometry, crosses, NULL, 0)
 260     PHP_ME(Geometry, within, NULL, 0)
 261     PHP_ME(Geometry, contains, NULL, 0)
 262     PHP_ME(Geometry, overlaps, NULL, 0)
 263     PHP_ME(Geometry, covers, NULL, 0)
 264     PHP_ME(Geometry, coveredBy, NULL, 0)
 265     PHP_ME(Geometry, equals, NULL, 0)
 266     PHP_ME(Geometry, equalsExact, NULL, 0)
 267     PHP_ME(Geometry, isEmpty, NULL, 0)
 268     PHP_ME(Geometry, checkValidity, NULL, 0)
 269     PHP_ME(Geometry, isSimple, NULL, 0)
 270     PHP_ME(Geometry, isRing, NULL, 0)
 271     PHP_ME(Geometry, hasZ, NULL, 0)
 272     PHP_ME(Geometry, isClosed, NULL, 0)
 273     PHP_ME(Geometry, typeName, NULL, 0)
 274     PHP_ME(Geometry, typeId, NULL, 0)
 275     PHP_ME(Geometry, getSRID, NULL, 0)
 276     PHP_ME(Geometry, setSRID, NULL, 0)
 277     PHP_ME(Geometry, numGeometries, NULL, 0)
 278     PHP_ME(Geometry, geometryN, NULL, 0)
 279     PHP_ME(Geometry, numInteriorRings, NULL, 0)
 280     PHP_ME(Geometry, numPoints, NULL, 0)
 281     PHP_ME(Geometry, getX, NULL, 0)
 282     PHP_ME(Geometry, getY, NULL, 0)
 283     PHP_ME(Geometry, interiorRingN, NULL, 0)
 284     PHP_ME(Geometry, exteriorRing, NULL, 0)
 285     PHP_ME(Geometry, numCoordinates, NULL, 0)
 286     PHP_ME(Geometry, dimension, NULL, 0)
 287     PHP_ME(Geometry, coordinateDimension, NULL, 0)
 288     PHP_ME(Geometry, pointN, NULL, 0)
 289     PHP_ME(Geometry, startPoint, NULL, 0)
 290     PHP_ME(Geometry, endPoint, NULL, 0)
 291     PHP_ME(Geometry, area, NULL, 0)
 292     PHP_ME(Geometry, length, NULL, 0)
 293     PHP_ME(Geometry, distance, NULL, 0)
 294     PHP_ME(Geometry, hausdorffDistance, NULL, 0)
 295     PHP_ME(Geometry, snapTo, NULL, 0)
 296     {NULL, NULL, NULL}
 297 };
 298
 299 static zend_class_entry *Geometry_ce_ptr;
 300
 301 static zend_object_handlers Geometry_object_handlers;
 302
 303 /* Geometry serializer */
 304
 305 static GEOSWKBWriter* Geometry_serializer = 0;
 306
 307 static GEOSWKBWriter* getGeometrySerializer()
 308 {
 309     if ( ! Geometry_serializer ) {
 310         Geometry_serializer = GEOSWKBWriter_create();
 311         GEOSWKBWriter_setIncludeSRID(Geometry_serializer, 1);
 312         GEOSWKBWriter_setOutputDimension(Geometry_serializer, 3);
 313     }
 314     return Geometry_serializer;
 315 }
 316
 317 static void delGeometrySerializer()
 318 {
 319     if ( Geometry_serializer ) {
 320         GEOSWKBWriter_destroy(Geometry_serializer);
 321     }
 322 }
 323
 324 /* Geometry deserializer */
 325
 326 static GEOSWKBReader* Geometry_deserializer = 0;
 327
 328 static GEOSWKBReader* getGeometryDeserializer()
 329 {
 330     if ( ! Geometry_deserializer ) {
 331         Geometry_deserializer = GEOSWKBReader_create();
 332     }
 333     return Geometry_deserializer;
 334 }
 335
 336 static void delGeometryDeserializer()
 337 {
 338     if ( Geometry_deserializer ) {
 339         GEOSWKBReader_destroy(Geometry_deserializer);
 340     }
 341 }
 342
 343 /* Serializer function for GEOSGeometry */
 344
 345 static int
 346 Geometry_serialize(zval *object, unsigned char **buffer, zend_uint *buf_len,
 347         zend_serialize_data *data TSRMLS_DC)
 348 {
 349     GEOSWKBWriter *serializer;
 350     GEOSGeometry *geom;
 351     char* ret;
 352     size_t retsize;
 353
 354
 355     serializer = getGeometrySerializer();
 356     geom = (GEOSGeometry*)getRelay(object, Geometry_ce_ptr);
 357
 358     /* NOTE: we might be fine using binary here */
 359     ret = (char*)GEOSWKBWriter_writeHEX(serializer, geom, &retsize);
 360     /* we'll probably get an exception if ret is null */
 361     if ( ! ret ) return FAILURE;
 362
 363     *buffer = (unsigned char*)estrndup(ret, retsize);
 364     GEOSFree(ret);
 365
 366     *buf_len = retsize;
 367
 368     return SUCCESS;
 369 }
 370
 371 static int
 372 Geometry_deserialize(zval **object, zend_class_entry *ce, const unsigned char *buf,
 373         zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC)
 374 {
 375     GEOSWKBReader* deserializer;
 376     GEOSGeometry* geom;
 377
 378     deserializer = getGeometryDeserializer();
 379     geom = GEOSWKBReader_readHEX(deserializer, buf, buf_len);
 380
 381     /* TODO: check zend_class_entry being what we expect! */
 382     if ( ce != Geometry_ce_ptr ) {
 383         php_error_docref(NULL TSRMLS_CC, E_ERROR,
 384                 "Geometry_deserialize called with unexpected zend_class_entry");
 385         return FAILURE;
 386     }
 387     object_init_ex(*object, ce);
 388     setRelay(*object, geom);
 389
 390     return SUCCESS;
 391 }
 392
 393 /*
 394  * Push components of the given geometry
 395  * to the given array zval.
 396  * Components geometries are cloned.
 397  * NOTE: collection components are not descended into
 398  */
 399 static void
 400 dumpGeometry(GEOSGeometry* g, zval* array)
 401 {
 402     int ngeoms, i;
 403
 404     /*
 405     MAKE_STD_ZVAL(array);
 406     array_init(array);
 407     */
 408
 409     ngeoms = GEOSGetNumGeometries(g);
 410     for (i=0; i<ngeoms; ++i)
 411     {
 412         zval *tmp;
 413         GEOSGeometry* cc;
 414         const GEOSGeometry* c = GEOSGetGeometryN(g, i);
 415         if ( ! c ) continue; /* should get an exception */
 416         /* we _need_ to clone as this one is owned by 'g' */
 417         cc = GEOSGeom_clone(c);
 418         if ( ! cc ) continue; /* should get an exception */
 419
 420         MAKE_STD_ZVAL(tmp);
 421         object_init_ex(tmp, Geometry_ce_ptr);
 422         setRelay(tmp, cc);
 423         add_next_index_zval(array, tmp);
 424     }
 425 }
 426
 427
 428 static void
 429 Geometry_dtor (void *object TSRMLS_DC)
 430 {
 431     Proxy *obj = (Proxy *)object;
 432     GEOSGeom_destroy((GEOSGeometry*)obj->relay);
 433
 434     zend_hash_destroy(obj->std.properties);
 435     FREE_HASHTABLE(obj->std.properties);
 436
 437     efree(obj);
 438 }
 439
 440 static zend_object_value
 441 Geometry_create_obj (zend_class_entry *type TSRMLS_DC)
 442 {
 443     return Gen_create_obj(type, Geometry_dtor, &Geometry_object_handlers);
 444 }
 445
 446
 447 PHP_METHOD(Geometry, __construct)
 448 {
 449     php_error_docref(NULL TSRMLS_CC, E_ERROR,
 450             "GEOSGeometry can't be constructed using new, check WKTReader");
 451
 452 }
 453
 454 PHP_METHOD(Geometry, __toString)
 455 {
 456     GEOSGeometry *geom;
 457     GEOSWKTWriter *writer;
 458     char *wkt;
 459     char *ret;
 460
 461     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 462     writer = GEOSWKTWriter_create();
 463     /* NOTE: if we get an exception before reaching
 464      *       GEOSWKTWriter_destory below we'll be leaking memory.
 465      *       One fix could be storing the object in a refcounted
 466      *       zval.
 467      */
 468     GEOSWKTWriter_setTrim(writer, 1);
 469
 470     wkt = GEOSWKTWriter_write(writer, geom);
 471     /* we'll probably get an exception if wkt is null */
 472     if ( ! wkt ) RETURN_NULL();
 473
 474     GEOSWKTWriter_destroy(writer);
 475
 476
 477     ret = estrdup(wkt);
 478     GEOSFree(wkt);
 479
 480     RETURN_STRING(ret, 0);
 481 }
 482
 483 PHP_METHOD(Geometry, project)
 484 {
 485     GEOSGeometry *this;
 486     GEOSGeometry *other;
 487     zval *zobj;
 488     zend_bool normalized = 0;
 489     double ret;
 490
 491     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 492
 493     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|b", &zobj,
 494             &normalized) == FAILURE) {
 495         RETURN_NULL();
 496     }
 497     other = getRelay(zobj, Geometry_ce_ptr);
 498
 499     if ( normalized ) {
 500         ret = GEOSProjectNormalized(this, other);
 501     } else {
 502         ret = GEOSProject(this, other);
 503     }
 504     if ( ret < 0 ) RETURN_NULL(); /* should get an exception first */
 505
 506     RETURN_DOUBLE(ret);
 507 }
 508
 509 PHP_METHOD(Geometry, interpolate)
 510 {
 511     GEOSGeometry *this;
 512     double dist;
 513     GEOSGeometry *ret;
 514     zend_bool normalized = 0;
 515
 516     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 517
 518     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d|b",
 519             &dist, &normalized) == FAILURE) {
 520         RETURN_NULL();
 521     }
 522
 523     if ( normalized ) {
 524         ret = GEOSInterpolateNormalized(this, dist);
 525     } else {
 526         ret = GEOSInterpolate(this, dist);
 527     }
 528     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
 529
 530     /* return_value is a zval */
 531     object_init_ex(return_value, Geometry_ce_ptr);
 532     setRelay(return_value, ret);
 533 }
 534
 535 /**
 536  * GEOSGeometry::buffer(dist, [<styleArray>])
 537  *
 538  * styleArray keys supported:
 539  *  'quad_segs'
 540  *       Type: int
 541  *       Number of segments used to approximate
 542  *       a quarter circle (defaults to 8).
 543  *  'endcap'
 544  *       Type: long
 545  *       Endcap style (defaults to GEOSBUF_CAP_ROUND)
 546  *  'join'
 547  *       Type: long
 548  *       Join style (defaults to GEOSBUF_JOIN_ROUND)
 549  *  'mitre_limit'
 550  *       Type: double
 551  *       mitre ratio limit (only affects joins with GEOSBUF_JOIN_MITRE style)
 552  *       'miter_limit' is also accepted as a synonym for 'mitre_limit'.
 553  *  'single_sided'
 554  *       Type: bool
 555  *       If true buffer lines only on one side, so that the input line
 556  *       will be a portion of the boundary of the returned polygon.
 557  *       Only applies to lineal input. Defaults to false.
 558  */
 559 PHP_METHOD(Geometry, buffer)
 560 {
 561     GEOSGeometry *this;
 562     double dist;
 563     GEOSGeometry *ret;
 564     GEOSBufferParams *params;
 565     static const double default_mitreLimit = 5.0;
 566     static const int default_endCapStyle = GEOSBUF_CAP_ROUND;
 567     static const int default_joinStyle = GEOSBUF_JOIN_ROUND;
 568     static const int default_quadSegs = 8;
 569     long int quadSegs = default_quadSegs;
 570     long int endCapStyle = default_endCapStyle;
 571     long int joinStyle = default_joinStyle;
 572     double mitreLimit = default_mitreLimit;
 573     long singleSided = 0;
 574     zval *style_val = NULL;
 575     zval **data;
 576     HashTable *style;
 577     char *key;
 578     ulong index;
 579
 580     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 581
 582     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d|a",
 583             &dist, &style_val) == FAILURE) {
 584         RETURN_NULL();
 585     }
 586
 587     params = GEOSBufferParams_create();
 588
 589     if ( style_val )
 590     {
 591         style = HASH_OF(style_val);
 592         while(zend_hash_get_current_key(style, &key, &index, 0)
 593               == HASH_KEY_IS_STRING)
 594         {
 595             if(!strcmp(key, "quad_segs"))
 596             {
 597                 zend_hash_get_current_data(style, (void**)&data);
 598                 quadSegs = getZvalAsLong(*data);
 599                 GEOSBufferParams_setQuadrantSegments(params, quadSegs);
 600             }
 601             else if(!strcmp(key, "endcap"))
 602             {
 603                 zend_hash_get_current_data(style, (void**)&data);
 604                 endCapStyle = getZvalAsLong(*data);
 605                 GEOSBufferParams_setEndCapStyle(params, endCapStyle);
 606             }
 607             else if(!strcmp(key, "join"))
 608             {
 609                 zend_hash_get_current_data(style, (void**)&data);
 610                 joinStyle = getZvalAsLong(*data);
 611                 GEOSBufferParams_setJoinStyle(params, joinStyle);
 612             }
 613             else if(!strcmp(key, "mitre_limit"))
 614             {
 615                 zend_hash_get_current_data(style, (void**)&data);
 616                 mitreLimit = getZvalAsDouble(*data);
 617                 GEOSBufferParams_setMitreLimit(params, mitreLimit);
 618             }
 619             else if(!strcmp(key, "single_sided"))
 620             {
 621                 zend_hash_get_current_data(style, (void**)&data);
 622                 singleSided = getZvalAsLong(*data);
 623                 GEOSBufferParams_setSingleSided(params, singleSided);
 624             }
 625
 626             zend_hash_move_forward(style);
 627         }
 628     }
 629
 630     ret = GEOSBufferWithParams(this, params, dist);
 631     GEOSBufferParams_destroy(params);
 632     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
 633
 634     /* return_value is a zval */
 635     object_init_ex(return_value, Geometry_ce_ptr);
 636     setRelay(return_value, ret);
 637 }
 638
 639 /**
 640  * GEOSGeometry::offsetCurve(dist, [<styleArray>])
 641  *
 642  * styleArray keys supported:
 643  *  'quad_segs'
 644  *       Type: int
 645  *       Number of segments used to approximate
 646  *       a quarter circle (defaults to 8).
 647  *  'join'
 648  *       Type: long
 649  *       Join style (defaults to GEOSBUF_JOIN_ROUND)
 650  *  'mitre_limit'
 651  *       Type: double
 652  *       mitre ratio limit (only affects joins with GEOSBUF_JOIN_MITRE style)
 653  *       'miter_limit' is also accepted as a synonym for 'mitre_limit'.
 654  */
 655 PHP_METHOD(Geometry, offsetCurve)
 656 {
 657     GEOSGeometry *this;
 658     double dist;
 659     GEOSGeometry *ret;
 660     static const double default_mitreLimit = 5.0;
 661     static const int default_joinStyle = GEOSBUF_JOIN_ROUND;
 662     static const int default_quadSegs = 8;
 663     long int quadSegs = default_quadSegs;
 664     long int joinStyle = default_joinStyle;
 665     double mitreLimit = default_mitreLimit;
 666     zval *style_val = NULL;
 667     zval **data;
 668     HashTable *style;
 669     char *key;
 670     ulong index;
 671
 672     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 673
 674     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d|a",
 675             &dist, &style_val) == FAILURE) {
 676         RETURN_NULL();
 677     }
 678
 679     if ( style_val )
 680     {
 681         style = HASH_OF(style_val);
 682         while(zend_hash_get_current_key(style, &key, &index, 0)
 683               == HASH_KEY_IS_STRING)
 684         {
 685             if(!strcmp(key, "quad_segs"))
 686             {
 687                 zend_hash_get_current_data(style, (void**)&data);
 688                 quadSegs = getZvalAsLong(*data);
 689             }
 690             else if(!strcmp(key, "join"))
 691             {
 692                 zend_hash_get_current_data(style, (void**)&data);
 693                 joinStyle = getZvalAsLong(*data);
 694             }
 695             else if(!strcmp(key, "mitre_limit"))
 696             {
 697                 zend_hash_get_current_data(style, (void**)&data);
 698                 mitreLimit = getZvalAsDouble(*data);
 699             }
 700
 701             zend_hash_move_forward(style);
 702         }
 703     }
 704
 705     ret = GEOSOffsetCurve(this, dist, quadSegs, joinStyle, mitreLimit);
 706     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
 707
 708     /* return_value is a zval */
 709     object_init_ex(return_value, Geometry_ce_ptr);
 710     setRelay(return_value, ret);
 711 }
 712
 713 PHP_METHOD(Geometry, envelope)
 714 {
 715     GEOSGeometry *this;
 716     GEOSGeometry *ret;
 717
 718     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 719
 720     ret = GEOSEnvelope(this);
 721     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
 722
 723     /* return_value is a zval */
 724     object_init_ex(return_value, Geometry_ce_ptr);
 725     setRelay(return_value, ret);
 726 }
 727
 728 PHP_METHOD(Geometry, intersection)
 729 {
 730     GEOSGeometry *this;
 731     GEOSGeometry *other;
 732     GEOSGeometry *ret;
 733     zval *zobj;
 734
 735     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 736
 737     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
 738             == FAILURE) {
 739         RETURN_NULL();
 740     }
 741     other = getRelay(zobj, Geometry_ce_ptr);
 742
 743     ret = GEOSIntersection(this, other);
 744     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
 745
 746     /* return_value is a zval */
 747     object_init_ex(return_value, Geometry_ce_ptr);
 748     setRelay(return_value, ret);
 749 }
 750
 751 PHP_METHOD(Geometry, convexHull)
 752 {
 753     GEOSGeometry *this;
 754     GEOSGeometry *ret;
 755
 756     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 757
 758     ret = GEOSConvexHull(this);
 759     if ( ret == NULL ) RETURN_NULL(); /* should get an exception first */
 760
 761     /* return_value is a zval */
 762     object_init_ex(return_value, Geometry_ce_ptr);
 763     setRelay(return_value, ret);
 764 }
 765
 766 PHP_METHOD(Geometry, difference)
 767 {
 768     GEOSGeometry *this;
 769     GEOSGeometry *other;
 770     GEOSGeometry *ret;
 771     zval *zobj;
 772
 773     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 774
 775     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
 776             == FAILURE) {
 777         RETURN_NULL();
 778     }
 779     other = getRelay(zobj, Geometry_ce_ptr);
 780
 781     ret = GEOSDifference(this, other);
 782     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
 783
 784     /* return_value is a zval */
 785     object_init_ex(return_value, Geometry_ce_ptr);
 786     setRelay(return_value, ret);
 787 }
 788
 789 PHP_METHOD(Geometry, symDifference)
 790 {
 791     GEOSGeometry *this;
 792     GEOSGeometry *other;
 793     GEOSGeometry *ret;
 794     zval *zobj;
 795
 796     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 797
 798     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
 799             == FAILURE) {
 800         RETURN_NULL();
 801     }
 802     other = getRelay(zobj, Geometry_ce_ptr);
 803
 804     ret = GEOSSymDifference(this, other);
 805     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
 806
 807     /* return_value is a zval */
 808     object_init_ex(return_value, Geometry_ce_ptr);
 809     setRelay(return_value, ret);
 810 }
 811
 812 PHP_METHOD(Geometry, boundary)
 813 {
 814     GEOSGeometry *this;
 815     GEOSGeometry *ret;
 816
 817     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 818
 819     ret = GEOSBoundary(this);
 820     if ( ret == NULL ) RETURN_NULL(); /* should get an exception first */
 821
 822     /* return_value is a zval */
 823     object_init_ex(return_value, Geometry_ce_ptr);
 824     setRelay(return_value, ret);
 825 }
 826
 827 /**
 828  * GEOSGeometry::union(otherGeom)
 829  * GEOSGeometry::union()
 830  */
 831 PHP_METHOD(Geometry, union)
 832 {
 833     GEOSGeometry *this;
 834     GEOSGeometry *other;
 835     GEOSGeometry *ret;
 836     zval *zobj = NULL;
 837
 838     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 839
 840     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|o", &zobj)
 841             == FAILURE) {
 842         RETURN_NULL();
 843     }
 844
 845     if ( zobj ) {
 846         other = getRelay(zobj, Geometry_ce_ptr);
 847         ret = GEOSUnion(this, other);
 848     } else {
 849         ret = GEOSUnaryUnion(this);
 850     }
 851
 852     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
 853
 854     /* return_value is a zval */
 855     object_init_ex(return_value, Geometry_ce_ptr);
 856     setRelay(return_value, ret);
 857 }
 858
 859 /**
 860  * GEOSGeometry::pointOnSurface()
 861  */
 862 PHP_METHOD(Geometry, pointOnSurface)
 863 {
 864     GEOSGeometry *this;
 865     GEOSGeometry *ret;
 866
 867     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 868
 869     ret = GEOSPointOnSurface(this);
 870     if ( ret == NULL ) RETURN_NULL(); /* should get an exception first */
 871
 872     /* return_value is a zval */
 873     object_init_ex(return_value, Geometry_ce_ptr);
 874     setRelay(return_value, ret);
 875 }
 876
 877 /**
 878  * GEOSGeometry::centroid()
 879  */
 880 PHP_METHOD(Geometry, centroid)
 881 {
 882     GEOSGeometry *this;
 883     GEOSGeometry *ret;
 884
 885     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 886
 887     ret = GEOSGetCentroid(this);
 888     if ( ret == NULL ) RETURN_NULL(); /* should get an exception first */
 889
 890     /* return_value is a zval */
 891     object_init_ex(return_value, Geometry_ce_ptr);
 892     setRelay(return_value, ret);
 893 }
 894
 895 /**
 896  * GEOSGeometry::relate(otherGeom)
 897  * GEOSGeometry::relate(otherGeom, pattern)
 898  */
 899 PHP_METHOD(Geometry, relate)
 900 {
 901     GEOSGeometry *this;
 902     GEOSGeometry *other;
 903     zval *zobj;
 904     char* pat = NULL;
 905     int patlen;
 906     int retInt;
 907     zend_bool retBool;
 908     char* retStr;
 909
 910     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 911
 912     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|s",
 913         &zobj, &pat, &patlen) == FAILURE)
 914     {
 915         RETURN_NULL();
 916     }
 917
 918     other = getRelay(zobj, Geometry_ce_ptr);
 919
 920     if ( ! pat ) {
 921         /* we'll compute it */
 922         pat = GEOSRelate(this, other);
 923         if ( ! pat ) RETURN_NULL(); /* should get an exception first */
 924         retStr = estrdup(pat);
 925         GEOSFree(pat);
 926         RETURN_STRING(retStr, 0);
 927     } else {
 928         retInt = GEOSRelatePattern(this, other, pat);
 929         if ( retInt == 2 ) RETURN_NULL(); /* should get an exception first */
 930         retBool = retInt;
 931         RETURN_BOOL(retBool);
 932     }
 933
 934 }
 935
 936 /**
 937  * GEOSGeometry::relateBoundaryNodeRule(otherGeom, rule)
 938  */
 939 PHP_METHOD(Geometry, relateBoundaryNodeRule)
 940 {
 941     GEOSGeometry *this;
 942     GEOSGeometry *other;
 943     zval *zobj;
 944     char* pat;
 945     long int bnr = GEOSRELATE_BNR_OGC;
 946     char* retStr;
 947
 948     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 949
 950     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ol",
 951         &zobj, &bnr) == FAILURE)
 952     {
 953         RETURN_NULL();
 954     }
 955
 956     other = getRelay(zobj, Geometry_ce_ptr);
 957
 958     /* we'll compute it */
 959     pat = GEOSRelateBoundaryNodeRule(this, other, bnr);
 960     if ( ! pat ) RETURN_NULL(); /* should get an exception first */
 961     retStr = estrdup(pat);
 962     GEOSFree(pat);
 963     RETURN_STRING(retStr, 0);
 964 }
 965
 966 /**
 967  * GEOSGeometry GEOSGeometry::simplify(tolerance)
 968  * GEOSGeometry GEOSGeometry::simplify(tolerance, preserveTopology)
 969  */
 970 PHP_METHOD(Geometry, simplify)
 971 {
 972     GEOSGeometry *this;
 973     double tolerance;
 974     zend_bool preserveTopology = 0;
 975     GEOSGeometry *ret;
 976
 977     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
 978
 979     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "d|b",
 980             &tolerance, &preserveTopology) == FAILURE) {
 981         RETURN_NULL();
 982     }
 983
 984     if ( preserveTopology ) {
 985         ret = GEOSTopologyPreserveSimplify(this, tolerance);
 986     } else {
 987         ret = GEOSSimplify(this, tolerance);
 988     }
 989
 990     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
 991
 992     /* return_value is a zval */
 993     object_init_ex(return_value, Geometry_ce_ptr);
 994     setRelay(return_value, ret);
 995 }
 996
 997 /**
 998  * GEOSGeometry GEOSGeometry::extractUniquePoints()
 999  */
1000 PHP_METHOD(Geometry, extractUniquePoints)
1001 {
1002     GEOSGeometry *this;
1003     GEOSGeometry *ret;
1004
1005     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1006
1007     ret = GEOSGeom_extractUniquePoints(this);
1008     if ( ret == NULL ) RETURN_NULL(); /* should get an exception first */
1009
1010     /* return_value is a zval */
1011     object_init_ex(return_value, Geometry_ce_ptr);
1012     setRelay(return_value, ret);
1013 }
1014
1015 /**
1016  * bool GEOSGeometry::disjoint(GEOSGeometry)
1017  */
1018 PHP_METHOD(Geometry, disjoint)
1019 {
1020     GEOSGeometry *this;
1021     GEOSGeometry *other;
1022     int ret;
1023     zend_bool retBool;
1024     zval *zobj;
1025
1026     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1027
1028     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
1029             == FAILURE) {
1030         RETURN_NULL();
1031     }
1032     other = getRelay(zobj, Geometry_ce_ptr);
1033
1034     ret = GEOSDisjoint(this, other);
1035     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1036
1037     /* return_value is a zval */
1038     retBool = ret;
1039     RETURN_BOOL(retBool);
1040 }
1041
1042 /**
1043  * bool GEOSGeometry::touches(GEOSGeometry)
1044  */
1045 PHP_METHOD(Geometry, touches)
1046 {
1047     GEOSGeometry *this;
1048     GEOSGeometry *other;
1049     int ret;
1050     zend_bool retBool;
1051     zval *zobj;
1052
1053     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1054
1055     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
1056             == FAILURE) {
1057         RETURN_NULL();
1058     }
1059     other = getRelay(zobj, Geometry_ce_ptr);
1060
1061     ret = GEOSTouches(this, other);
1062     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1063
1064     /* return_value is a zval */
1065     retBool = ret;
1066     RETURN_BOOL(retBool);
1067 }
1068
1069 /**
1070  * bool GEOSGeometry::intersects(GEOSGeometry)
1071  */
1072 PHP_METHOD(Geometry, intersects)
1073 {
1074     GEOSGeometry *this;
1075     GEOSGeometry *other;
1076     int ret;
1077     zend_bool retBool;
1078     zval *zobj;
1079
1080     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1081
1082     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
1083             == FAILURE) {
1084         RETURN_NULL();
1085     }
1086     other = getRelay(zobj, Geometry_ce_ptr);
1087
1088     ret = GEOSIntersects(this, other);
1089     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1090
1091     /* return_value is a zval */
1092     retBool = ret;
1093     RETURN_BOOL(retBool);
1094 }
1095
1096 /**
1097  * bool GEOSGeometry::crosses(GEOSGeometry)
1098  */
1099 PHP_METHOD(Geometry, crosses)
1100 {
1101     GEOSGeometry *this;
1102     GEOSGeometry *other;
1103     int ret;
1104     zend_bool retBool;
1105     zval *zobj;
1106
1107     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1108
1109     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
1110             == FAILURE) {
1111         RETURN_NULL();
1112     }
1113     other = getRelay(zobj, Geometry_ce_ptr);
1114
1115     ret = GEOSCrosses(this, other);
1116     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1117
1118     /* return_value is a zval */
1119     retBool = ret;
1120     RETURN_BOOL(retBool);
1121 }
1122
1123 /**
1124  * bool GEOSGeometry::within(GEOSGeometry)
1125  */
1126 PHP_METHOD(Geometry, within)
1127 {
1128     GEOSGeometry *this;
1129     GEOSGeometry *other;
1130     int ret;
1131     zend_bool retBool;
1132     zval *zobj;
1133
1134     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1135
1136     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
1137             == FAILURE) {
1138         RETURN_NULL();
1139     }
1140     other = getRelay(zobj, Geometry_ce_ptr);
1141
1142     ret = GEOSWithin(this, other);
1143     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1144
1145     /* return_value is a zval */
1146     retBool = ret;
1147     RETURN_BOOL(retBool);
1148 }
1149
1150 /**
1151  * bool GEOSGeometry::contains(GEOSGeometry)
1152  */
1153 PHP_METHOD(Geometry, contains)
1154 {
1155     GEOSGeometry *this;
1156     GEOSGeometry *other;
1157     int ret;
1158     zend_bool retBool;
1159     zval *zobj;
1160
1161     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1162
1163     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
1164             == FAILURE) {
1165         RETURN_NULL();
1166     }
1167     other = getRelay(zobj, Geometry_ce_ptr);
1168
1169     ret = GEOSContains(this, other);
1170     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1171
1172     /* return_value is a zval */
1173     retBool = ret;
1174     RETURN_BOOL(retBool);
1175 }
1176
1177 /**
1178  * bool GEOSGeometry::overlaps(GEOSGeometry)
1179  */
1180 PHP_METHOD(Geometry, overlaps)
1181 {
1182     GEOSGeometry *this;
1183     GEOSGeometry *other;
1184     int ret;
1185     zend_bool retBool;
1186     zval *zobj;
1187
1188     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1189
1190     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
1191             == FAILURE) {
1192         RETURN_NULL();
1193     }
1194     other = getRelay(zobj, Geometry_ce_ptr);
1195
1196     ret = GEOSOverlaps(this, other);
1197     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1198
1199     /* return_value is a zval */
1200     retBool = ret;
1201     RETURN_BOOL(retBool);
1202 }
1203
1204 /**
1205  * bool GEOSGeometry::covers(GEOSGeometry)
1206  */
1207 PHP_METHOD(Geometry, covers)
1208 {
1209     GEOSGeometry *this;
1210     GEOSGeometry *other;
1211     int ret;
1212     zend_bool retBool;
1213     zval *zobj;
1214
1215     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1216
1217     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
1218             == FAILURE) {
1219         RETURN_NULL();
1220     }
1221     other = getRelay(zobj, Geometry_ce_ptr);
1222
1223     ret = GEOSCovers(this, other);
1224     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1225
1226     /* return_value is a zval */
1227     retBool = ret;
1228     RETURN_BOOL(retBool);
1229 }
1230
1231 /**
1232  * bool GEOSGeometry::coveredBy(GEOSGeometry)
1233  */
1234 PHP_METHOD(Geometry, coveredBy)
1235 {
1236     GEOSGeometry *this;
1237     GEOSGeometry *other;
1238     int ret;
1239     zend_bool retBool;
1240     zval *zobj;
1241
1242     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1243
1244     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
1245             == FAILURE) {
1246         RETURN_NULL();
1247     }
1248     other = getRelay(zobj, Geometry_ce_ptr);
1249
1250     ret = GEOSCoveredBy(this, other);
1251     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1252
1253     /* return_value is a zval */
1254     retBool = ret;
1255     RETURN_BOOL(retBool);
1256 }
1257
1258 /**
1259  * bool GEOSGeometry::equals(GEOSGeometry)
1260  */
1261 PHP_METHOD(Geometry, equals)
1262 {
1263     GEOSGeometry *this;
1264     GEOSGeometry *other;
1265     int ret;
1266     zend_bool retBool;
1267     zval *zobj;
1268
1269     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1270
1271     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o",
1272         &zobj) == FAILURE) {
1273         RETURN_NULL();
1274     }
1275     other = getRelay(zobj, Geometry_ce_ptr);
1276
1277     ret = GEOSEquals(this, other);
1278     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1279
1280     /* return_value is a zval */
1281     retBool = ret;
1282     RETURN_BOOL(retBool);
1283 }
1284
1285 /**
1286  * bool GEOSGeometry::equalsExact(GEOSGeometry)
1287  * bool GEOSGeometry::equalsExact(GEOSGeometry, double tolerance)
1288  */
1289 PHP_METHOD(Geometry, equalsExact)
1290 {
1291     GEOSGeometry *this;
1292     GEOSGeometry *other;
1293     int ret;
1294     double tolerance = 0;
1295     zend_bool retBool;
1296     zval *zobj;
1297
1298     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1299
1300     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|d",
1301         &zobj, &tolerance) == FAILURE) {
1302         RETURN_NULL();
1303     }
1304     other = getRelay(zobj, Geometry_ce_ptr);
1305
1306     ret = GEOSEqualsExact(this, other, tolerance);
1307     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1308
1309     /* return_value is a zval */
1310     retBool = ret;
1311     RETURN_BOOL(retBool);
1312 }
1313
1314 /**
1315  * bool GEOSGeometry::isEmpty()
1316  */
1317 PHP_METHOD(Geometry, isEmpty)
1318 {
1319     GEOSGeometry *this;
1320     int ret;
1321     zend_bool retBool;
1322
1323     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1324
1325     ret = GEOSisEmpty(this);
1326     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1327
1328     /* return_value is a zval */
1329     retBool = ret;
1330     RETURN_BOOL(retBool);
1331 }
1332
1333 /**
1334  * array GEOSGeometry::checkValidity()
1335  */
1336 PHP_METHOD(Geometry, checkValidity)
1337 {
1338     GEOSGeometry *this;
1339     GEOSGeometry *location = NULL;
1340     int ret;
1341     char *reason = NULL;
1342     zend_bool retBool;
1343     char *reasonVal = NULL;
1344     zval *locationVal = NULL;
1345     long int flags = 0;
1346
1347     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1348
1349     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l",
1350         &flags) == FAILURE) {
1351         RETURN_NULL();
1352     }
1353
1354     ret = GEOSisValidDetail(this, flags, &reason, &location);
1355     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1356
1357     if ( reason ) {
1358         reasonVal = estrdup(reason);
1359         GEOSFree(reason);
1360     }
1361
1362     if ( location ) {
1363         MAKE_STD_ZVAL(locationVal);
1364         object_init_ex(locationVal, Geometry_ce_ptr);
1365         setRelay(locationVal, location);
1366     }
1367
1368     retBool = ret;
1369
1370     /* return value is an array */
1371     array_init(return_value);
1372     add_assoc_bool(return_value, "valid", retBool);
1373     if ( reasonVal ) add_assoc_string(return_value, "reason", reasonVal, 0);
1374     if ( locationVal ) add_assoc_zval(return_value, "location", locationVal);
1375
1376 }
1377
1378 /**
1379  * bool GEOSGeometry::isSimple()
1380  */
1381 PHP_METHOD(Geometry, isSimple)
1382 {
1383     GEOSGeometry *this;
1384     int ret;
1385     zend_bool retBool;
1386
1387     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1388
1389     ret = GEOSisSimple(this);
1390     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1391
1392     /* return_value is a zval */
1393     retBool = ret;
1394     RETURN_BOOL(retBool);
1395 }
1396
1397 /**
1398  * bool GEOSGeometry::isRing()
1399  */
1400 PHP_METHOD(Geometry, isRing)
1401 {
1402     GEOSGeometry *this;
1403     int ret;
1404     zend_bool retBool;
1405
1406     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1407
1408     ret = GEOSisRing(this);
1409     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1410
1411     /* return_value is a zval */
1412     retBool = ret;
1413     RETURN_BOOL(retBool);
1414 }
1415
1416 /**
1417  * bool GEOSGeometry::hasZ()
1418  */
1419 PHP_METHOD(Geometry, hasZ)
1420 {
1421     GEOSGeometry *this;
1422     int ret;
1423     zend_bool retBool;
1424
1425     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1426
1427     ret = GEOSHasZ(this);
1428     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1429
1430     /* return_value is a zval */
1431     retBool = ret;
1432     RETURN_BOOL(retBool);
1433 }
1434
1435 /**
1436  * bool GEOSGeometry::isClosed()
1437  */
1438 PHP_METHOD(Geometry, isClosed)
1439 {
1440     GEOSGeometry *this;
1441     int ret;
1442     zend_bool retBool;
1443
1444     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1445
1446     ret = GEOSisClosed(this);
1447     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
1448
1449     /* return_value is a zval */
1450     retBool = ret;
1451     RETURN_BOOL(retBool);
1452 }
1453
1454 /**
1455  * string GEOSGeometry::typeName()
1456  */
1457 PHP_METHOD(Geometry, typeName)
1458 {
1459     GEOSGeometry *this;
1460     char *typ;
1461     char *typVal;
1462
1463     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1464
1465     /* TODO: define constant strings instead... */
1466
1467     typ = GEOSGeomType(this);
1468     if ( ! typ ) RETURN_NULL(); /* should get an exception first */
1469
1470     typVal = estrdup(typ);
1471     GEOSFree(typ);
1472
1473     RETURN_STRING(typVal, 0);
1474 }
1475
1476 /**
1477  * long GEOSGeometry::typeId()
1478  */
1479 PHP_METHOD(Geometry, typeId)
1480 {
1481     GEOSGeometry *this;
1482     long typ;
1483
1484     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1485
1486     /* TODO: define constant strings instead... */
1487
1488     typ = GEOSGeomTypeId(this);
1489     if ( typ == -1 ) RETURN_NULL(); /* should get an exception first */
1490
1491     RETURN_LONG(typ);
1492 }
1493
1494 /**
1495  * long GEOSGeometry::getSRID()
1496  */
1497 PHP_METHOD(Geometry, getSRID)
1498 {
1499     GEOSGeometry *geom;
1500     long int ret;
1501
1502     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1503
1504     ret = GEOSGetSRID(geom);
1505
1506     RETURN_LONG(ret);
1507 }
1508
1509 /**
1510  * void GEOSGeometry::setSRID(long)
1511  */
1512 PHP_METHOD(Geometry, setSRID)
1513 {
1514     GEOSGeometry *geom;
1515     long int srid;
1516
1517     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1518
1519     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
1520         &srid) == FAILURE) {
1521         RETURN_NULL();
1522     }
1523
1524     GEOSSetSRID(geom, srid);
1525 }
1526
1527 /**
1528  * long GEOSGeometry::numGeometries()
1529  */
1530 PHP_METHOD(Geometry, numGeometries)
1531 {
1532     GEOSGeometry *geom;
1533     long int ret;
1534
1535     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1536
1537     ret = GEOSGetNumGeometries(geom);
1538     if ( ret == -1 ) RETURN_NULL(); /* should get an exception first */
1539
1540     RETURN_LONG(ret);
1541 }
1542
1543 /**
1544  * GEOSGeometry GEOSGeometry::geometryN()
1545  */
1546 PHP_METHOD(Geometry, geometryN)
1547 {
1548     GEOSGeometry *geom;
1549     const GEOSGeometry *c;
1550     GEOSGeometry *cc;
1551     long int num;
1552
1553     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1554
1555     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
1556         &num) == FAILURE) {
1557         RETURN_NULL();
1558     }
1559
1560     if ( num >= GEOSGetNumGeometries(geom) ) RETURN_NULL();
1561     c = GEOSGetGeometryN(geom, num);
1562     if ( ! c ) RETURN_NULL(); /* should get an exception first */
1563     cc = GEOSGeom_clone(c);
1564     if ( ! cc ) RETURN_NULL(); /* should get an exception first */
1565
1566     object_init_ex(return_value, Geometry_ce_ptr);
1567     setRelay(return_value, cc);
1568 }
1569
1570 /**
1571  * long GEOSGeometry::numInteriorRings()
1572  */
1573 PHP_METHOD(Geometry, numInteriorRings)
1574 {
1575     GEOSGeometry *geom;
1576     long int ret;
1577
1578     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1579
1580     ret = GEOSGetNumInteriorRings(geom);
1581     if ( ret == -1 ) RETURN_NULL(); /* should get an exception first */
1582
1583     RETURN_LONG(ret);
1584 }
1585
1586 /**
1587  * long GEOSGeometry::numPoints()
1588  */
1589 PHP_METHOD(Geometry, numPoints)
1590 {
1591     GEOSGeometry *geom;
1592     long int ret;
1593
1594     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1595
1596     ret = GEOSGeomGetNumPoints(geom);
1597     if ( ret == -1 ) RETURN_NULL(); /* should get an exception first */
1598
1599     RETURN_LONG(ret);
1600 }
1601
1602 /**
1603  * double GEOSGeometry::getX()
1604  */
1605 PHP_METHOD(Geometry, getX)
1606 {
1607     GEOSGeometry *geom;
1608     int ret;
1609     double x;
1610
1611     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1612
1613     ret = GEOSGeomGetX(geom, &x);
1614     if ( ret == -1 ) RETURN_NULL(); /* should get an exception first */
1615
1616     RETURN_DOUBLE(x);
1617 }
1618
1619 /**
1620  * double GEOSGeometry::getY()
1621  */
1622 PHP_METHOD(Geometry, getY)
1623 {
1624     GEOSGeometry *geom;
1625     int ret;
1626     double y;
1627
1628     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1629
1630     ret = GEOSGeomGetY(geom, &y);
1631     if ( ret == -1 ) RETURN_NULL(); /* should get an exception first */
1632
1633     RETURN_DOUBLE(y);
1634 }
1635
1636 /**
1637  * GEOSGeometry GEOSGeometry::interiorRingN()
1638  */
1639 PHP_METHOD(Geometry, interiorRingN)
1640 {
1641     GEOSGeometry *geom;
1642     const GEOSGeometry *c;
1643     GEOSGeometry *cc;
1644     long int num;
1645
1646     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1647
1648     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
1649         &num) == FAILURE) {
1650         RETURN_NULL();
1651     }
1652
1653     if ( num >= GEOSGetNumInteriorRings(geom) ) RETURN_NULL();
1654     c = GEOSGetInteriorRingN(geom, num);
1655     if ( ! c ) RETURN_NULL(); /* should get an exception first */
1656     cc = GEOSGeom_clone(c);
1657     if ( ! cc ) RETURN_NULL(); /* should get an exception first */
1658
1659     object_init_ex(return_value, Geometry_ce_ptr);
1660     setRelay(return_value, cc);
1661 }
1662
1663 /**
1664  * GEOSGeometry GEOSGeometry::exteriorRing()
1665  */
1666 PHP_METHOD(Geometry, exteriorRing)
1667 {
1668     GEOSGeometry *geom;
1669     const GEOSGeometry *c;
1670     GEOSGeometry *cc;
1671
1672     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1673
1674     c = GEOSGetExteriorRing(geom);
1675     if ( ! c ) RETURN_NULL(); /* should get an exception first */
1676     cc = GEOSGeom_clone(c);
1677     if ( ! cc ) RETURN_NULL(); /* should get an exception first */
1678
1679     object_init_ex(return_value, Geometry_ce_ptr);
1680     setRelay(return_value, cc);
1681 }
1682
1683 /**
1684  * long GEOSGeometry::numCoordinates()
1685  */
1686 PHP_METHOD(Geometry, numCoordinates)
1687 {
1688     GEOSGeometry *geom;
1689     long int ret;
1690
1691     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1692
1693     ret = GEOSGetNumCoordinates(geom);
1694     if ( ret == -1 ) RETURN_NULL(); /* should get an exception first */
1695
1696     RETURN_LONG(ret);
1697 }
1698
1699 /**
1700  * long GEOSGeometry::dimension()
1701  * 0:puntual 1:lineal 2:areal
1702  */
1703 PHP_METHOD(Geometry, dimension)
1704 {
1705     GEOSGeometry *geom;
1706     long int ret;
1707
1708     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1709
1710     ret = GEOSGeom_getDimensions(geom);
1711     if ( ret == -1 ) RETURN_NULL(); /* should get an exception first */
1712
1713     RETURN_LONG(ret);
1714 }
1715
1716 /**
1717  * long GEOSGeometry::coordinateDimension()
1718  */
1719 PHP_METHOD(Geometry, coordinateDimension)
1720 {
1721     GEOSGeometry *geom;
1722     long int ret;
1723
1724     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1725
1726     ret = GEOSGeom_getCoordinateDimension(geom);
1727     if ( ret == -1 ) RETURN_NULL(); /* should get an exception first */
1728
1729     RETURN_LONG(ret);
1730 }
1731
1732 /**
1733  * GEOSGeometry GEOSGeometry::pointN()
1734  */
1735 PHP_METHOD(Geometry, pointN)
1736 {
1737     GEOSGeometry *geom;
1738     GEOSGeometry *c;
1739     long int num;
1740
1741     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1742
1743     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
1744         &num) == FAILURE) {
1745         RETURN_NULL();
1746     }
1747
1748     if ( num >= GEOSGeomGetNumPoints(geom) ) RETURN_NULL();
1749     c = GEOSGeomGetPointN(geom, num);
1750     if ( ! c ) RETURN_NULL(); /* should get an exception first */
1751
1752     object_init_ex(return_value, Geometry_ce_ptr);
1753     setRelay(return_value, c);
1754 }
1755
1756 /**
1757  * GEOSGeometry GEOSGeometry::startPoint()
1758  */
1759 PHP_METHOD(Geometry, startPoint)
1760 {
1761     GEOSGeometry *geom;
1762     GEOSGeometry *c;
1763
1764     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1765
1766     c = GEOSGeomGetStartPoint(geom);
1767     if ( ! c ) RETURN_NULL(); /* should get an exception first */
1768
1769     object_init_ex(return_value, Geometry_ce_ptr);
1770     setRelay(return_value, c);
1771 }
1772
1773 /**
1774  * GEOSGeometry GEOSGeometry::endPoint()
1775  */
1776 PHP_METHOD(Geometry, endPoint)
1777 {
1778     GEOSGeometry *geom;
1779     GEOSGeometry *c;
1780
1781     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1782
1783     c = GEOSGeomGetEndPoint(geom);
1784     if ( ! c ) RETURN_NULL(); /* should get an exception first */
1785
1786     object_init_ex(return_value, Geometry_ce_ptr);
1787     setRelay(return_value, c);
1788 }
1789
1790 /**
1791  * double GEOSGeometry::area()
1792  */
1793 PHP_METHOD(Geometry, area)
1794 {
1795     GEOSGeometry *geom;
1796     double area;
1797     int ret;
1798
1799     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1800
1801     ret = GEOSArea(geom, &area);
1802     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
1803
1804     RETURN_DOUBLE(area);
1805 }
1806
1807 /**
1808  * double GEOSGeometry::length()
1809  */
1810 PHP_METHOD(Geometry, length)
1811 {
1812     GEOSGeometry *geom;
1813     double length;
1814     int ret;
1815
1816     geom = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1817
1818     ret = GEOSLength(geom, &length);
1819     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
1820
1821     RETURN_DOUBLE(length);
1822 }
1823
1824 /**
1825  * double GEOSGeometry::distance(GEOSGeometry)
1826  */
1827 PHP_METHOD(Geometry, distance)
1828 {
1829     GEOSGeometry *this;
1830     GEOSGeometry *other;
1831     zval *zobj;
1832     double dist;
1833     int ret;
1834
1835     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1836
1837     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o",
1838         &zobj) == FAILURE)
1839     {
1840         RETURN_NULL();
1841     }
1842
1843     other = getRelay(zobj, Geometry_ce_ptr);
1844
1845     ret = GEOSDistance(this, other, &dist);
1846     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
1847
1848     RETURN_DOUBLE(dist);
1849 }
1850
1851 /**
1852  * double GEOSGeometry::hausdorffDistance(GEOSGeometry)
1853  */
1854 PHP_METHOD(Geometry, hausdorffDistance)
1855 {
1856     GEOSGeometry *this;
1857     GEOSGeometry *other;
1858     zval *zobj;
1859     double dist;
1860     int ret;
1861
1862     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1863
1864     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o",
1865         &zobj) == FAILURE)
1866     {
1867         RETURN_NULL();
1868     }
1869
1870     other = getRelay(zobj, Geometry_ce_ptr);
1871
1872     ret = GEOSHausdorffDistance(this, other, &dist);
1873     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
1874
1875     RETURN_DOUBLE(dist);
1876 }
1877
1878 PHP_METHOD(Geometry, snapTo)
1879 {
1880     GEOSGeometry *this;
1881     GEOSGeometry *other;
1882     GEOSGeometry *ret;
1883     double tolerance;
1884     zval *zobj;
1885
1886     this = (GEOSGeometry*)getRelay(getThis(), Geometry_ce_ptr);
1887
1888     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "od", &zobj,
1889             &tolerance) == FAILURE) {
1890         RETURN_NULL();
1891     }
1892     other = getRelay(zobj, Geometry_ce_ptr);
1893
1894     ret = GEOSSnap(this, other, tolerance);
1895     if ( ! ret ) RETURN_NULL(); /* should get an exception first */
1896
1897     /* return_value is a zval */
1898     object_init_ex(return_value, Geometry_ce_ptr);
1899     setRelay(return_value, ret);
1900 }
1901
1902
1903
1904 /* -- class GEOSWKTReader -------------------- */
1905
1906 PHP_METHOD(WKTReader, __construct);
1907 PHP_METHOD(WKTReader, read);
1908
1909 static function_entry WKTReader_methods[] = {
1910     PHP_ME(WKTReader, __construct, NULL, 0)
1911     PHP_ME(WKTReader, read, NULL, 0)
1912     {NULL, NULL, NULL}
1913 };
1914
1915 static zend_class_entry *WKTReader_ce_ptr;
1916
1917 static zend_object_handlers WKTReader_object_handlers;
1918
1919 static void
1920 WKTReader_dtor (void *object TSRMLS_DC)
1921 {
1922     Proxy *obj = (Proxy *)object;
1923     GEOSWKTReader_destroy((GEOSWKTReader*)obj->relay);
1924
1925     zend_hash_destroy(obj->std.properties);
1926     FREE_HASHTABLE(obj->std.properties);
1927
1928     efree(obj);
1929 }
1930
1931 static zend_object_value
1932 WKTReader_create_obj (zend_class_entry *type TSRMLS_DC)
1933 {
1934     return Gen_create_obj(type, WKTReader_dtor, &WKTReader_object_handlers);
1935 }
1936
1937
1938 PHP_METHOD(WKTReader, __construct)
1939 {
1940     GEOSWKTReader* obj;
1941     zval *object = getThis();
1942
1943     obj = GEOSWKTReader_create();
1944     if ( ! obj ) {
1945         php_error_docref(NULL TSRMLS_CC, E_ERROR,
1946                 "GEOSWKTReader_create() failed (didn't initGEOS?)");
1947     }
1948
1949     setRelay(object, obj);
1950 }
1951
1952 PHP_METHOD(WKTReader, read)
1953 {
1954     GEOSWKTReader *reader;
1955     GEOSGeometry *geom;
1956     char* wkt;
1957     int wktlen;
1958
1959     reader = (GEOSWKTReader*)getRelay(getThis(), WKTReader_ce_ptr);
1960
1961     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
1962         &wkt, &wktlen) == FAILURE)
1963     {
1964         RETURN_NULL();
1965     }
1966
1967     geom = GEOSWKTReader_read(reader, wkt);
1968     /* we'll probably get an exception if geom is null */
1969     if ( ! geom ) RETURN_NULL();
1970
1971     /* return_value is a zval */
1972     object_init_ex(return_value, Geometry_ce_ptr);
1973     setRelay(return_value, geom);
1974
1975 }
1976
1977 /* -- class GEOSWKTWriter -------------------- */
1978
1979 PHP_METHOD(WKTWriter, __construct);
1980 PHP_METHOD(WKTWriter, write);
1981 PHP_METHOD(WKTWriter, setTrim);
1982 PHP_METHOD(WKTWriter, setRoundingPrecision);
1983 PHP_METHOD(WKTWriter, setOutputDimension);
1984 PHP_METHOD(WKTWriter, getOutputDimension);
1985 PHP_METHOD(WKTWriter, setOld3D);
1986
1987 static function_entry WKTWriter_methods[] = {
1988     PHP_ME(WKTWriter, __construct, NULL, 0)
1989     PHP_ME(WKTWriter, write, NULL, 0)
1990     PHP_ME(WKTWriter, setTrim, NULL, 0)
1991     PHP_ME(WKTWriter, setRoundingPrecision, NULL, 0)
1992     PHP_ME(WKTWriter, setOutputDimension, NULL, 0)
1993     PHP_ME(WKTWriter, getOutputDimension, NULL, 0)
1994     PHP_ME(WKTWriter, setOld3D, NULL, 0)
1995     {NULL, NULL, NULL}
1996 };
1997
1998 static zend_class_entry *WKTWriter_ce_ptr;
1999
2000 static zend_object_handlers WKTWriter_object_handlers;
2001
2002 static void
2003 WKTWriter_dtor (void *object TSRMLS_DC)
2004 {
2005     Proxy *obj = (Proxy *)object;
2006     GEOSWKTWriter_destroy((GEOSWKTWriter*)obj->relay);
2007
2008     zend_hash_destroy(obj->std.properties);
2009     FREE_HASHTABLE(obj->std.properties);
2010
2011     efree(obj);
2012 }
2013
2014 static zend_object_value
2015 WKTWriter_create_obj (zend_class_entry *type TSRMLS_DC)
2016 {
2017     return Gen_create_obj(type, WKTWriter_dtor, &WKTWriter_object_handlers);
2018 }
2019
2020 PHP_METHOD(WKTWriter, __construct)
2021 {
2022     GEOSWKTWriter* obj;
2023     zval *object = getThis();
2024
2025     obj = GEOSWKTWriter_create();
2026     if ( ! obj ) {
2027         php_error_docref(NULL TSRMLS_CC, E_ERROR,
2028                 "GEOSWKTWriter_create() failed (didn't initGEOS?)");
2029     }
2030
2031     setRelay(object, obj);
2032 }
2033
2034 PHP_METHOD(WKTWriter, write)
2035 {
2036     GEOSWKTWriter *writer;
2037     zval *zobj;
2038     GEOSGeometry *geom;
2039     char* wkt;
2040     char* retstr;
2041
2042     writer = (GEOSWKTWriter*)getRelay(getThis(), WKTWriter_ce_ptr);
2043
2044     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
2045         == FAILURE)
2046     {
2047         RETURN_NULL();
2048     }
2049
2050     geom = getRelay(zobj, Geometry_ce_ptr);
2051
2052     wkt = GEOSWKTWriter_write(writer, geom);
2053     /* we'll probably get an exception if wkt is null */
2054     if ( ! wkt ) RETURN_NULL();
2055
2056     retstr = estrdup(wkt);
2057     GEOSFree(wkt);
2058
2059     RETURN_STRING(retstr, 0);
2060 }
2061
2062 PHP_METHOD(WKTWriter, setTrim)
2063 {
2064     GEOSWKTWriter *writer;
2065     zend_bool trimval;
2066     char trim;
2067
2068     writer = (GEOSWKTWriter*)getRelay(getThis(), WKTWriter_ce_ptr);
2069
2070     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &trimval)
2071         == FAILURE)
2072     {
2073         RETURN_NULL();
2074     }
2075
2076     trim = trimval;
2077     GEOSWKTWriter_setTrim(writer, trim);
2078 }
2079
2080 PHP_METHOD(WKTWriter, setRoundingPrecision)
2081 {
2082     GEOSWKTWriter *writer;
2083     long int prec;
2084
2085     writer = (GEOSWKTWriter*)getRelay(getThis(), WKTWriter_ce_ptr);
2086
2087     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &prec)
2088         == FAILURE)
2089     {
2090         RETURN_NULL();
2091     }
2092
2093     GEOSWKTWriter_setRoundingPrecision(writer, prec);
2094 }
2095
2096 /**
2097  * void GEOSWKTWriter::setOutputDimension()
2098  */
2099 PHP_METHOD(WKTWriter, setOutputDimension)
2100 {
2101     GEOSWKTWriter *writer;
2102     long int dim;
2103
2104     writer = (GEOSWKTWriter*)getRelay(getThis(), WKTWriter_ce_ptr);
2105
2106     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &dim)
2107         == FAILURE)
2108     {
2109         RETURN_NULL();
2110     }
2111
2112     GEOSWKTWriter_setOutputDimension(writer, dim);
2113 }
2114
2115 /**
2116  * long GEOSWKTWriter::getOutputDimension()
2117  */
2118 PHP_METHOD(WKTWriter, getOutputDimension)
2119 {
2120     GEOSWKTWriter *writer;
2121     long int ret;
2122
2123     writer = (GEOSWKTWriter*)getRelay(getThis(), WKTWriter_ce_ptr);
2124
2125     ret = GEOSWKTWriter_getOutputDimension(writer);
2126
2127     RETURN_LONG(ret);
2128 }
2129
2130 PHP_METHOD(WKTWriter, setOld3D)
2131 {
2132     GEOSWKTWriter *writer;
2133     zend_bool bval;
2134     int val;
2135
2136     writer = (GEOSWKTWriter*)getRelay(getThis(), WKTWriter_ce_ptr);
2137
2138     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &bval)
2139         == FAILURE)
2140     {
2141         RETURN_NULL();
2142     }
2143
2144     val = bval;
2145     GEOSWKTWriter_setOld3D(writer, val);
2146 }
2147
2148 /* -- class GEOSWKBWriter -------------------- */
2149
2150 PHP_METHOD(WKBWriter, __construct);
2151 PHP_METHOD(WKBWriter, getOutputDimension);
2152 PHP_METHOD(WKBWriter, setOutputDimension);
2153 PHP_METHOD(WKBWriter, getByteOrder);
2154 PHP_METHOD(WKBWriter, setByteOrder);
2155 PHP_METHOD(WKBWriter, setIncludeSRID);
2156 PHP_METHOD(WKBWriter, getIncludeSRID);
2157 PHP_METHOD(WKBWriter, writeHEX);
2158
2159 static function_entry WKBWriter_methods[] = {
2160     PHP_ME(WKBWriter, __construct, NULL, 0)
2161     PHP_ME(WKBWriter, getOutputDimension, NULL, 0)
2162     PHP_ME(WKBWriter, setOutputDimension, NULL, 0)
2163     PHP_ME(WKBWriter, getByteOrder, NULL, 0)
2164     PHP_ME(WKBWriter, setByteOrder, NULL, 0)
2165     PHP_ME(WKBWriter, getIncludeSRID, NULL, 0)
2166     PHP_ME(WKBWriter, setIncludeSRID, NULL, 0)
2167     PHP_ME(WKBWriter, writeHEX, NULL, 0)
2168     {NULL, NULL, NULL}
2169 };
2170
2171 static zend_class_entry *WKBWriter_ce_ptr;
2172
2173 static zend_object_handlers WKBWriter_object_handlers;
2174
2175 static void
2176 WKBWriter_dtor (void *object TSRMLS_DC)
2177 {
2178     Proxy *obj = (Proxy *)object;
2179     GEOSWKBWriter_destroy((GEOSWKBWriter*)obj->relay);
2180
2181     zend_hash_destroy(obj->std.properties);
2182     FREE_HASHTABLE(obj->std.properties);
2183
2184     efree(obj);
2185 }
2186
2187 static zend_object_value
2188 WKBWriter_create_obj (zend_class_entry *type TSRMLS_DC)
2189 {
2190     return Gen_create_obj(type, WKBWriter_dtor, &WKBWriter_object_handlers);
2191 }
2192
2193 /**
2194  * GEOSWKBWriter w = new GEOSWKBWriter()
2195  */
2196 PHP_METHOD(WKBWriter, __construct)
2197 {
2198     GEOSWKBWriter* obj;
2199     zval *object = getThis();
2200
2201     obj = GEOSWKBWriter_create();
2202     if ( ! obj ) {
2203         php_error_docref(NULL TSRMLS_CC, E_ERROR,
2204                 "GEOSWKBWriter_create() failed (didn't initGEOS?)");
2205     }
2206
2207     setRelay(object, obj);
2208 }
2209
2210 /**
2211  * long GEOSWKBWriter::getOutputDimension();
2212  */
2213 PHP_METHOD(WKBWriter, getOutputDimension)
2214 {
2215     GEOSWKBWriter *writer;
2216     long int ret;
2217
2218     writer = (GEOSWKBWriter*)getRelay(getThis(), WKBWriter_ce_ptr);
2219
2220     ret = GEOSWKBWriter_getOutputDimension(writer);
2221
2222     RETURN_LONG(ret);
2223 }
2224
2225 /**
2226  * void GEOSWKBWriter::setOutputDimension(dims);
2227  */
2228 PHP_METHOD(WKBWriter, setOutputDimension)
2229 {
2230     GEOSWKBWriter *writer;
2231     long int dim;
2232
2233     writer = (GEOSWKBWriter*)getRelay(getThis(), WKBWriter_ce_ptr);
2234
2235     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &dim)
2236         == FAILURE)
2237     {
2238         RETURN_NULL();
2239     }
2240
2241     GEOSWKBWriter_setOutputDimension(writer, dim);
2242
2243 }
2244
2245 /**
2246  * string GEOSWKBWriter::writeHEX(GEOSGeometry)
2247  */
2248 PHP_METHOD(WKBWriter, writeHEX)
2249 {
2250     GEOSWKBWriter *writer;
2251     zval *zobj;
2252     GEOSGeometry *geom;
2253     char *ret;
2254     size_t retsize; /* useless... */
2255     char* retstr;
2256
2257     writer = (GEOSWKBWriter*)getRelay(getThis(), WKBWriter_ce_ptr);
2258
2259     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
2260         == FAILURE)
2261     {
2262         RETURN_NULL();
2263     }
2264
2265     geom = getRelay(zobj, Geometry_ce_ptr);
2266
2267     ret = (char*)GEOSWKBWriter_writeHEX(writer, geom, &retsize);
2268     /* we'll probably get an exception if ret is null */
2269     if ( ! ret ) RETURN_NULL();
2270
2271     retstr = estrndup(ret, retsize);
2272     GEOSFree(ret);
2273
2274     RETURN_STRING(retstr, 0);
2275 }
2276
2277 /**
2278  * long GEOSWKBWriter::getByteOrder();
2279  */
2280 PHP_METHOD(WKBWriter, getByteOrder)
2281 {
2282     GEOSWKBWriter *writer;
2283     long int ret;
2284
2285     writer = (GEOSWKBWriter*)getRelay(getThis(), WKBWriter_ce_ptr);
2286
2287     ret = GEOSWKBWriter_getByteOrder(writer);
2288
2289     RETURN_LONG(ret);
2290 }
2291
2292 /**
2293  * void GEOSWKBWriter::setByteOrder(dims);
2294  */
2295 PHP_METHOD(WKBWriter, setByteOrder)
2296 {
2297     GEOSWKBWriter *writer;
2298     long int dim;
2299
2300     writer = (GEOSWKBWriter*)getRelay(getThis(), WKBWriter_ce_ptr);
2301
2302     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &dim)
2303         == FAILURE)
2304     {
2305         RETURN_NULL();
2306     }
2307
2308     GEOSWKBWriter_setByteOrder(writer, dim);
2309
2310 }
2311
2312 /**
2313  * bool GEOSWKBWriter::getIncludeSRID();
2314  */
2315 PHP_METHOD(WKBWriter, getIncludeSRID)
2316 {
2317     GEOSWKBWriter *writer;
2318     int ret;
2319     zend_bool retBool;
2320
2321     writer = (GEOSWKBWriter*)getRelay(getThis(), WKBWriter_ce_ptr);
2322
2323     ret = GEOSWKBWriter_getIncludeSRID(writer);
2324     retBool = ret;
2325
2326     RETURN_BOOL(retBool);
2327 }
2328
2329 /**
2330  * void GEOSWKBWriter::setIncludeSRID(bool);
2331  */
2332 PHP_METHOD(WKBWriter, setIncludeSRID)
2333 {
2334     GEOSWKBWriter *writer;
2335     int inc;
2336     zend_bool incVal;
2337
2338     writer = (GEOSWKBWriter*)getRelay(getThis(), WKBWriter_ce_ptr);
2339
2340     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &incVal)
2341         == FAILURE)
2342     {
2343         RETURN_NULL();
2344     }
2345
2346     inc = incVal;
2347     GEOSWKBWriter_setIncludeSRID(writer, inc);
2348 }
2349
2350 /* -- class GEOSWKBReader -------------------- */
2351
2352 PHP_METHOD(WKBReader, __construct);
2353 PHP_METHOD(WKBReader, readHEX);
2354
2355 static function_entry WKBReader_methods[] = {
2356     PHP_ME(WKBReader, __construct, NULL, 0)
2357     PHP_ME(WKBReader, readHEX, NULL, 0)
2358     {NULL, NULL, NULL}
2359 };
2360
2361 static zend_class_entry *WKBReader_ce_ptr;
2362
2363 static zend_object_handlers WKBReader_object_handlers;
2364
2365 static void
2366 WKBReader_dtor (void *object TSRMLS_DC)
2367 {
2368     Proxy *obj = (Proxy *)object;
2369     GEOSWKBReader_destroy((GEOSWKBReader*)obj->relay);
2370
2371     zend_hash_destroy(obj->std.properties);
2372     FREE_HASHTABLE(obj->std.properties);
2373
2374     efree(obj);
2375 }
2376
2377 static zend_object_value
2378 WKBReader_create_obj (zend_class_entry *type TSRMLS_DC)
2379 {
2380     return Gen_create_obj(type, WKBReader_dtor, &WKBReader_object_handlers);
2381 }
2382
2383
2384 PHP_METHOD(WKBReader, __construct)
2385 {
2386     GEOSWKBReader* obj;
2387     zval *object = getThis();
2388
2389     obj = GEOSWKBReader_create();
2390     if ( ! obj ) {
2391         php_error_docref(NULL TSRMLS_CC, E_ERROR,
2392                 "GEOSWKBReader_create() failed (didn't initGEOS?)");
2393     }
2394
2395     setRelay(object, obj);
2396 }
2397
2398 PHP_METHOD(WKBReader, readHEX)
2399 {
2400     GEOSWKBReader *reader;
2401     GEOSGeometry *geom;
2402     unsigned char* wkb;
2403     int wkblen;
2404
2405     reader = (GEOSWKBReader*)getRelay(getThis(), WKBReader_ce_ptr);
2406
2407     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
2408         &wkb, &wkblen) == FAILURE)
2409     {
2410         RETURN_NULL();
2411     }
2412
2413     geom = GEOSWKBReader_readHEX(reader, wkb, wkblen);
2414     /* we'll probably get an exception if geom is null */
2415     if ( ! geom ) RETURN_NULL();
2416
2417     /* return_value is a zval */
2418     object_init_ex(return_value, Geometry_ce_ptr);
2419     setRelay(return_value, geom);
2420
2421 }
2422
2423
2424 /* -- Free functions ------------------------- */
2425
2426 /**
2427  * string GEOSVersion()
2428  */
2429 PHP_FUNCTION(GEOSVersion)
2430 {
2431     char *str;
2432
2433     str = estrdup(GEOSversion());
2434     RETURN_STRING(str, 0);
2435 }
2436
2437 /**
2438  * array GEOSPolygonize(GEOSGeometry $geom)
2439  *
2440  * The returned array contains the following elements:
2441  *
2442  *  - 'rings'
2443  *      Type: array of GEOSGeometry
2444  *      Rings that can be formed by the costituent
2445  *      linework of geometry.
2446  *  - 'cut_edges' (optional)
2447  *      Type: array of GEOSGeometry
2448  *      Edges which are connected at both ends but
2449  *      which do not form part of polygon.
2450  *  - 'dangles'
2451  *      Type: array of GEOSGeometry
2452  *      Edges which have one or both ends which are
2453  *      not incident on another edge endpoint
2454  *  - 'invalid_rings'
2455  *      Type: array of GEOSGeometry
2456  *      Edges which form rings which are invalid
2457  *      (e.g. the component lines contain a self-intersection)
2458  *
2459  */
2460 PHP_FUNCTION(GEOSPolygonize)
2461 {
2462     GEOSGeometry *this;
2463     GEOSGeometry *rings;
2464     GEOSGeometry *cut_edges;
2465     GEOSGeometry *dangles;
2466     GEOSGeometry *invalid_rings;
2467     zval *array_elem;
2468     zval *zobj;
2469
2470     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
2471         == FAILURE)
2472     {
2473         RETURN_NULL();
2474     }
2475     this = getRelay(zobj, Geometry_ce_ptr);
2476
2477     rings = GEOSPolygonize_full(this, &cut_edges, &dangles, &invalid_rings);
2478     if ( ! rings ) RETURN_NULL(); /* should get an exception first */
2479
2480     /* return value should be an array */
2481     array_init(return_value);
2482
2483     MAKE_STD_ZVAL(array_elem);
2484     array_init(array_elem);
2485     dumpGeometry(rings, array_elem);
2486     GEOSGeom_destroy(rings);
2487     add_assoc_zval(return_value, "rings", array_elem);
2488
2489     MAKE_STD_ZVAL(array_elem);
2490     array_init(array_elem);
2491     dumpGeometry(cut_edges, array_elem);
2492     GEOSGeom_destroy(cut_edges);
2493     add_assoc_zval(return_value, "cut_edges", array_elem);
2494
2495     MAKE_STD_ZVAL(array_elem);
2496     array_init(array_elem);
2497     dumpGeometry(dangles, array_elem);
2498     GEOSGeom_destroy(dangles);
2499     add_assoc_zval(return_value, "dangles", array_elem);
2500
2501     MAKE_STD_ZVAL(array_elem);
2502     array_init(array_elem);
2503     dumpGeometry(invalid_rings, array_elem);
2504     GEOSGeom_destroy(invalid_rings);
2505     add_assoc_zval(return_value, "invalid_rings", array_elem);
2506
2507 }
2508
2509 /**
2510  * array GEOSLineMerge(GEOSGeometry $geom)
2511  */
2512 PHP_FUNCTION(GEOSLineMerge)
2513 {
2514     GEOSGeometry *geom_in;
2515     GEOSGeometry *geom_out;
2516     zval *zobj;
2517
2518     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &zobj)
2519         == FAILURE)
2520     {
2521         RETURN_NULL();
2522     }
2523     geom_in = getRelay(zobj, Geometry_ce_ptr);
2524
2525     geom_out = GEOSLineMerge(geom_in);
2526     if ( ! geom_out ) RETURN_NULL(); /* should get an exception first */
2527
2528     /* return value should be an array */
2529     array_init(return_value);
2530     dumpGeometry(geom_out, return_value);
2531     GEOSGeom_destroy(geom_out);
2532 }
2533
2534 /**
2535  * GEOSGeometry GEOSSharedPaths(GEOSGeometry $geom1, GEOSGeometry *geom2)
2536  */
2537 PHP_FUNCTION(GEOSSharedPaths)
2538 {
2539     GEOSGeometry *geom_in_1;
2540     GEOSGeometry *geom_in_2;
2541     GEOSGeometry *geom_out;
2542     zval *zobj1, *zobj2;
2543
2544     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "oo", &zobj1, &zobj2)
2545         == FAILURE)
2546     {
2547         RETURN_NULL();
2548     }
2549     geom_in_1 = getRelay(zobj1, Geometry_ce_ptr);
2550     geom_in_2 = getRelay(zobj2, Geometry_ce_ptr);
2551
2552     geom_out = GEOSSharedPaths(geom_in_1, geom_in_2);
2553     if ( ! geom_out ) RETURN_NULL(); /* should get an exception first */
2554
2555     /* return_value is a zval */
2556     object_init_ex(return_value, Geometry_ce_ptr);
2557     setRelay(return_value, geom_out);
2558 }
2559
2560 /**
2561  * bool GEOSRelateMatch(string matrix, string pattern)
2562  */
2563 PHP_FUNCTION(GEOSRelateMatch)
2564 {
2565     char* mat = NULL;
2566     int matlen;
2567     char* pat = NULL;
2568     int patlen;
2569     int ret;
2570     zend_bool retBool;
2571
2572     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss",
2573         &mat, &matlen, &pat, &patlen) == FAILURE)
2574     {
2575         RETURN_NULL();
2576     }
2577
2578     ret = GEOSRelatePatternMatch(mat, pat);
2579     if ( ret == 2 ) RETURN_NULL(); /* should get an exception first */
2580
2581     /* return_value is a zval */
2582     retBool = ret;
2583     RETURN_BOOL(retBool);
2584 }
2585
2586 /* ------ Initialization / Deinitialization / Meta ------------------ */
2587
2588 /* per-module initialization */
2589 PHP_MINIT_FUNCTION(geos)
2590 {
2591     zend_class_entry ce;
2592
2593     /* WKTReader */
2594     INIT_CLASS_ENTRY(ce, "GEOSWKTReader", WKTReader_methods);
2595     WKTReader_ce_ptr = zend_register_internal_class(&ce TSRMLS_CC);
2596     WKTReader_ce_ptr->create_object = WKTReader_create_obj;
2597     memcpy(&WKTReader_object_handlers,
2598         zend_get_std_object_handlers(), sizeof(zend_object_handlers));
2599     WKTReader_object_handlers.clone_obj = NULL;
2600
2601     /* WKTWriter */
2602     INIT_CLASS_ENTRY(ce, "GEOSWKTWriter", WKTWriter_methods);
2603     WKTWriter_ce_ptr = zend_register_internal_class(&ce TSRMLS_CC);
2604     WKTWriter_ce_ptr->create_object = WKTWriter_create_obj;
2605     memcpy(&WKTWriter_object_handlers,
2606         zend_get_std_object_handlers(), sizeof(zend_object_handlers));
2607     WKTWriter_object_handlers.clone_obj = NULL;
2608
2609     /* Geometry */
2610     INIT_CLASS_ENTRY(ce, "GEOSGeometry", Geometry_methods);
2611     Geometry_ce_ptr = zend_register_internal_class(&ce TSRMLS_CC);
2612     Geometry_ce_ptr->create_object = Geometry_create_obj;
2613     memcpy(&Geometry_object_handlers,
2614         zend_get_std_object_handlers(), sizeof(zend_object_handlers));
2615     Geometry_object_handlers.clone_obj = NULL;
2616     /* Geometry serialization */
2617     Geometry_ce_ptr->serialize = Geometry_serialize;
2618     Geometry_ce_ptr->unserialize = Geometry_deserialize;
2619
2620     /* WKBWriter */
2621     INIT_CLASS_ENTRY(ce, "GEOSWKBWriter", WKBWriter_methods);
2622     WKBWriter_ce_ptr = zend_register_internal_class(&ce TSRMLS_CC);
2623     WKBWriter_ce_ptr->create_object = WKBWriter_create_obj;
2624     memcpy(&WKBWriter_object_handlers,
2625         zend_get_std_object_handlers(), sizeof(zend_object_handlers));
2626     WKBWriter_object_handlers.clone_obj = NULL;
2627
2628     /* WKBReader */
2629     INIT_CLASS_ENTRY(ce, "GEOSWKBReader", WKBReader_methods);
2630     WKBReader_ce_ptr = zend_register_internal_class(&ce TSRMLS_CC);
2631     WKBReader_ce_ptr->create_object = WKBReader_create_obj;
2632     memcpy(&WKBReader_object_handlers,
2633         zend_get_std_object_handlers(), sizeof(zend_object_handlers));
2634     WKBReader_object_handlers.clone_obj = NULL;
2635
2636
2637     /* Constants */
2638     REGISTER_LONG_CONSTANT("GEOSBUF_CAP_ROUND",  GEOSBUF_CAP_ROUND,
2639         CONST_CS|CONST_PERSISTENT);
2640     REGISTER_LONG_CONSTANT("GEOSBUF_CAP_FLAT",   GEOSBUF_CAP_FLAT,
2641         CONST_CS|CONST_PERSISTENT);
2642     REGISTER_LONG_CONSTANT("GEOSBUF_CAP_SQUARE", GEOSBUF_CAP_SQUARE,
2643         CONST_CS|CONST_PERSISTENT);
2644     REGISTER_LONG_CONSTANT("GEOSBUF_JOIN_ROUND", GEOSBUF_JOIN_ROUND,
2645         CONST_CS|CONST_PERSISTENT);
2646     REGISTER_LONG_CONSTANT("GEOSBUF_JOIN_MITRE", GEOSBUF_JOIN_MITRE,
2647         CONST_CS|CONST_PERSISTENT);
2648     REGISTER_LONG_CONSTANT("GEOSBUF_JOIN_BEVEL", GEOSBUF_JOIN_BEVEL,
2649         CONST_CS|CONST_PERSISTENT);
2650
2651     REGISTER_LONG_CONSTANT("GEOS_POINT", GEOS_POINT,
2652         CONST_CS|CONST_PERSISTENT);
2653     REGISTER_LONG_CONSTANT("GEOS_LINESTRING", GEOS_LINESTRING,
2654         CONST_CS|CONST_PERSISTENT);
2655     REGISTER_LONG_CONSTANT("GEOS_LINEARRING", GEOS_LINEARRING,
2656         CONST_CS|CONST_PERSISTENT);
2657     REGISTER_LONG_CONSTANT("GEOS_POLYGON", GEOS_POLYGON,
2658         CONST_CS|CONST_PERSISTENT);
2659     REGISTER_LONG_CONSTANT("GEOS_MULTIPOINT", GEOS_MULTIPOINT,
2660         CONST_CS|CONST_PERSISTENT);
2661     REGISTER_LONG_CONSTANT("GEOS_MULTILINESTRING", GEOS_MULTILINESTRING,
2662         CONST_CS|CONST_PERSISTENT);
2663     REGISTER_LONG_CONSTANT("GEOS_MULTIPOLYGON", GEOS_MULTIPOLYGON,
2664         CONST_CS|CONST_PERSISTENT);
2665     REGISTER_LONG_CONSTANT("GEOS_GEOMETRYCOLLECTION", GEOS_GEOMETRYCOLLECTION,
2666         CONST_CS|CONST_PERSISTENT);
2667
2668     REGISTER_LONG_CONSTANT("GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE",
2669         GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE,
2670         CONST_CS|CONST_PERSISTENT);
2671
2672     REGISTER_LONG_CONSTANT("GEOSRELATE_BNR_MOD2", GEOSRELATE_BNR_MOD2,
2673         CONST_CS|CONST_PERSISTENT);
2674     REGISTER_LONG_CONSTANT("GEOSRELATE_BNR_OGC", GEOSRELATE_BNR_OGC,
2675         CONST_CS|CONST_PERSISTENT);
2676     REGISTER_LONG_CONSTANT("GEOSRELATE_BNR_ENDPOINT", GEOSRELATE_BNR_ENDPOINT,
2677         CONST_CS|CONST_PERSISTENT);
2678     REGISTER_LONG_CONSTANT("GEOSRELATE_BNR_MULTIVALENT_ENDPOINT",
2679         GEOSRELATE_BNR_MULTIVALENT_ENDPOINT,
2680         CONST_CS|CONST_PERSISTENT);
2681     REGISTER_LONG_CONSTANT("GEOSRELATE_BNR_MONOVALENT_ENDPOINT",
2682         GEOSRELATE_BNR_MONOVALENT_ENDPOINT,
2683         CONST_CS|CONST_PERSISTENT);
2684
2685     return SUCCESS;
2686 }
2687
2688 /* per-module shutdown */
2689 PHP_MSHUTDOWN_FUNCTION(geos)
2690 {
2691     delGeometrySerializer();
2692     delGeometryDeserializer();
2693     return SUCCESS;
2694 }
2695
2696 /* per-request initialization */
2697 PHP_RINIT_FUNCTION(geos)
2698 {
2699     initGEOS(noticeHandler, errorHandler);
2700     return SUCCESS;
2701 }
2702
2703 /* pre-request destruction */
2704 PHP_RSHUTDOWN_FUNCTION(geos)
2705 {
2706     finishGEOS();
2707     return SUCCESS;
2708 }
2709
2710 /* module info */
2711 PHP_MINFO_FUNCTION(geos)
2712 {
2713     php_info_print_table_start();
2714     php_info_print_table_row(2,
2715         "GEOS - Geometry Engine Open Source", "enabled");
2716     php_info_print_table_row(2,
2717         "Version", PHP_GEOS_VERSION);
2718     php_info_print_table_end();
2719 }
2720