git.m6w6.name Git - awesomized/ext-ion/blob - ion.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: ion                                                        |
   4     +--------------------------------------------------------------------+
   5     | Redistribution and use in source and binary forms, with or without |
   6     | modification, are permitted provided that the conditions mentioned |
   7     | in the accompanying LICENSE file are met.                          |
   8     +--------------------------------------------------------------------+
   9     | Copyright (c) 2021, Michael Wallner <mike@php.net>                 |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include "config.h"
  15 #endif
  16
  17 #include "php.h"
  18 #include "ext/standard/info.h"
  19
  20 #include "Zend/zend_enum.h"
  21 #include "Zend/zend_exceptions.h"
  22 #include "Zend/zend_closures.h"
  23 #include "Zend/zend_interfaces.h"
  24 #include "Zend/zend_smart_str.h"
  25
  26 #include "ext/date/php_date.h"
  27 #include "ext/spl/spl_exceptions.h"
  28 #include "ext/spl/spl_iterators.h"
  29
  30 #include "php_ion.h"
  31 #include "ion_private.h"
  32
  33 static ZEND_METHOD(ion_Symbol_ImportLocation, __construct)
  34 {
  35         php_ion_symbol_iloc *obj = php_ion_obj(symbol_iloc, Z_OBJ_P(ZEND_THIS));
  36         PTR_CHECK(obj);
  37
  38         zend_long location;
  39         ZEND_PARSE_PARAMETERS_START(2, 2)
  40                 Z_PARAM_STR(obj->name)
  41                 Z_PARAM_LONG(location)
  42         ZEND_PARSE_PARAMETERS_END();
  43
  44         obj->loc.location = location;
  45         php_ion_symbol_iloc_ctor(obj);
  46 }
  47 static ZEND_METHOD(ion_Symbol, __construct)
  48 {
  49         php_ion_symbol *obj = php_ion_obj(symbol, Z_OBJ_P(ZEND_THIS));
  50         PTR_CHECK(obj);
  51
  52         zend_long sid = -1;
  53         ZEND_PARSE_PARAMETERS_START(0, 3)
  54                 Z_PARAM_OPTIONAL
  55                 Z_PARAM_STR_OR_NULL(obj->value)
  56                 Z_PARAM_LONG(sid)
  57                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->iloc, ce_Symbol_ImportLocation)
  58         ZEND_PARSE_PARAMETERS_END();
  59
  60         obj->sym.sid = sid;
  61         php_ion_symbol_ctor(obj);
  62 }
  63 static ZEND_METHOD(ion_Symbol, equals)
  64 {
  65         php_ion_symbol *sym = php_ion_obj(symbol, Z_OBJ_P(ZEND_THIS));
  66         OBJ_CHECK(sym);
  67
  68         zend_object *other_obj;
  69         ZEND_PARSE_PARAMETERS_START(1, 1)
  70                 Z_PARAM_OBJ_OF_CLASS(other_obj, ce_Symbol)
  71         ZEND_PARSE_PARAMETERS_END();
  72
  73         BOOL eq = FALSE;
  74         iERR err = ion_symbol_is_equal(
  75                 &sym->sym,
  76                 &php_ion_obj(symbol, other_obj)->sym, &eq);
  77         ION_CHECK(err);
  78         RETVAL_BOOL(eq);
  79 }
  80 static ZEND_METHOD(ion_Symbol, __toString)
  81 {
  82         php_ion_symbol *sym = php_ion_obj(symbol, Z_OBJ_P(ZEND_THIS));
  83         OBJ_CHECK(sym);
  84
  85         ZEND_PARSE_PARAMETERS_NONE();
  86
  87         if (!sym->value) {
  88                 RETURN_EMPTY_STRING();
  89         }
  90         RETURN_STR_COPY(sym->value);
  91 }
  92 static ZEND_METHOD(ion_Symbol_Enum, toSymbol)
  93 {
  94         ZEND_PARSE_PARAMETERS_NONE();
  95
  96         zval *zc = zend_enum_fetch_case_name(Z_OBJ_P(ZEND_THIS));
  97         PTR_CHECK(zc);
  98
  99         zval *zsym = php_ion_global_symbol_fetch_by_enum(Z_STR_P(zc));
 100         PTR_CHECK(zsym);
 101         RETVAL_ZVAL(zsym, 1, 0);
 102 }
 103 static ZEND_METHOD(ion_Symbol_Enum, toSID)
 104 {
 105         ZEND_PARSE_PARAMETERS_NONE();
 106
 107         zval *zc = zend_enum_fetch_case_name(Z_OBJ_P(ZEND_THIS));
 108         PTR_CHECK(zc);
 109
 110         zval *zsym = php_ion_global_symbol_fetch_by_enum(Z_STR_P(zc));
 111         PTR_CHECK(zsym);
 112
 113         zval tmp;
 114         RETVAL_ZVAL(zend_read_property(Z_OBJCE_P(zsym), Z_OBJ_P(zsym), ZEND_STRL("sid"), 0, &tmp), 1, 0);
 115 }
 116 static ZEND_METHOD(ion_Symbol_Enum, toString)
 117 {
 118         ZEND_PARSE_PARAMETERS_NONE();
 119
 120         zval *zc = zend_enum_fetch_case_name(Z_OBJ_P(ZEND_THIS));
 121         PTR_CHECK(zc);
 122
 123         zval *zsym = php_ion_global_symbol_fetch_by_enum(Z_STR_P(zc));
 124         PTR_CHECK(zsym);
 125
 126         zval tmp;
 127         RETVAL_ZVAL(zend_read_property(Z_OBJCE_P(zsym), Z_OBJ_P(zsym), ZEND_STRL("value"), 0, &tmp), 1, 0);
 128 }
 129 static ZEND_FUNCTION(ion_Symbol_Table_System)
 130 {
 131         ZEND_PARSE_PARAMETERS_NONE();
 132
 133         object_init_ex(return_value, ce_Symbol_Table_Shared);
 134         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(return_value));
 135         ION_CHECK(ion_symbol_table_get_system_table(&obj->tab, 1));
 136         php_ion_symbol_table_ctor(obj);
 137         ion_symbol_table_lock(obj->tab);
 138 }
 139 static ZEND_FUNCTION(ion_Symbol_Table_PHP)
 140 {
 141         ZEND_PARSE_PARAMETERS_NONE();
 142
 143         object_init_ex(return_value, ce_Symbol_Table_Shared);
 144         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(return_value));
 145         obj->tab = g_sym_tab_php;
 146         php_ion_symbol_table_ctor(obj);
 147         ion_symbol_table_lock(obj->tab);
 148 }
 149 static ZEND_METHOD(ion_Symbol_Table_Local, __construct)
 150 {
 151         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 152         PTR_CHECK(obj);
 153
 154         ZEND_PARSE_PARAMETERS_NONE();
 155
 156         ION_CHECK(ion_symbol_table_open_with_type(&obj->tab, NULL, ist_LOCAL));
 157         obj->dtor = ion_symbol_table_close;
 158         OBJ_CHECK(obj);
 159 }
 160 static ZEND_METHOD(ion_Symbol_Table_Local, import)
 161 {
 162         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 163         OBJ_CHECK(obj);
 164
 165         zend_object *zo_import;
 166         ZEND_PARSE_PARAMETERS_START(1, 1)
 167                 Z_PARAM_OBJ_OF_CLASS(zo_import, ce_Symbol_Table);
 168         ZEND_PARSE_PARAMETERS_END();
 169
 170         php_ion_symbol_table_import(obj, php_ion_obj(symbol_table, zo_import));
 171 }
 172 static ZEND_METHOD(ion_Symbol_Table_Shared, __construct)
 173 {
 174         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 175         PTR_CHECK(obj);
 176
 177         zend_string *zname;
 178         zend_long version = 1;
 179         HashTable *ht_sym = NULL;
 180         ZEND_PARSE_PARAMETERS_START(1, 3)
 181                 Z_PARAM_STR(zname)
 182                 Z_PARAM_OPTIONAL
 183                 Z_PARAM_LONG(version)
 184                 Z_PARAM_ARRAY_HT_OR_NULL(ht_sym)
 185         ZEND_PARSE_PARAMETERS_END();
 186
 187         ION_CHECK(ion_symbol_table_open_with_type(&obj->tab, NULL, ist_SHARED));
 188         obj->dtor = ion_symbol_table_close;
 189
 190         ION_STRING is;
 191         ION_CHECK(ion_symbol_table_set_name(obj->tab, ion_string_from_zend(&is, zname)));
 192         ION_CHECK(ion_symbol_table_set_version(obj->tab, version));
 193
 194         php_ion_symbol_table_ctor(obj);
 195
 196         zval *zsym;
 197         if (ht_sym) ZEND_HASH_FOREACH_VAL(ht_sym, zsym)
 198         {
 199                 zend_string *str = zval_get_string(zsym);
 200                 if (EG(exception)) {
 201                         break;
 202                 }
 203
 204                 ION_STRING is;
 205                 ION_CHECK(ion_symbol_table_add_symbol(obj->tab, ion_string_from_zend(&is, str), NULL), zend_string_release(str));
 206                 zend_string_release(str);
 207         }
 208         ZEND_HASH_FOREACH_END();
 209 }
 210 static ZEND_METHOD(ion_Symbol_Table, getMaxId)
 211 {
 212         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 213         OBJ_CHECK(obj);
 214
 215         ZEND_PARSE_PARAMETERS_NONE();
 216
 217         SID max_sid;
 218         ION_CHECK(ion_symbol_table_get_max_sid(obj->tab, &max_sid));
 219         RETURN_LONG(max_sid);
 220 }
 221 static ZEND_METHOD(ion_Symbol_Table, add)
 222 {
 223         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 224         OBJ_CHECK(obj);
 225
 226         zend_object *zo_sym = NULL;
 227         zend_string *zs_sym = NULL;
 228         ZEND_PARSE_PARAMETERS_START(1, 1)
 229                 Z_PARAM_OBJ_OF_CLASS_OR_STR(zo_sym, ce_Symbol, zs_sym)
 230         ZEND_PARSE_PARAMETERS_END();
 231
 232         if (zo_sym) {
 233                 zval z_sym;
 234                 ZVAL_OBJ(&z_sym, zo_sym);
 235                 zs_sym = zval_get_string(&z_sym);
 236                 ION_CATCH();
 237         }
 238         SID sid;
 239         ION_STRING is;
 240         ION_CHECK(ion_symbol_table_add_symbol(obj->tab, ion_string_from_zend(&is, zs_sym), &sid),
 241                         if (zo_sym) {
 242                                 zend_string_release(zs_sym);
 243                         });
 244         if (zo_sym) {
 245                 zend_string_release(zs_sym);
 246         }
 247         RETURN_LONG(sid);
 248 }
 249 static ZEND_METHOD(ion_Symbol_Table, find)
 250 {
 251         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 252         OBJ_CHECK(obj);
 253
 254         zend_long zsid;
 255         zend_string *zstring = NULL;
 256         ZEND_PARSE_PARAMETERS_START(1, 1)
 257                 Z_PARAM_STR_OR_LONG(zstring, zsid)
 258         ZEND_PARSE_PARAMETERS_END();
 259
 260         if (zstring) {
 261                 SID sid;
 262                 ION_STRING is;
 263                 ION_CHECK(ion_symbol_table_find_by_name(obj->tab, ion_string_from_zend(&is, zstring), &sid));
 264                 zsid = sid;
 265         }
 266         ION_SYMBOL *sym;
 267         ION_CHECK(ion_symbol_table_get_symbol(obj->tab, zsid, &sym));
 268         if (sym) {
 269                 php_ion_symbol_table_symbol_zval(obj, sym, return_value);
 270         }
 271 }
 272 static ZEND_METHOD(ion_Symbol_Table, findLocal)
 273 {
 274         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 275         OBJ_CHECK(obj);
 276
 277         zend_long zsid;
 278         zend_string *zstring;
 279         ZEND_PARSE_PARAMETERS_START(1, 1)
 280                 Z_PARAM_STR_OR_LONG(zstring, zsid)
 281         ZEND_PARSE_PARAMETERS_END();
 282
 283         if (zstring) {
 284                 SID sid;
 285                 ION_STRING is;
 286                 ION_CHECK(ion_symbol_table_find_by_name(obj->tab, ion_string_from_zend(&is, zstring), &sid));
 287                 zsid = sid;
 288         }
 289         ION_SYMBOL *sym;
 290         ION_CHECK(ion_symbol_table_get_local_symbol(obj->tab, zsid, &sym));
 291         if (sym) {
 292                 php_ion_symbol_table_symbol_zval(obj, sym, return_value);
 293         }
 294 }
 295 static ZEND_METHOD(ion_Catalog, __construct)
 296 {
 297         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 298         PTR_CHECK(obj);
 299
 300         ZEND_PARSE_PARAMETERS_NONE();
 301
 302         php_ion_catalog_ctor(obj);
 303 }
 304 static ZEND_METHOD(ion_Catalog, count)
 305 {
 306         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 307         OBJ_CHECK(obj);
 308
 309         ZEND_PARSE_PARAMETERS_NONE();
 310
 311         int32_t c;
 312         ION_CHECK(ion_catalog_get_symbol_table_count(obj->cat, &c));
 313         RETURN_LONG(c);
 314 }
 315 static ZEND_METHOD(ion_Catalog, add)
 316 {
 317         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 318         OBJ_CHECK(obj);
 319
 320         zend_object *zo_symtab;
 321         ZEND_PARSE_PARAMETERS_START(1, 1)
 322                 Z_PARAM_OBJ_OF_CLASS(zo_symtab, ce_Symbol_Table)
 323         ZEND_PARSE_PARAMETERS_END();
 324
 325         php_ion_symbol_table *o_symtab = php_ion_obj(symbol_table, zo_symtab);
 326         php_ion_catalog_add_symbol_table(obj, o_symtab);
 327 }
 328
 329 static ZEND_METHOD(ion_Catalog, remove)
 330 {
 331         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 332         OBJ_CHECK(obj);
 333
 334         zend_object *zo_symtab = NULL;
 335         zend_string *zs_symtab = NULL;
 336         ZEND_PARSE_PARAMETERS_START(1, 1)
 337                 Z_PARAM_OBJ_OF_CLASS_OR_STR(zo_symtab, ce_Symbol_Table, zs_symtab)
 338         ZEND_PARSE_PARAMETERS_END();
 339
 340         RETVAL_FALSE;
 341
 342         zval tmp;
 343         zval *ztabs = zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("symbolTables"), 0, &tmp);
 344         if (ztabs) {
 345                 if (zo_symtab) {
 346                         // fast path
 347                         zend_ulong idx = (uintptr_t) &zo_symtab->gc;
 348                         RETVAL_BOOL(SUCCESS == zend_hash_index_del(Z_ARRVAL_P(ztabs), idx));
 349                         ION_CHECK(ion_catalog_release_symbol_table(obj->cat, php_ion_obj(symbol_table, zo_symtab)->tab));
 350                 } else {
 351                         bool deleted = false;
 352                         ION_SYMBOL_TABLE *tab;
 353                         ION_STRING is;
 354                         ion_string_from_zend(&is, zs_symtab);
 355                         do {
 356                                 tab = NULL;
 357                                 ION_CHECK(ion_catalog_find_best_match(obj->cat, &is, 0, &tab));
 358                                 if (tab) {
 359                                         ION_CHECK(ion_catalog_release_symbol_table(obj->cat, tab));
 360                                         deleted = true;
 361                                 }
 362                         } while(tab);
 363                         RETVAL_BOOL(deleted);
 364                 }
 365         }
 366 }
 367 static ZEND_METHOD(ion_Catalog, find)
 368 {
 369         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 370         OBJ_CHECK(obj);
 371
 372         zend_long zversion = 0;
 373         zend_string *zname;
 374         ZEND_PARSE_PARAMETERS_START(1, 2)
 375                 Z_PARAM_STR(zname)
 376                 Z_PARAM_OPTIONAL
 377                 Z_PARAM_LONG(zversion)
 378         ZEND_PARSE_PARAMETERS_END();
 379
 380         ION_STRING is;
 381         ION_SYMBOL_TABLE *tab_ptr = NULL;
 382         ION_CHECK(ion_catalog_find_symbol_table(obj->cat, ion_string_from_zend(&is, zname), zversion, &tab_ptr));
 383         if (tab_ptr) {
 384                 php_ion_catalog_symbol_table_zval(obj, tab_ptr, return_value);
 385         }
 386 }
 387 static ZEND_METHOD(ion_Catalog, findBest)
 388 {
 389         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 390         OBJ_CHECK(obj);
 391
 392         zend_long zversion = 0;
 393         zend_string *zname;
 394         ZEND_PARSE_PARAMETERS_START(1, 2)
 395                 Z_PARAM_STR(zname)
 396                 Z_PARAM_OPTIONAL
 397                 Z_PARAM_LONG(zversion)
 398         ZEND_PARSE_PARAMETERS_END();
 399
 400         ION_STRING is;
 401         ION_SYMBOL_TABLE *tab_ptr = NULL;
 402         ION_CHECK(ion_catalog_find_best_match(obj->cat, ion_string_from_zend(&is, zname), zversion, &tab_ptr));
 403         if (tab_ptr) {
 404                 php_ion_catalog_symbol_table_zval(obj, tab_ptr, return_value);
 405         }
 406 }
 407 static ZEND_METHOD(ion_Timestamp, __construct)
 408 {
 409         php_ion_timestamp *obj = php_ion_obj(timestamp, Z_OBJ_P(ZEND_THIS));
 410         PTR_CHECK(obj);
 411
 412         zend_long precision;
 413         zend_object *precision_obj;
 414         zend_string *fmt = NULL, *dt = NULL;
 415         zval *tz = NULL;
 416         ZEND_PARSE_PARAMETERS_START(1, 4)
 417                 Z_PARAM_OBJ_OF_CLASS_OR_LONG(precision_obj, ce_Timestamp_Precision, precision)
 418                 Z_PARAM_OPTIONAL
 419                 Z_PARAM_STR_OR_NULL(fmt)
 420                 Z_PARAM_STR_OR_NULL(dt)
 421                 Z_PARAM_ZVAL(tz)
 422         ZEND_PARSE_PARAMETERS_END();
 423
 424         if (precision_obj) {
 425                 precision = Z_LVAL_P(zend_enum_fetch_case_value(precision_obj));
 426         }
 427         php_ion_timestamp_ctor(obj, precision, fmt, dt, tz);
 428 }
 429 static ZEND_METHOD(ion_Timestamp, __toString)
 430 {
 431         php_ion_timestamp *obj = php_ion_obj(timestamp, Z_OBJ_P(ZEND_THIS));
 432         OBJ_CHECK(obj);
 433
 434         ZEND_PARSE_PARAMETERS_NONE();
 435
 436         zval fmt;
 437         ZVAL_NULL(&fmt);
 438         zend_call_method_with_1_params(&obj->std, obj->std.ce, NULL, "format", return_value,
 439                 zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("format"), 0, &fmt));
 440 }
 441 static ZEND_METHOD(ion_Decimal_Context, __construct)
 442 {
 443         php_ion_decimal_ctx *obj = php_ion_obj(decimal_ctx, Z_OBJ_P(ZEND_THIS));
 444         PTR_CHECK(obj);
 445
 446         zend_bool clamp;
 447         zend_object *o_round = NULL;
 448         zend_long digits, emax, emin, round;
 449         ZEND_PARSE_PARAMETERS_START(5, 5)
 450                 Z_PARAM_LONG(digits)
 451                 Z_PARAM_LONG(emax)
 452                 Z_PARAM_LONG(emin)
 453                 Z_PARAM_OBJ_OF_CLASS_OR_LONG(o_round, ce_Decimal_Context_Rounding, round)
 454                 Z_PARAM_BOOL(clamp)
 455         ZEND_PARSE_PARAMETERS_END();
 456
 457         if (o_round) {
 458                 round = Z_LVAL_P(zend_enum_fetch_case_value(o_round));
 459         }
 460         php_ion_decimal_ctx_init(&obj->ctx, digits, emax, emin, round, clamp);
 461         php_ion_decimal_ctx_ctor(obj, o_round);
 462 }
 463 static inline void make_decimal_ctx(INTERNAL_FUNCTION_PARAMETERS, int kind)
 464 {
 465         ZEND_PARSE_PARAMETERS_NONE();
 466
 467         object_init_ex(return_value, ce_Decimal_Context);
 468         php_ion_decimal_ctx *obj = php_ion_obj(decimal_ctx, Z_OBJ_P(return_value));
 469         decContextDefault(&obj->ctx, kind);
 470         php_ion_decimal_ctx_ctor(obj, NULL);
 471 }
 472 static ZEND_METHOD(ion_Decimal_Context, Dec32)
 473 {
 474         make_decimal_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, DEC_INIT_DECIMAL32);
 475 }
 476 static ZEND_METHOD(ion_Decimal_Context, Dec64)
 477 {
 478         make_decimal_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, DEC_INIT_DECIMAL64);
 479 }
 480 static ZEND_METHOD(ion_Decimal_Context, Dec128)
 481 {
 482         make_decimal_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, DEC_INIT_DECIMAL128);
 483 }
 484 static ZEND_METHOD(ion_Decimal_Context, DecMax)
 485 {
 486         zend_object *o_round = NULL;
 487         zend_long round = DEC_ROUND_HALF_EVEN;
 488         ZEND_PARSE_PARAMETERS_START(0, 1)
 489                 Z_PARAM_OPTIONAL
 490                 Z_PARAM_OBJ_OF_CLASS_OR_LONG(o_round, ce_Decimal_Context_Rounding, round)
 491         ZEND_PARSE_PARAMETERS_END();
 492
 493         if (o_round) {
 494                 round = Z_LVAL_P(zend_enum_fetch_case_value(o_round));
 495         }
 496         object_init_ex(return_value, ce_Decimal_Context);
 497         php_ion_decimal_ctx *obj = php_ion_obj(decimal_ctx, Z_OBJ_P(return_value));
 498         php_ion_decimal_ctx_init_max(&obj->ctx, round);
 499         php_ion_decimal_ctx_ctor(obj, o_round);
 500 }
 501 static ZEND_METHOD(ion_Decimal, __construct)
 502 {
 503         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 504         PTR_CHECK(obj);
 505
 506         zend_long num;
 507         zend_string *zstr;
 508         ZEND_PARSE_PARAMETERS_START(1, 2)
 509                 Z_PARAM_STR_OR_LONG(zstr, num)
 510                 Z_PARAM_OPTIONAL
 511                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->ctx, ce_Decimal_Context)
 512         ZEND_PARSE_PARAMETERS_END();
 513
 514         if (obj->ctx) {
 515                 GC_ADDREF(obj->ctx);
 516         } else {
 517                 zval zdc;
 518                 object_init_ex(&zdc, ce_Decimal_Context);
 519                 obj->ctx = Z_OBJ(zdc);
 520                 php_ion_decimal_ctx_ctor(php_ion_obj(decimal_ctx, obj->ctx), NULL);
 521         }
 522
 523         decContext *ctx = &php_ion_obj(decimal_ctx, obj->ctx)->ctx;
 524
 525         if (zstr) {
 526                 ION_CHECK(ion_decimal_from_string(&obj->dec, zstr->val, ctx), OBJ_RELEASE(obj->ctx));
 527         } else {
 528                 php_ion_decimal_from_zend_long(&obj->dec, ctx, num);
 529         }
 530
 531         php_ion_decimal_ctor(obj);
 532         OBJ_RELEASE(obj->ctx);
 533 }
 534 static ZEND_METHOD(ion_Decimal, equals)
 535 {
 536         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 537         PTR_CHECK(obj);
 538
 539         zend_object *dec_obj;
 540         ZEND_PARSE_PARAMETERS_START(1, 1)
 541                 Z_PARAM_OBJ_OF_CLASS(dec_obj, ce_Decimal)
 542         ZEND_PARSE_PARAMETERS_END();
 543
 544         BOOL is = FALSE;
 545         ION_CHECK(ion_decimal_equals(&obj->dec, &php_ion_obj(decimal, dec_obj)->dec,
 546                 obj->ctx ? &php_ion_obj(decimal_ctx, obj->ctx)->ctx : NULL, &is));
 547         RETURN_BOOL(is);
 548 }
 549 static ZEND_METHOD(ion_Decimal, __toString)
 550 {
 551         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 552         PTR_CHECK(obj);
 553
 554         ZEND_PARSE_PARAMETERS_NONE();
 555
 556         RETURN_STR(php_ion_decimal_to_string(&obj->dec));
 557 }
 558 static ZEND_METHOD(ion_Decimal, toInt)
 559 {
 560         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 561         PTR_CHECK(obj);
 562
 563         ZEND_PARSE_PARAMETERS_NONE();
 564
 565         zend_long l;
 566         php_ion_decimal_to_zend_long(&obj->dec, &php_ion_obj(decimal_ctx, obj->ctx)->ctx, &l);
 567         RETURN_LONG(l);
 568 }
 569 static ZEND_METHOD(ion_Decimal, isInt)
 570 {
 571         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 572         PTR_CHECK(obj);
 573
 574         ZEND_PARSE_PARAMETERS_NONE();
 575
 576         RETURN_BOOL(ion_decimal_is_integer(&obj->dec));
 577 }
 578 static ZEND_METHOD(ion_LOB, __construct)
 579 {
 580         zend_string *value;
 581         zend_object *type = NULL;
 582         ZEND_PARSE_PARAMETERS_START(1, 2)
 583                 Z_PARAM_STR(value)
 584                 Z_PARAM_OPTIONAL
 585                 Z_PARAM_OBJ_OF_CLASS(type, ce_Type)
 586         ZEND_PARSE_PARAMETERS_END();
 587
 588         if (!type) {
 589                 type = zend_enum_get_case_cstr(ce_Type, "CLob");
 590         }
 591         update_property_obj(Z_OBJ_P(ZEND_THIS), ZEND_STRL("type"), type);
 592         zend_update_property_str(Z_OBJCE_P(ZEND_THIS), Z_OBJ_P(ZEND_THIS), ZEND_STRL("value"), value);
 593 }
 594 static ZEND_METHOD(ion_Reader_Options, __construct)
 595 {
 596         php_ion_reader_options *opt = php_ion_obj(reader_options, Z_OBJ_P(ZEND_THIS));
 597         zend_bool ret_sys_val = false, skip_validation = false;
 598         zend_long ch_nl = 0xa, max_depth = 10, max_ann = 10, max_ann_buf = 512,
 599                         sym_thr = 0x4000, uval_thr = 0x4000, chunk_thr = 0x4000, alloc_pgsz = 0x10000;
 600
 601         PTR_CHECK(opt);
 602
 603         ZEND_PARSE_PARAMETERS_START(0, 13)
 604                 Z_PARAM_OPTIONAL
 605         // public readonly ?\ion\Catalog $catalog = null,
 606                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(opt->cat, ce_Catalog)
 607         // public readonly ?\ion\Decimal\Context $decimalContext = null,
 608                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(opt->dec_ctx, ce_Decimal_Context)
 609         // public readonly ?\Closure $onContextChange = null,
 610                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(opt->cb, zend_ce_closure);
 611         // public readonly bool $returnSystemValues = false,
 612                 Z_PARAM_BOOL(ret_sys_val)
 613         // public readonly int $newLine = 0xa,
 614                 Z_PARAM_LONG(ch_nl)
 615         // public readonly int $maxContainerDepth = 10,
 616                 Z_PARAM_LONG(max_depth)
 617         // public readonly int $maxAnnotations = 10,
 618                 Z_PARAM_LONG(max_ann)
 619         // public readonly int $maxAnnotationBuffered = 512,
 620                 Z_PARAM_LONG(max_ann_buf)
 621         // public readonly int $symbolThreshold = 0x4000,
 622                 Z_PARAM_LONG(sym_thr)
 623         // public readonly int $userValueThreshold = 0x4000,
 624                 Z_PARAM_LONG(uval_thr)
 625         // public readonly int $chunkThreshold = 0x4000,
 626                 Z_PARAM_LONG(chunk_thr)
 627         // public readonly int $allocationPageSize = 0x10000,
 628                 Z_PARAM_LONG(alloc_pgsz)
 629         // public readonly bool $skipCharacterValidation = false,
 630                 Z_PARAM_BOOL(skip_validation)
 631         ZEND_PARSE_PARAMETERS_END();
 632
 633         opt->opt.context_change_notifier = EMPTY_READER_CHANGE_NOTIFIER;
 634         if (opt->cb) {
 635                 update_property_obj(&opt->std, ZEND_STRL("onContextChange"), opt->cb);
 636         }
 637         if (opt->cat) {
 638                 update_property_obj(&opt->std, ZEND_STRL("catalog"), opt->cat);
 639                 opt->opt.pcatalog = php_ion_obj(catalog, opt->cat)->cat;
 640         }
 641         if (opt->dec_ctx) {
 642                 update_property_obj(&opt->std, ZEND_STRL("decimalContext"), opt->dec_ctx);
 643                 opt->opt.decimal_context = &php_ion_obj(decimal_ctx, opt->dec_ctx)->ctx;
 644         }
 645         zend_update_property_bool(opt->std.ce, &opt->std, ZEND_STRL("returnSystemValues"),
 646                 opt->opt.return_system_values = ret_sys_val);
 647         zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("newLine"),
 648                 opt->opt.new_line_char = ch_nl);
 649         zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("maxContainerDepth"),
 650                 opt->opt.max_container_depth = max_depth);
 651         zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("maxAnnotationCount"),
 652                 opt->opt.max_annotation_count = max_ann);
 653         zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("maxAnnotationBuffered"),
 654                 opt->opt.max_annotation_buffered = max_ann_buf);
 655         zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("symbolThreshold"),
 656                 opt->opt.symbol_threshold = sym_thr);
 657         zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("userValueThreshold"),
 658                 opt->opt.user_value_threshold = uval_thr);
 659         zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("chunkThreshold"),
 660                 opt->opt.chunk_threshold = chunk_thr);
 661         zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("allocationPageSize"),
 662                 opt->opt.allocation_page_size = alloc_pgsz);
 663         zend_update_property_long(opt->std.ce, &opt->std, ZEND_STRL("skipCharacterValidation"),
 664                 opt->opt.skip_character_validation = skip_validation);
 665 }
 666 static ZEND_METHOD(ion_Reader_Reader, hasChildren)
 667 {
 668         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 669
 670         OBJ_CHECK(obj);
 671         ZEND_PARSE_PARAMETERS_NONE();
 672
 673         ION_TYPE t;
 674         ION_CHECK(ion_reader_get_type(obj->reader, &t));
 675         switch (ION_TYPE_INT(t)) {
 676                 case tid_LIST_INT:
 677                 case tid_SEXP_INT:
 678                 case tid_STRUCT_INT:
 679                         RETVAL_TRUE;
 680                         break;
 681                 default:
 682                         RETVAL_FALSE;
 683                         break;
 684         }
 685 }
 686 static ZEND_METHOD(ion_Reader_Reader, getChildren)
 687 {
 688         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 689         OBJ_CHECK(obj);
 690
 691         ZEND_PARSE_PARAMETERS_NONE();
 692
 693         ION_CHECK(ion_reader_step_in(obj->reader));
 694
 695         RETURN_ZVAL(ZEND_THIS, 1, 0);
 696 }
 697 static ZEND_METHOD(ion_Reader_Reader, rewind)
 698 {
 699         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 700         OBJ_CHECK(obj);
 701
 702         ZEND_PARSE_PARAMETERS_NONE();
 703
 704         ION_CHECK(ion_reader_next(obj->reader, &obj->state));
 705 }
 706 static ZEND_METHOD(ion_Reader_Reader, next)
 707 {
 708         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 709         OBJ_CHECK(obj);
 710
 711         ZEND_PARSE_PARAMETERS_NONE();
 712
 713         if (obj->state == tid_EOF) {
 714                 SIZE depth = 0;
 715                 ION_CHECK(ion_reader_get_depth(obj->reader, &depth));
 716                 if (depth) {
 717                         ION_CHECK(ion_reader_step_out(obj->reader));
 718                 }
 719         }
 720         ION_CHECK(ion_reader_next(obj->reader, &obj->state));
 721 }
 722 static ZEND_METHOD(ion_Reader_Reader, valid)
 723 {
 724         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 725         OBJ_CHECK(obj);
 726
 727         ZEND_PARSE_PARAMETERS_NONE();
 728         RETURN_BOOL(obj->state != tid_none && obj->state != tid_EOF);
 729 }
 730 static ZEND_METHOD(ion_Reader_Reader, key)
 731 {
 732         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 733         OBJ_CHECK(obj);
 734
 735         ZEND_PARSE_PARAMETERS_NONE();
 736         RETURN_IONTYPE(obj->state);
 737 }
 738 static ZEND_METHOD(ion_Reader_Reader, current)
 739 {
 740         ZEND_PARSE_PARAMETERS_NONE();
 741         RETURN_ZVAL(ZEND_THIS, 1, 0);
 742 }
 743 static ZEND_METHOD(ion_Reader_Reader, getType)
 744 {
 745         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 746         OBJ_CHECK(obj);
 747
 748         ZEND_PARSE_PARAMETERS_NONE();
 749
 750         ION_TYPE typ;
 751         ION_CHECK(ion_reader_get_type(obj->reader, &typ));
 752         RETURN_IONTYPE(typ);
 753 }
 754 static ZEND_METHOD(ion_Reader_Reader, hasAnnotations)
 755 {
 756         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 757         OBJ_CHECK(obj);
 758
 759         ZEND_PARSE_PARAMETERS_NONE();
 760
 761         BOOL has = FALSE;
 762         ION_CHECK(ion_reader_has_any_annotations(obj->reader, &has));
 763         RETURN_BOOL(has);
 764 }
 765 static ZEND_METHOD(ion_Reader_Reader, hasAnnotation)
 766 {
 767         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 768         OBJ_CHECK(obj);
 769
 770         zend_string *ann_zstr;
 771         ZEND_PARSE_PARAMETERS_START(1, 1);
 772                 Z_PARAM_STR(ann_zstr);
 773         ZEND_PARSE_PARAMETERS_END();
 774
 775         ION_STRING ann_istr;
 776         BOOL has = FALSE;
 777         ION_CHECK(ion_reader_has_annotation(obj->reader, ion_string_from_zend(&ann_istr, ann_zstr), &has));
 778         RETURN_BOOL(has);
 779 }
 780 static ZEND_METHOD(ion_Reader_Reader, isNull)
 781 {
 782         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 783         OBJ_CHECK(obj);
 784
 785         ZEND_PARSE_PARAMETERS_NONE();
 786
 787         BOOL is = FALSE;
 788         ION_CHECK(ion_reader_is_null(obj->reader, &is));
 789         RETURN_BOOL(is);
 790 }
 791 static ZEND_METHOD(ion_Reader_Reader, isInStruct)
 792 {
 793         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 794         OBJ_CHECK(obj);
 795
 796         ZEND_PARSE_PARAMETERS_NONE();
 797
 798         BOOL is = FALSE;
 799         ION_CHECK(ion_reader_is_in_struct(obj->reader, &is));
 800         RETURN_BOOL(is);
 801 }
 802 static ZEND_METHOD(ion_Reader_Reader, getFieldName)
 803 {
 804         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 805         OBJ_CHECK(obj);
 806
 807         ZEND_PARSE_PARAMETERS_NONE();
 808
 809         ION_STRING name;
 810         ION_CHECK(ion_reader_get_field_name(obj->reader, &name));
 811         RETURN_STRINGL((char *) name.value, name.length);
 812 }
 813 static ZEND_METHOD(ion_Reader_Reader, getFieldNameSymbol)
 814 {
 815         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 816         OBJ_CHECK(obj);
 817
 818         ZEND_PARSE_PARAMETERS_NONE();
 819
 820         ION_SYMBOL *sym_ptr;
 821         ION_CHECK(ion_reader_get_field_name_symbol(obj->reader, &sym_ptr));
 822
 823         php_ion_symbol_zval(sym_ptr, return_value);
 824 }
 825 static ZEND_METHOD(ion_Reader_Reader, getAnnotations)
 826 {
 827         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 828         OBJ_CHECK(obj);
 829
 830         ZEND_PARSE_PARAMETERS_NONE();
 831
 832         int32_t count, max;
 833         if (obj->opt) {
 834                 max = php_ion_obj(reader_options, obj->opt)->opt.max_annotation_count;
 835         } else {
 836                 max = 10;
 837         }
 838         ION_STRING *ptr = ecalloc(sizeof(*ptr), max);
 839         iERR err = ion_reader_get_annotations(obj->reader, ptr, max, &count);
 840         if (!err) {
 841                 array_init_size(return_value, count);
 842                 for (int32_t i = 0; i < count; ++i) {
 843                         add_next_index_str(return_value, zend_string_from_ion(&ptr[i]));
 844                 }
 845         }
 846         efree(ptr);
 847         ION_CHECK(err);
 848 }
 849 static ZEND_METHOD(ion_Reader_Reader, getAnnotationSymbols)
 850 {
 851         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 852         OBJ_CHECK(obj);
 853
 854         ZEND_PARSE_PARAMETERS_NONE();
 855
 856         int32_t count, max = php_ion_obj(reader_options, obj->opt)->opt.max_annotation_count;
 857         ION_SYMBOL *ptr = ecalloc(sizeof(*ptr), max);
 858         iERR err = ion_reader_get_annotation_symbols(obj->reader, ptr, max, &count);
 859         if (!err) {
 860                 array_init_size(return_value, count);
 861                 for (int32_t i = 0; i < count; ++i) {
 862                         zval zsym;
 863                         php_ion_symbol_zval(&ptr[i], &zsym);
 864                         add_next_index_zval(return_value, &zsym);
 865                 }
 866         }
 867         efree(ptr);
 868         ION_CHECK(err);
 869 }
 870 static ZEND_METHOD(ion_Reader_Reader, countAnnotations)
 871 {
 872         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 873         OBJ_CHECK(obj);
 874
 875         ZEND_PARSE_PARAMETERS_NONE();
 876
 877         SIZE sz = 0;
 878         ION_CHECK(ion_reader_get_annotation_count(obj->reader, &sz));
 879         RETURN_LONG(sz);
 880 }
 881 static ZEND_METHOD(ion_Reader_Reader, getAnnotation)
 882 {
 883         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 884         OBJ_CHECK(obj);
 885
 886         zend_long idx;
 887         ZEND_PARSE_PARAMETERS_START(1, 1)
 888                 Z_PARAM_LONG(idx);
 889         ZEND_PARSE_PARAMETERS_END();
 890
 891         ION_STRING ann;
 892         ION_CHECK(ion_reader_get_an_annotation(obj->reader, idx, &ann));
 893         RETURN_STRINGL((char *) ann.value, ann.length);
 894 }
 895 static ZEND_METHOD(ion_Reader_Reader, getAnnotationSymbol)
 896 {
 897         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 898         OBJ_CHECK(obj);
 899
 900         zend_long idx;
 901         ZEND_PARSE_PARAMETERS_START(1, 1)
 902                 Z_PARAM_LONG(idx);
 903         ZEND_PARSE_PARAMETERS_END();
 904
 905         ION_SYMBOL sym;
 906         ION_CHECK(ion_reader_get_an_annotation_symbol(obj->reader, idx, &sym));
 907         php_ion_symbol_zval(&sym, return_value);
 908 }
 909 static ZEND_METHOD(ion_Reader_Reader, readNull)
 910 {
 911         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 912         OBJ_CHECK(obj);
 913
 914         ZEND_PARSE_PARAMETERS_NONE();
 915
 916         ION_TYPE typ;
 917         ION_CHECK(ion_reader_read_null(obj->reader, &typ));
 918         RETURN_OBJ_COPY(php_ion_type_fetch(typ));
 919 }
 920 static ZEND_METHOD(ion_Reader_Reader, readBool)
 921 {
 922         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 923         OBJ_CHECK(obj);
 924
 925         ZEND_PARSE_PARAMETERS_NONE();
 926
 927         BOOL b;
 928         ION_CHECK(ion_reader_read_bool(obj->reader, &b));
 929         RETURN_BOOL(b);
 930 }
 931 static ZEND_METHOD(ion_Reader_Reader, readInt)
 932 {
 933         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 934         OBJ_CHECK(obj);
 935
 936         ZEND_PARSE_PARAMETERS_NONE();
 937
 938         php_ion_reader_read_int(obj->reader, return_value);
 939 }
 940 static ZEND_METHOD(ion_Reader_Reader, readFloat)
 941 {
 942         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 943         OBJ_CHECK(obj);
 944
 945         ZEND_PARSE_PARAMETERS_NONE();
 946
 947         ION_CHECK(ion_reader_read_double(obj->reader, &Z_DVAL_P(return_value)));
 948 }
 949 static ZEND_METHOD(ion_Reader_Reader, readDecimal)
 950 {
 951         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 952         OBJ_CHECK(obj);
 953
 954         ZEND_PARSE_PARAMETERS_NONE();
 955
 956         object_init_ex(return_value, ce_Decimal);
 957         php_ion_decimal *dec = php_ion_obj(decimal, Z_OBJ_P(return_value));
 958         ION_CHECK(ion_reader_read_ion_decimal(obj->reader, &dec->dec));
 959         php_ion_decimal_ctor(dec);
 960 }
 961 static ZEND_METHOD(ion_Reader_Reader, readTimestamp)
 962 {
 963         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 964         OBJ_CHECK(obj);
 965
 966         ZEND_PARSE_PARAMETERS_NONE();
 967
 968         php_ion_reader_read_timestamp(obj->reader, obj->opt ? &php_ion_obj(reader_options, obj->opt)->opt : NULL, return_value);
 969 }
 970 static ZEND_METHOD(ion_Reader_Reader, readSymbol)
 971 {
 972         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 973         OBJ_CHECK(obj);
 974
 975         ZEND_PARSE_PARAMETERS_NONE();
 976
 977         ION_SYMBOL sym;
 978         ION_CHECK(ion_reader_read_ion_symbol(obj->reader, &sym));
 979         php_ion_symbol_zval(&sym, return_value);
 980 }
 981 static ZEND_METHOD(ion_Reader_Reader, readString)
 982 {
 983         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 984         OBJ_CHECK(obj);
 985
 986         ZEND_PARSE_PARAMETERS_NONE();
 987
 988         ION_STRING str;
 989         ION_CHECK(ion_reader_read_string(obj->reader, &str));
 990         RETURN_STRINGL((char *) str.value, str.length);
 991 }
 992
 993 typedef iERR (*read_part_fn)(ION_READER *, BYTE *, SIZE, SIZE *);
 994 static void read_part(INTERNAL_FUNCTION_PARAMETERS, read_part_fn fn)
 995 {
 996         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
 997         OBJ_CHECK(obj);
 998
 999         zval *ref;
1000         zend_string *zstr;
1001         zend_long len = 0x1000;
1002         ZEND_PARSE_PARAMETERS_START(1, 1)
1003                 Z_PARAM_ZVAL(ref)
1004                 Z_PARAM_OPTIONAL
1005                 Z_PARAM_LONG(len)
1006         ZEND_PARSE_PARAMETERS_END();
1007
1008         ZVAL_DEREF(ref);
1009
1010         if (Z_TYPE_P(ref) == IS_STRING && Z_STRLEN_P(ref) == len) {
1011                 /* reuse */
1012                 zstr = Z_STR_P(ref);
1013         } else {
1014                 zval_dtor(ref);
1015                 zstr = zend_string_alloc(len, 0);
1016         }
1017
1018         SIZE read = 0;
1019         ION_CHECK(fn(obj->reader, (BYTE *) zstr->val, zstr->len, &read), goto fail);
1020         if (read > 0) {
1021                 if (read < zstr->len) {
1022                         zstr = zend_string_truncate(zstr, read, 0);
1023                 }
1024                 ZVAL_STR(ref, zstr);
1025                 RETURN_TRUE;
1026         }
1027 fail:
1028         if (zstr != Z_STR_P(ref)) {
1029                 zend_string_release(zstr);
1030         }
1031         ZVAL_EMPTY_STRING(ref);
1032         RETURN_FALSE;
1033 }
1034 static ZEND_METHOD(ion_Reader_Reader, readStringPart)
1035 {
1036         read_part(INTERNAL_FUNCTION_PARAM_PASSTHRU, ion_reader_read_partial_string);
1037 }
1038 static ZEND_METHOD(ion_Reader_Reader, readLob)
1039 {
1040         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1041         OBJ_CHECK(obj);
1042
1043         ZEND_PARSE_PARAMETERS_NONE();
1044
1045         php_ion_reader_read_lob(obj->reader, return_value);
1046 }
1047 static ZEND_METHOD(ion_Reader_Reader, readLobPart)
1048 {
1049         read_part(INTERNAL_FUNCTION_PARAM_PASSTHRU, ion_reader_read_lob_partial_bytes);
1050 }
1051 static ZEND_METHOD(ion_Reader_Reader, getPosition)
1052 {
1053         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1054         OBJ_CHECK(obj);
1055
1056         ZEND_PARSE_PARAMETERS_NONE();
1057
1058         int64_t bytes = 0;
1059         int32_t dummy;
1060         ION_CHECK(ion_reader_get_position(obj->reader, &bytes, &dummy, &dummy));
1061         RETURN_LONG(bytes);
1062 }
1063 static ZEND_METHOD(ion_Reader_Reader, getDepth)
1064 {
1065         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1066         OBJ_CHECK(obj);
1067
1068         ZEND_PARSE_PARAMETERS_NONE();
1069
1070         SIZE depth = 0;
1071         ION_CHECK(ion_reader_get_depth(obj->reader, &depth));
1072         RETURN_LONG(depth);
1073 }
1074 static ZEND_METHOD(ion_Reader_Reader, seek)
1075 {
1076         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1077         OBJ_CHECK(obj);
1078
1079         zend_long off, len = -1;
1080         ZEND_PARSE_PARAMETERS_START(1, 2)
1081                 Z_PARAM_LONG(off)
1082                 Z_PARAM_OPTIONAL
1083                 Z_PARAM_LONG(len)
1084         ZEND_PARSE_PARAMETERS_END();
1085
1086         ION_CHECK(ion_reader_seek(obj->reader, off, len));
1087 }
1088 static ZEND_METHOD(ion_Reader_Reader, getValueOffset)
1089 {
1090         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1091         OBJ_CHECK(obj);
1092
1093         ZEND_PARSE_PARAMETERS_NONE();
1094
1095         POSITION off = 0;
1096         ION_CHECK(ion_reader_get_value_offset(obj->reader, &off));
1097         RETURN_LONG(off);
1098 }
1099 static ZEND_METHOD(ion_Reader_Reader, getValueLength)
1100 {
1101         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1102         OBJ_CHECK(obj);
1103
1104         ZEND_PARSE_PARAMETERS_NONE();
1105
1106         SIZE len = 0;
1107         ION_CHECK(ion_reader_get_value_length(obj->reader, &len));
1108         RETURN_LONG(len);
1109 }
1110 static ZEND_METHOD(ion_Reader_Buffer_Reader, __construct)
1111 {
1112         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1113         PTR_CHECK(obj);
1114
1115         zend_string *zstr;
1116         ZEND_PARSE_PARAMETERS_START(1, 2)
1117                 Z_PARAM_STR(zstr)
1118                 Z_PARAM_OPTIONAL
1119                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Reader_Options)
1120         ZEND_PARSE_PARAMETERS_END();
1121
1122         obj->type = BUFFER_READER;
1123         obj->buffer = zend_string_copy(zstr);
1124
1125         php_ion_reader_ctor(obj);
1126 }
1127 static ZEND_METHOD(ion_Reader_Buffer_Reader, getBuffer)
1128 {
1129         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1130         OBJ_CHECK(obj);
1131
1132         ZEND_PARSE_PARAMETERS_NONE();
1133         RETURN_STR_COPY(obj->buffer);
1134 }
1135
1136 static ZEND_METHOD(ion_Reader_Stream_Reader, __construct)
1137 {
1138         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1139         PTR_CHECK(obj);
1140
1141         zval *zstream;
1142         ZEND_PARSE_PARAMETERS_START(1, 2)
1143                 Z_PARAM_RESOURCE(zstream)
1144                 Z_PARAM_OPTIONAL
1145                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Reader_Options)
1146         ZEND_PARSE_PARAMETERS_END();
1147
1148         obj->type = STREAM_READER;
1149         php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1150
1151         php_ion_reader_ctor(obj);
1152 }
1153 static ZEND_METHOD(ion_Reader_Stream_Reader, getStream)
1154 {
1155         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1156         OBJ_CHECK(obj);
1157
1158         ZEND_PARSE_PARAMETERS_NONE();
1159         PTR_CHECK(obj->stream.ptr);
1160
1161         GC_ADDREF(obj->stream.ptr->res);
1162         RETURN_RES(obj->stream.ptr->res);
1163 }
1164 static ZEND_METHOD(ion_Reader_Stream_Reader, resetStream)
1165 {
1166         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1167         OBJ_CHECK(obj);
1168
1169         zval *zstream;
1170         ZEND_PARSE_PARAMETERS_START(1, 1);
1171                 Z_PARAM_RESOURCE(zstream);
1172         ZEND_PARSE_PARAMETERS_END();
1173
1174         ION_CHECK(ion_reader_reset_stream(&obj->reader, obj, php_ion_reader_stream_handler));
1175
1176         if (obj->stream.ptr) {
1177                 zend_list_delete(obj->stream.ptr->res);
1178         }
1179         php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1180         PTR_CHECK(obj->stream.ptr);
1181         Z_ADDREF_P(zstream);
1182 }
1183 static ZEND_METHOD(ion_Reader_Stream_Reader, resetStreamWithLength)
1184 {
1185         php_ion_reader *obj = php_ion_obj(reader, Z_OBJ_P(ZEND_THIS));
1186         OBJ_CHECK(obj);
1187
1188         zval *zstream;
1189         zend_long length;
1190         ZEND_PARSE_PARAMETERS_START(1, 2);
1191                 Z_PARAM_RESOURCE(zstream);
1192                 Z_PARAM_LONG(length)
1193         ZEND_PARSE_PARAMETERS_END();
1194
1195         ION_CHECK(ion_reader_reset_stream_with_length(&obj->reader, obj, php_ion_reader_stream_handler, length));
1196
1197         if (obj->stream.ptr) {
1198                 zend_list_delete(obj->stream.ptr->res);
1199         }
1200         php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1201         PTR_CHECK(obj->stream.ptr);
1202         Z_ADDREF_P(zstream);
1203 }
1204 static ZEND_METHOD(ion_Writer_Options, __construct)
1205 {
1206         php_ion_writer_options *obj = php_ion_obj(writer_options, Z_OBJ_P(ZEND_THIS));
1207         PTR_CHECK(obj);
1208
1209         zend_bool binary = false, compact_floats = false, escape = false, pretty = false,
1210                         tabs = true, small_cntr_inl = true, suppress_sys = false, flush = false;
1211         zend_long indent = 2, max_depth = 10, max_ann = 10, temp = 0x4000, alloc = 0x10000;
1212         ZEND_PARSE_PARAMETERS_START(0, 16)
1213                 Z_PARAM_OPTIONAL
1214                 //public readonly ?\ion\Catalog $catalog = null,
1215                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->cat, ce_Catalog)
1216                 //public readonly ?\ion\Decimal\Context $decimalContext = null,
1217                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->dec_ctx, ce_Decimal_Context)
1218                 //public readonly bool $outputBinary = false,
1219                 Z_PARAM_BOOL(binary)
1220                 //public readonly bool $compactFloats = false,
1221                 Z_PARAM_BOOL(compact_floats)
1222                 //public readonly bool $escapeNonAscii = false,
1223                 Z_PARAM_BOOL(escape)
1224                 //public readonly bool $prettyPrint = false,
1225                 Z_PARAM_BOOL(pretty)
1226                 //public readonly bool $indentTabs = true,
1227                 Z_PARAM_BOOL(tabs)
1228                 //public readonly int $indentSize = 2,
1229                 Z_PARAM_LONG(indent)
1230                 //public readonly bool $smallContainersInline = true,
1231                 Z_PARAM_BOOL(small_cntr_inl)
1232                 //public readonly bool $suppressSystemValues = false,
1233                 Z_PARAM_BOOL(suppress_sys)
1234                 //public readonly bool $flushEveryValue = false,
1235                 Z_PARAM_BOOL(flush)
1236                 //public readonly int $maxContainerDepth = 10,
1237                 Z_PARAM_LONG(max_depth)
1238                 //public readonly int $maxAnnotations = 10,
1239                 Z_PARAM_LONG(max_ann)
1240                 //public readonly int $tempBufferSize = 0x4000,
1241                 Z_PARAM_LONG(temp)
1242                 //public readonly int $allocationPageSize = 0x10000,
1243                 Z_PARAM_LONG(alloc)
1244         ZEND_PARSE_PARAMETERS_END();
1245
1246         if (obj->cat) {
1247                 update_property_obj(&obj->std, ZEND_STRL("catalog"), obj->cat);
1248                 obj->opt.pcatalog = php_ion_obj(catalog, obj->cat)->cat;
1249         }
1250         if (obj->dec_ctx) {
1251                 update_property_obj(&obj->std, ZEND_STRL("decimalContext"), obj->dec_ctx);
1252                 obj->opt.decimal_context = &php_ion_obj(decimal_ctx, obj->dec_ctx)->ctx;
1253         }
1254         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("outputBinary"),
1255                         obj->opt.output_as_binary = binary);
1256         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("comactFloats"),
1257                         obj->opt.compact_floats = compact_floats);
1258         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("excapeNonAscii"),
1259                         obj->opt.escape_all_non_ascii = escape);
1260         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("prettyPrint"),
1261                         obj->opt.pretty_print = pretty);
1262         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("indentTabs"),
1263                         obj->opt.indent_with_tabs = tabs);
1264         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("indentSize"),
1265                         obj->opt.indent_size = indent);
1266         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("smallContainersInline"),
1267                         obj->opt.small_containers_in_line = small_cntr_inl);
1268         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("suppressSystemValues"),
1269                         obj->opt.supress_system_values = suppress_sys);
1270         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("flushEveryValue"),
1271                         obj->opt.flush_every_value = flush);
1272         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("maxContainerDepth"),
1273                         obj->opt.max_container_depth = max_depth);
1274         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("maxAnnotations"),
1275                         obj->opt.max_annotation_count = max_ann);
1276         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("tempBufferSize"),
1277                         obj->opt.temp_buffer_size = temp);
1278         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("allocationPageSize"),
1279                         obj->opt.allocation_page_size = alloc);
1280 }
1281 static ZEND_METHOD(ion_Writer_Writer, writeNull)
1282 {
1283         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1284         OBJ_CHECK(obj);
1285
1286         ZEND_PARSE_PARAMETERS_NONE();
1287
1288         ION_CHECK(ion_writer_write_null(obj->writer));
1289 }
1290 static ZEND_METHOD(ion_Writer_Writer, writeTypedNull)
1291 {
1292         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1293         OBJ_CHECK(obj);
1294
1295         zend_object *typ_obj;
1296         ZEND_PARSE_PARAMETERS_START(1, 1)
1297                 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1298         ZEND_PARSE_PARAMETERS_END();
1299
1300         php_ion_type *typ = php_ion_obj(type, typ_obj);
1301         OBJ_CHECK(typ);
1302         ION_CHECK(ion_writer_write_typed_null(obj->writer, php_ion_obj(type, typ)->typ));
1303 }
1304 static ZEND_METHOD(ion_Writer_Writer, writeBool)
1305 {
1306         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1307         OBJ_CHECK(obj);
1308
1309         zend_bool b;
1310         ZEND_PARSE_PARAMETERS_START(1, 1)
1311                 Z_PARAM_BOOL(b)
1312         ZEND_PARSE_PARAMETERS_END();
1313
1314         ION_CHECK(ion_writer_write_bool(obj->writer, b));
1315 }
1316 static ZEND_METHOD(ion_Writer_Writer, writeInt)
1317 {
1318         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1319         OBJ_CHECK(obj);
1320
1321         zend_long l;
1322         zend_string *s;
1323         ZEND_PARSE_PARAMETERS_START(1, 1)
1324                 Z_PARAM_STR_OR_LONG(s, l)
1325         ZEND_PARSE_PARAMETERS_END();
1326
1327         if (s) {
1328                 ION_INT *i;
1329                 ION_CHECK(ion_int_alloc(obj->writer, &i));
1330                 ION_CHECK(ion_int_from_chars(i, s->val, s->len));
1331                 ION_CHECK(ion_writer_write_ion_int(obj->writer, i));
1332                 ion_int_free(i);
1333         } else {
1334                 ION_CHECK(ion_writer_write_int64(obj->writer, l));
1335         }
1336 }
1337 static ZEND_METHOD(ion_Writer_Writer, writeFloat)
1338 {
1339         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1340         OBJ_CHECK(obj);
1341
1342         double d;
1343         ZEND_PARSE_PARAMETERS_START(1, 1)
1344                 Z_PARAM_DOUBLE(d)
1345         ZEND_PARSE_PARAMETERS_END();
1346
1347         ION_CHECK(ion_writer_write_double(obj->writer, d));
1348 }
1349 static ZEND_METHOD(ion_Writer_Writer, writeDecimal)
1350 {
1351         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1352         OBJ_CHECK(obj);
1353
1354         zend_object *dec_obj;
1355         zend_string *dec_str;
1356         ZEND_PARSE_PARAMETERS_START(1, 1)
1357                 Z_PARAM_OBJ_OF_CLASS_OR_STR(dec_obj, ce_Decimal, dec_str)
1358         ZEND_PARSE_PARAMETERS_END();
1359
1360         if (dec_str) {
1361                 ION_STRING s;
1362                 ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&s, dec_str)));
1363         } else {
1364                 php_ion_decimal *dec = php_ion_obj(decimal, dec_obj);
1365                 ION_CHECK(ion_writer_write_ion_decimal(obj->writer, &dec->dec));
1366         }
1367 }
1368 static ZEND_METHOD(ion_Writer_Writer, writeTimestamp)
1369 {
1370         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1371         OBJ_CHECK(obj);
1372
1373         zend_object *ts_obj;
1374         zend_string *ts_str;
1375         ZEND_PARSE_PARAMETERS_START(1, 1)
1376                 Z_PARAM_OBJ_OF_CLASS_OR_STR(ts_obj, ce_Timestamp, ts_str)
1377         ZEND_PARSE_PARAMETERS_END();
1378
1379         decContext *ctx = NULL;
1380         if (obj->opt) {
1381                 ctx = php_ion_obj(reader_options, obj->opt)->opt.decimal_context;
1382         }
1383
1384         ION_TIMESTAMP tmp = {0};
1385         if (ts_str) {
1386                 SIZE used;
1387                 ION_CHECK(ion_timestamp_parse(&tmp, ts_str->val, ts_str->len, &used, ctx));
1388         } else {
1389                 php_ion_timestamp *ts = php_ion_obj(timestamp, ts_obj);
1390                 OBJ_CHECK(ts);
1391                 ion_timestamp_from_php(&tmp, ts, ctx);
1392         }
1393         ION_CHECK(ion_writer_write_timestamp(obj->writer, &tmp));
1394 }
1395 static ZEND_METHOD(ion_Writer_Writer, writeSymbol)
1396 {
1397         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1398         OBJ_CHECK(obj);
1399
1400         zend_object *sym_obj;
1401         zend_string *sym_str;
1402         ZEND_PARSE_PARAMETERS_START(1, 1)
1403                 Z_PARAM_OBJ_OF_CLASS_OR_STR(sym_obj, ce_Symbol, sym_str);
1404         ZEND_PARSE_PARAMETERS_END();
1405
1406         if (sym_str) {
1407                 ION_STRING is;
1408                 ION_CHECK(ion_writer_write_symbol(obj->writer, ion_string_from_zend(&is, sym_str)));
1409         } else {
1410                 php_ion_symbol *sym = php_ion_obj(symbol, sym_obj);
1411                 PTR_CHECK(sym);
1412                 ION_CHECK(ion_writer_write_ion_symbol(obj->writer, &sym->sym));
1413         }
1414 }
1415 static ZEND_METHOD(ion_Writer_Writer, writeString)
1416 {
1417         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1418         OBJ_CHECK(obj);
1419
1420         zend_string *str;
1421         ZEND_PARSE_PARAMETERS_START(1, 1)
1422                 Z_PARAM_STR(str)
1423         ZEND_PARSE_PARAMETERS_END();
1424
1425         ION_STRING is;
1426         ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&is, str)));
1427 }
1428 static ZEND_METHOD(ion_Writer_Writer, writeCLob)
1429 {
1430         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1431         OBJ_CHECK(obj);
1432
1433         zend_string *str;
1434         ZEND_PARSE_PARAMETERS_START(1, 1)
1435                 Z_PARAM_STR(str)
1436         ZEND_PARSE_PARAMETERS_END();
1437
1438         ION_CHECK(ion_writer_write_clob(obj->writer, (BYTE *) str->val, str->len));
1439 }
1440 static ZEND_METHOD(ion_Writer_Writer, writeBLob)
1441 {
1442         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1443         OBJ_CHECK(obj);
1444
1445         zend_string *str;
1446         ZEND_PARSE_PARAMETERS_START(1, 1)
1447                 Z_PARAM_STR(str)
1448         ZEND_PARSE_PARAMETERS_END();
1449
1450         ION_CHECK(ion_writer_write_blob(obj->writer, (BYTE *) str->val, str->len));
1451 }
1452 static ZEND_METHOD(ion_Writer_Writer, startLob)
1453 {
1454         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1455         OBJ_CHECK(obj);
1456
1457         zend_object *typ_obj;
1458         ZEND_PARSE_PARAMETERS_START(1, 1)
1459                 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1460         ZEND_PARSE_PARAMETERS_END();
1461
1462         php_ion_type *typ = php_ion_obj(type, typ_obj);
1463         OBJ_CHECK(typ);
1464         ION_CHECK(ion_writer_start_lob(obj->writer, php_ion_obj(type, typ)->typ));
1465 }
1466 static ZEND_METHOD(ion_Writer_Writer, appendLob)
1467 {
1468         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1469         OBJ_CHECK(obj);
1470
1471         zend_string *str;
1472         ZEND_PARSE_PARAMETERS_START(1, 1)
1473                 Z_PARAM_STR(str)
1474         ZEND_PARSE_PARAMETERS_END();
1475
1476         ION_CHECK(ion_writer_append_lob(obj->writer, (BYTE *) str->val, str->len));
1477 }
1478 static ZEND_METHOD(ion_Writer_Writer, finishLob)
1479 {
1480         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1481         OBJ_CHECK(obj);
1482
1483         ZEND_PARSE_PARAMETERS_NONE();
1484
1485         ION_CHECK(ion_writer_finish_lob(obj->writer));
1486 }
1487 static ZEND_METHOD(ion_Writer_Writer, startContainer)
1488 {
1489         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1490         OBJ_CHECK(obj);
1491
1492         zend_object *typ_obj;
1493         ZEND_PARSE_PARAMETERS_START(1, 1)
1494                 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1495         ZEND_PARSE_PARAMETERS_END();
1496
1497         php_ion_type *typ = php_ion_obj(type, typ_obj);
1498         OBJ_CHECK(typ);
1499         ION_CHECK(ion_writer_start_container(obj->writer, php_ion_obj(type, typ)->typ));
1500 }
1501 static ZEND_METHOD(ion_Writer_Writer, finishContainer)
1502 {
1503         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1504         OBJ_CHECK(obj);
1505
1506         ZEND_PARSE_PARAMETERS_NONE();
1507
1508         ION_CHECK(ion_writer_finish_container(obj->writer));
1509 }
1510 static ZEND_METHOD(ion_Writer_Writer, writeFieldName)
1511 {
1512         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1513         OBJ_CHECK(obj);
1514
1515         zend_object *sym_obj;
1516         zend_string *sym_str;
1517         ZEND_PARSE_PARAMETERS_START(1, 1)
1518                 Z_PARAM_OBJ_OF_CLASS_OR_STR(sym_obj, ce_Symbol, sym_str);
1519         ZEND_PARSE_PARAMETERS_END();
1520
1521         if (sym_str) {
1522                 ION_STRING is;
1523                 ION_CHECK(ion_writer_write_field_name(obj->writer, ion_string_from_zend(&is, sym_str)));
1524         } else {
1525                 php_ion_symbol *sym = php_ion_obj(symbol, sym_obj);
1526                 PTR_CHECK(sym);
1527                 ION_CHECK(ion_writer_write_field_name_symbol(obj->writer, &sym->sym));
1528         }
1529 }
1530 static ZEND_METHOD(ion_Writer_Writer, writeAnnotation)
1531 {
1532         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1533         OBJ_CHECK(obj);
1534
1535         zval *args;
1536         unsigned argc;
1537         ZEND_PARSE_PARAMETERS_START(1, -1)
1538                 Z_PARAM_VARIADIC('+', args, argc);
1539         ZEND_PARSE_PARAMETERS_END();
1540
1541         for (unsigned i = 0; i < argc; ++i) {
1542                 switch (Z_TYPE(args[i])) {
1543                 case IS_STRING:
1544                         ION_STRING is;
1545                         ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_zend(&is, Z_STR(args[i]))));
1546                         break;
1547
1548                 case IS_OBJECT:
1549                         ION_CHECK(ion_writer_add_annotation_symbol(obj->writer, &php_ion_obj(symbol, Z_OBJ(args[i]))->sym));
1550                         break;
1551                 }
1552         }
1553 }
1554 static ZEND_METHOD(ion_Writer_Writer, getDepth)
1555 {
1556         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1557         OBJ_CHECK(obj);
1558
1559         ZEND_PARSE_PARAMETERS_NONE();
1560
1561         SIZE depth;
1562         ION_CHECK(ion_writer_get_depth(obj->writer, &depth));
1563         RETURN_LONG(depth);
1564 }
1565 static ZEND_METHOD(ion_Writer_Writer, flush)
1566 {
1567         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1568         OBJ_CHECK(obj);
1569
1570         ZEND_PARSE_PARAMETERS_NONE();
1571
1572         SIZE flushed;
1573         ION_CHECK(ion_writer_flush(obj->writer, &flushed));
1574         if (obj->type == BUFFER_WRITER) {
1575                 smart_str_0(&obj->buffer.str);
1576         }
1577         RETURN_LONG(flushed);
1578 }
1579 static ZEND_METHOD(ion_Writer_Writer, finish)
1580 {
1581         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1582         OBJ_CHECK(obj);
1583
1584         ZEND_PARSE_PARAMETERS_NONE();
1585
1586         SIZE flushed;
1587         ION_CHECK(ion_writer_finish(obj->writer, &flushed));
1588         if (obj->type == BUFFER_WRITER) {
1589                 smart_str_0(&obj->buffer.str);
1590         }
1591         RETURN_LONG(flushed);
1592 }
1593 static ZEND_METHOD(ion_Writer_Writer, writeOne)
1594 {
1595 }
1596 static ZEND_METHOD(ion_Writer_Writer, writeAll)
1597 {
1598 }
1599 static ZEND_METHOD(ion_Writer_Buffer_Writer, __construct)
1600 {
1601         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1602         PTR_CHECK(obj);
1603
1604         zval *ref;
1605         ZEND_PARSE_PARAMETERS_START(1, 2)
1606                 Z_PARAM_ZVAL(ref)
1607                 Z_PARAM_OPTIONAL
1608                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1609         ZEND_PARSE_PARAMETERS_END();
1610
1611         obj->type = BUFFER_WRITER;
1612         ZVAL_COPY(&obj->buffer.val, ref);
1613         zval_dtor(Z_REFVAL_P(ref));
1614
1615         php_ion_writer_ctor(obj);
1616 }
1617 static ZEND_METHOD(ion_Writer_Buffer_Writer, getBuffer)
1618 {
1619         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1620         OBJ_CHECK(obj);
1621
1622         ZEND_PARSE_PARAMETERS_NONE();
1623
1624         RETVAL_STR(zend_string_dup(obj->buffer.str.s, 0));
1625 }
1626 static ZEND_METHOD(ion_Writer_Stream_Writer, __construct)
1627 {
1628         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1629         PTR_CHECK(obj);
1630
1631         zval *zstream;
1632         ZEND_PARSE_PARAMETERS_START(1, 2)
1633                 Z_PARAM_RESOURCE(zstream)
1634                 Z_PARAM_OPTIONAL
1635                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1636         ZEND_PARSE_PARAMETERS_END();
1637
1638         obj->type = STREAM_WRITER;
1639         php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1640
1641         php_ion_writer_ctor(obj);
1642 }
1643 static ZEND_METHOD(ion_Writer_Stream_Writer, getStream)
1644 {
1645         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1646         OBJ_CHECK(obj);
1647
1648         ZEND_PARSE_PARAMETERS_NONE();
1649         PTR_CHECK(obj->stream.ptr);
1650
1651         GC_ADDREF(obj->stream.ptr->res);
1652         RETURN_RES(obj->stream.ptr->res);
1653 }
1654
1655 static ZEND_METHOD(ion_Serializer_PHP, __construct)
1656 {
1657         php_ion_serializer_php *obj = php_ion_obj(serializer_php, Z_OBJ_P(ZEND_THIS));
1658         PTR_CHECK(obj);
1659
1660         obj->serializer.call_magic = true;
1661
1662         ZEND_PARSE_PARAMETERS_START(0, 3)
1663                 Z_PARAM_OPTIONAL
1664                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1665                 Z_PARAM_BOOL(obj->serializer.multi_seq)
1666                 Z_PARAM_BOOL(obj->serializer.call_magic)
1667                 Z_PARAM_STR_OR_NULL(obj->serializer.call_custom)
1668         ZEND_PARSE_PARAMETERS_END();
1669
1670         php_ion_serializer_php_ctor(obj);
1671 }
1672 static ZEND_METHOD(ion_Serializer_PHP, __invoke)
1673 {
1674         zend_object *obj = Z_OBJ_P(ZEND_THIS);
1675
1676         zval *data;
1677         ZEND_PARSE_PARAMETERS_START(1, 1)
1678                 Z_PARAM_ZVAL(data)
1679         ZEND_PARSE_PARAMETERS_END();
1680
1681         if (obj->ce == ce_Serializer_PHP) {
1682                 // default, fast path
1683                 php_ion_serialize(&php_ion_obj(serializer_php, obj)->serializer, data, return_value);
1684         } else {
1685                 zend_call_method_with_1_params(obj, obj->ce, NULL /* TODO */, "serialize", return_value, data);
1686         }
1687 }
1688 static ZEND_FUNCTION(ion_serialize)
1689 {
1690         zval *data;
1691         zend_object *zo_ser = NULL;
1692         ZEND_PARSE_PARAMETERS_START(1, 2)
1693                 Z_PARAM_ZVAL(data)
1694                 Z_PARAM_OPTIONAL
1695                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(zo_ser, ce_Serializer)
1696         ZEND_PARSE_PARAMETERS_END();
1697
1698         if (!zo_ser || zo_ser->ce == ce_Serializer_PHP) {
1699                 // default, fast path
1700                 php_ion_serializer *ser = zo_ser ? &php_ion_obj(serializer_php, zo_ser)->serializer : NULL;
1701                 php_ion_serialize(ser, data, return_value);
1702         } else {
1703                 zend_call_method_with_1_params(zo_ser, NULL, NULL, "__invoke", return_value, data);
1704         }
1705 }
1706 static ZEND_METHOD(ion_Serializer_PHP, serialize)
1707 {
1708         //zend_object *obj = Z_OBJ_P(ZEND_THIS);
1709
1710         zval *data;
1711         ZEND_PARSE_PARAMETERS_START(1, 1)
1712                 Z_PARAM_ZVAL(data)
1713         ZEND_PARSE_PARAMETERS_END();
1714
1715         // TODO
1716         zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Not implemented");
1717 }
1718
1719 static ZEND_METHOD(ion_Unserializer_PHP, __construct)
1720 {
1721         php_ion_unserializer_php *obj = php_ion_obj(unserializer_php, Z_OBJ_P(ZEND_THIS));
1722         PTR_CHECK(obj);
1723
1724         obj->unserializer.call_magic = true;
1725
1726         ZEND_PARSE_PARAMETERS_START(0, 3)
1727                 Z_PARAM_OPTIONAL
1728                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Reader_Options)
1729                 Z_PARAM_BOOL(obj->unserializer.multi_seq)
1730                 Z_PARAM_BOOL(obj->unserializer.call_magic)
1731                 Z_PARAM_STR_OR_NULL(obj->unserializer.call_custom)
1732         ZEND_PARSE_PARAMETERS_END();
1733
1734         php_ion_unserializer_php_ctor(obj);
1735 }
1736 static ZEND_METHOD(ion_Unserializer_PHP, __invoke)
1737 {
1738         zend_object *obj = Z_OBJ_P(ZEND_THIS);
1739
1740         zval *data;
1741         ZEND_PARSE_PARAMETERS_START(1, 1)
1742                 Z_PARAM_ZVAL(data)
1743         ZEND_PARSE_PARAMETERS_END();
1744
1745         if (obj->ce == ce_Unserializer_PHP) {
1746                 php_ion_unserialize(&php_ion_obj(unserializer_php, obj)->unserializer, data, return_value);
1747         } else {
1748                 zend_call_method_with_1_params(obj, obj->ce, NULL /* TODO */, "unserialize", return_value, data);
1749         }
1750 }
1751 static ZEND_FUNCTION(ion_unserialize)
1752 {
1753         zval *data;
1754         zend_object *zo_ser = NULL;
1755         ZEND_PARSE_PARAMETERS_START(1, 2)
1756                 Z_PARAM_ZVAL(data)
1757                 Z_PARAM_OPTIONAL
1758                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(zo_ser, ce_Unserializer)
1759         ZEND_PARSE_PARAMETERS_END();
1760
1761         if (!zo_ser || zo_ser->ce == ce_Unserializer_PHP) {
1762                 // default, fast path
1763                 php_ion_unserializer *ser = zo_ser ? &php_ion_obj(unserializer_php, zo_ser)->unserializer : NULL;
1764                 php_ion_unserialize(ser, data, return_value);
1765         } else {
1766                 zend_call_method_with_1_params(zo_ser, NULL, NULL, "__invoke", return_value, data);
1767         }
1768 }
1769 static ZEND_METHOD(ion_Unserializer_PHP, unserialize)
1770 {
1771         //zend_object *obj = Z_OBJ_P(ZEND_THIS);
1772
1773         zval *data;
1774         ZEND_PARSE_PARAMETERS_START(1, 1)
1775                 Z_PARAM_ZVAL(data)
1776         ZEND_PARSE_PARAMETERS_END();
1777
1778         // TODO
1779         zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Not implemented");
1780 }
1781
1782 PHP_RINIT_FUNCTION(ion)
1783 {
1784 #if defined(ZTS) && defined(COMPILE_DL_ION)
1785         ZEND_TSRMLS_CACHE_UPDATE();
1786 #endif
1787
1788         php_ion_globals_symbols_init();
1789         php_ion_globals_serializer_init();
1790         php_ion_globals_unserializer_init();
1791         return SUCCESS;
1792 }
1793
1794 PHP_RSHUTDOWN_FUNCTION(ion)
1795 {
1796         php_ion_globals_unserializer_dtor();
1797         php_ion_globals_serializer_dtor();
1798         php_ion_globals_symbols_dtor();
1799         return SUCCESS;
1800 }
1801
1802 #define ZEND_ARG_VARIADIC_OBJ_TYPE_MASK(pass_by_ref, name, classname, type_mask, default_value) \
1803         { #name, ZEND_TYPE_INIT_CLASS_CONST_MASK(#classname, type_mask | _ZEND_ARG_INFO_FLAGS(pass_by_ref, 1, 0)), default_value },
1804 #include "ion_arginfo.h"
1805
1806 PHP_MINIT_FUNCTION(ion)
1807 {
1808         // true globals
1809         if (SUCCESS != g_sym_init())  {
1810                 return FAILURE;
1811         }
1812
1813         // Catalog
1814         php_ion_register(catalog, Catalog, zend_ce_countable);
1815
1816         // Decimal
1817         php_ion_register(decimal, Decimal);
1818         php_ion_register(decimal_ctx, Decimal_Context);
1819         ce_Decimal_Context_Rounding = register_class_ion_Decimal_Context_Rounding();
1820
1821         // LOB
1822         ce_LOB = register_class_ion_LOB();
1823
1824         // Reader
1825         ce_Reader = register_class_ion_Reader(spl_ce_RecursiveIterator);
1826         php_ion_register(reader_options, Reader_Options);
1827         php_ion_register(reader, Reader_Reader, ce_Reader);
1828         ce_Reader_Buffer = register_class_ion_Reader_Buffer(ce_Reader);
1829         ce_Reader_Buffer_Reader = register_class_ion_Reader_Buffer_Reader(ce_Reader_Reader, ce_Reader_Buffer);
1830         ce_Reader_Stream = register_class_ion_Reader_Stream(ce_Reader);
1831         ce_Reader_Stream_Reader = register_class_ion_Reader_Stream_Reader(ce_Reader_Reader, ce_Reader_Stream);
1832
1833         // Serializer
1834         ce_Serializer = register_class_ion_Serializer();
1835         php_ion_register(serializer_php, Serializer_PHP, ce_Serializer);
1836
1837         // Symbol
1838         php_ion_register(symbol, Symbol);
1839         oh_Symbol.compare = php_ion_symbol_zval_compare;
1840         php_ion_register(symbol_iloc, Symbol_ImportLocation);
1841         php_ion_register(symbol_table, Symbol_Table);
1842         ce_Symbol_Table->create_object = NULL;
1843         ce_Symbol_Table_Local = register_class_ion_Symbol_Table_Local(ce_Symbol_Table);
1844         ce_Symbol_Table_Local->create_object = create_ion_Symbol_Table;
1845         ce_Symbol_Table_Shared = register_class_ion_Symbol_Table_Shared(ce_Symbol_Table);
1846         ce_Symbol_Table_Shared->create_object = create_ion_Symbol_Table;
1847         ce_Symbol_Enum = register_class_ion_Symbol_Enum();
1848         ce_Symbol_Table_System = register_class_ion_Symbol_Table_System(ce_Symbol_Enum);
1849         ce_Symbol_Table_PHP = register_class_ion_Symbol_Table_PHP(ce_Symbol_Enum);
1850
1851         // Timestamp
1852         ce_Timestamp = register_class_ion_Timestamp(php_date_get_date_ce());
1853         ce_Timestamp_Precision = register_class_ion_Timestamp_Precision();
1854
1855         // Type
1856         php_ion_register(type, Type);
1857
1858         // Writer
1859         ce_Writer = register_class_ion_Writer();
1860         php_ion_register(writer_options, Writer_Options);
1861         php_ion_register(writer, Writer_Writer, ce_Writer);
1862         ce_Writer_Buffer = register_class_ion_Writer_Buffer(ce_Writer);
1863         ce_Writer_Buffer_Writer = register_class_ion_Writer_Buffer_Writer(ce_Writer_Writer, ce_Writer_Buffer);
1864         ce_Writer_Stream = register_class_ion_Writer_Stream(ce_Writer);
1865         ce_Writer_Stream_Writer = register_class_ion_Writer_Stream_Writer(ce_Writer_Writer, ce_Writer_Stream);
1866
1867         // Unserializer
1868         ce_Unserializer = register_class_ion_Unserializer();
1869         php_ion_register(unserializer_php, Unserializer_PHP, ce_Unserializer);
1870
1871         return SUCCESS;
1872 }
1873
1874 PHP_MSHUTDOWN_FUNCTION(ion)
1875 {
1876         if (g_sym_tab_php) {
1877                 ion_symbol_table_close(g_sym_tab_php);
1878         }
1879         zend_hash_destroy(&g_sym_hash);
1880         return SUCCESS;
1881 }
1882
1883 PHP_MINFO_FUNCTION(ion)
1884 {
1885         php_info_print_table_start();
1886         php_info_print_table_header(2, "ion support", "enabled");
1887         php_info_print_table_end();
1888 }
1889
1890 PHP_GINIT_FUNCTION(ion)
1891 {
1892         memset(ion_globals, 0, sizeof(*ion_globals));
1893
1894         php_ion_decimal_ctx_init_max(&ion_globals->decimal.ctx, DEC_ROUND_HALF_EVEN);
1895         php_ion_decimal_from_zend_long(&ion_globals->decimal.zend_max, &ion_globals->decimal.ctx, ZEND_LONG_MAX);
1896         php_ion_decimal_from_zend_long(&ion_globals->decimal.zend_min, &ion_globals->decimal.ctx, ZEND_LONG_MIN);
1897 }
1898
1899 PHP_GSHUTDOWN_FUNCTION(ion)
1900 {
1901 }
1902
1903 static zend_module_dep ion_module_deps[] = {
1904         ZEND_MOD_REQUIRED("date")
1905         ZEND_MOD_REQUIRED("spl")
1906         ZEND_MOD_END
1907 };
1908
1909 zend_module_entry ion_module_entry = {
1910         STANDARD_MODULE_HEADER_EX,
1911         NULL,
1912         ion_module_deps,
1913         "ion",                                  /* Extension name */
1914         ext_functions,                  /* zend_function_entry */
1915         PHP_MINIT(ion),                 /* PHP_MINIT - Module initialization */
1916         PHP_MSHUTDOWN(ion),             /* PHP_MSHUTDOWN - Module shutdown */
1917         PHP_RINIT(ion),                 /* PHP_RINIT - Request initialization */
1918         PHP_RSHUTDOWN(ion),             /* PHP_RSHUTDOWN - Request shutdown */
1919         PHP_MINFO(ion),                 /* PHP_MINFO - Module info */
1920         PHP_ION_VERSION,                /* Version */
1921         ZEND_MODULE_GLOBALS(ion),
1922         PHP_GINIT(ion),                 /* PHP_GINIT */
1923         PHP_GSHUTDOWN(ion),             /* PHP_GSHUTDOWN */
1924         NULL,
1925         STANDARD_MODULE_PROPERTIES_EX
1926 };
1927
1928 #ifdef COMPILE_DL_ION
1929 # ifdef ZTS
1930 ZEND_TSRMLS_CACHE_DEFINE()
1931 # endif
1932 ZEND_GET_MODULE(ion)
1933 #endif