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