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\Collection $encodingSymbolTable = null,
1226                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->col, ce_Collection)
1227                 //public readonly ?\ion\Decimal\Context $decimalContext = null,
1228                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->dec_ctx, ce_Decimal_Context)
1229                 //public readonly bool $outputBinary = false,
1230                 Z_PARAM_BOOL(binary)
1231                 //public readonly bool $compactFloats = false,
1232                 Z_PARAM_BOOL(compact_floats)
1233                 //public readonly bool $escapeNonAscii = false,
1234                 Z_PARAM_BOOL(escape)
1235                 //public readonly bool $prettyPrint = false,
1236                 Z_PARAM_BOOL(pretty)
1237                 //public readonly bool $indentTabs = true,
1238                 Z_PARAM_BOOL(tabs)
1239                 //public readonly int $indentSize = 2,
1240                 Z_PARAM_LONG(indent)
1241                 //public readonly bool $smallContainersInline = true,
1242                 Z_PARAM_BOOL(small_cntr_inl)
1243                 //public readonly bool $suppressSystemValues = false,
1244                 Z_PARAM_BOOL(suppress_sys)
1245                 //public readonly bool $flushEveryValue = false,
1246                 Z_PARAM_BOOL(flush)
1247                 //public readonly int $maxContainerDepth = 10,
1248                 Z_PARAM_LONG(max_depth)
1249                 //public readonly int $maxAnnotations = 10,
1250                 Z_PARAM_LONG(max_ann)
1251                 //public readonly int $tempBufferSize = 0x4000,
1252                 Z_PARAM_LONG(temp)
1253                 //public readonly int $allocationPageSize = 0x10000,
1254                 Z_PARAM_LONG(alloc)
1255         ZEND_PARSE_PARAMETERS_END();
1256
1257         if (obj->cat) {
1258                 update_property_obj(&obj->std, ZEND_STRL("catalog"), obj->cat);
1259                 obj->opt.pcatalog = php_ion_obj(catalog, obj->cat)->cat;
1260         }
1261         if (obj->col) {
1262                 // TODO
1263         }
1264         if (obj->dec_ctx) {
1265                 update_property_obj(&obj->std, ZEND_STRL("decimalContext"), obj->dec_ctx);
1266                 obj->opt.decimal_context = &php_ion_obj(decimal_ctx, obj->dec_ctx)->ctx;
1267         }
1268         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("outputBinary"),
1269                         obj->opt.output_as_binary = binary);
1270         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("comactFloats"),
1271                         obj->opt.compact_floats = compact_floats);
1272         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("excapeNonAscii"),
1273                         obj->opt.escape_all_non_ascii = escape);
1274         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("prettyPrint"),
1275                         obj->opt.pretty_print = pretty);
1276         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("indentTabs"),
1277                         obj->opt.indent_with_tabs = tabs);
1278         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("indentSize"),
1279                         obj->opt.indent_size = indent);
1280         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("smallContainersInline"),
1281                         obj->opt.small_containers_in_line = small_cntr_inl);
1282         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("suppressSystemValues"),
1283                         obj->opt.supress_system_values = suppress_sys);
1284         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("flushEveryValue"),
1285                         obj->opt.flush_every_value = flush);
1286         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("maxContainerDepth"),
1287                         obj->opt.max_container_depth = max_depth);
1288         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("maxAnnotations"),
1289                         obj->opt.max_annotation_count = max_ann);
1290         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("tempBufferSize"),
1291                         obj->opt.temp_buffer_size = temp);
1292         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("allocationPageSize"),
1293                         obj->opt.allocation_page_size = alloc);
1294 }
1295 static ZEND_METHOD(ion_Writer_Writer, writeNull)
1296 {
1297         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1298         OBJ_CHECK(obj);
1299
1300         ZEND_PARSE_PARAMETERS_NONE();
1301
1302         ION_CHECK(ion_writer_write_null(obj->writer));
1303 }
1304 static ZEND_METHOD(ion_Writer_Writer, writeTypedNull)
1305 {
1306         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1307         OBJ_CHECK(obj);
1308
1309         zend_object *typ_obj;
1310         ZEND_PARSE_PARAMETERS_START(1, 1)
1311                 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1312         ZEND_PARSE_PARAMETERS_END();
1313
1314         php_ion_type *typ = php_ion_obj(type, typ_obj);
1315         OBJ_CHECK(typ);
1316         ION_CHECK(ion_writer_write_typed_null(obj->writer, php_ion_obj(type, typ)->typ));
1317 }
1318 static ZEND_METHOD(ion_Writer_Writer, writeBool)
1319 {
1320         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1321         OBJ_CHECK(obj);
1322
1323         zend_bool b;
1324         ZEND_PARSE_PARAMETERS_START(1, 1)
1325                 Z_PARAM_BOOL(b)
1326         ZEND_PARSE_PARAMETERS_END();
1327
1328         ION_CHECK(ion_writer_write_bool(obj->writer, b));
1329 }
1330 static ZEND_METHOD(ion_Writer_Writer, writeInt)
1331 {
1332         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1333         OBJ_CHECK(obj);
1334
1335         zend_long l;
1336         zend_string *s;
1337         ZEND_PARSE_PARAMETERS_START(1, 1)
1338                 Z_PARAM_STR_OR_LONG(s, l)
1339         ZEND_PARSE_PARAMETERS_END();
1340
1341         if (s) {
1342                 ION_INT *i;
1343                 ION_CHECK(ion_int_alloc(obj->writer, &i));
1344                 ION_CHECK(ion_int_from_chars(i, s->val, s->len));
1345                 ION_CHECK(ion_writer_write_ion_int(obj->writer, i));
1346                 ion_int_free(i);
1347         } else {
1348                 ION_CHECK(ion_writer_write_int64(obj->writer, l));
1349         }
1350 }
1351 static ZEND_METHOD(ion_Writer_Writer, writeFloat)
1352 {
1353         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1354         OBJ_CHECK(obj);
1355
1356         double d;
1357         ZEND_PARSE_PARAMETERS_START(1, 1)
1358                 Z_PARAM_DOUBLE(d)
1359         ZEND_PARSE_PARAMETERS_END();
1360
1361         ION_CHECK(ion_writer_write_double(obj->writer, d));
1362 }
1363 static ZEND_METHOD(ion_Writer_Writer, writeDecimal)
1364 {
1365         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1366         OBJ_CHECK(obj);
1367
1368         zend_object *dec_obj;
1369         zend_string *dec_str;
1370         ZEND_PARSE_PARAMETERS_START(1, 1)
1371                 Z_PARAM_OBJ_OF_CLASS_OR_STR(dec_obj, ce_Decimal, dec_str)
1372         ZEND_PARSE_PARAMETERS_END();
1373
1374         if (dec_str) {
1375                 ION_STRING s;
1376                 ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&s, dec_str)));
1377         } else {
1378                 php_ion_decimal *dec = php_ion_obj(decimal, dec_obj);
1379                 ION_CHECK(ion_writer_write_ion_decimal(obj->writer, &dec->dec));
1380         }
1381 }
1382 static ZEND_METHOD(ion_Writer_Writer, writeTimestamp)
1383 {
1384         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1385         OBJ_CHECK(obj);
1386
1387         zend_object *ts_obj;
1388         zend_string *ts_str;
1389         ZEND_PARSE_PARAMETERS_START(1, 1)
1390                 Z_PARAM_OBJ_OF_CLASS_OR_STR(ts_obj, ce_Timestamp, ts_str)
1391         ZEND_PARSE_PARAMETERS_END();
1392
1393         decContext *ctx = NULL;
1394         if (obj->opt) {
1395                 ctx = php_ion_obj(reader_options, obj->opt)->opt.decimal_context;
1396         }
1397
1398         ION_TIMESTAMP tmp = {0};
1399         if (ts_str) {
1400                 SIZE used;
1401                 ION_CHECK(ion_timestamp_parse(&tmp, ts_str->val, ts_str->len, &used, ctx));
1402         } else {
1403                 php_ion_timestamp *ts = php_ion_obj(timestamp, ts_obj);
1404                 OBJ_CHECK(ts);
1405                 ion_timestamp_from_php(&tmp, ts, ctx);
1406         }
1407         ION_CHECK(ion_writer_write_timestamp(obj->writer, &tmp));
1408 }
1409 static ZEND_METHOD(ion_Writer_Writer, writeSymbol)
1410 {
1411         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1412         OBJ_CHECK(obj);
1413
1414         zend_object *sym_obj;
1415         zend_string *sym_str;
1416         ZEND_PARSE_PARAMETERS_START(1, 1)
1417                 Z_PARAM_OBJ_OF_CLASS_OR_STR(sym_obj, ce_Symbol, sym_str);
1418         ZEND_PARSE_PARAMETERS_END();
1419
1420         if (sym_str) {
1421                 ION_STRING is;
1422                 ION_CHECK(ion_writer_write_symbol(obj->writer, ion_string_from_zend(&is, sym_str)));
1423         } else {
1424                 php_ion_symbol *sym = php_ion_obj(symbol, sym_obj);
1425                 PTR_CHECK(sym);
1426                 ION_CHECK(ion_writer_write_ion_symbol(obj->writer, &sym->sym));
1427         }
1428 }
1429 static ZEND_METHOD(ion_Writer_Writer, writeString)
1430 {
1431         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1432         OBJ_CHECK(obj);
1433
1434         zend_string *str;
1435         ZEND_PARSE_PARAMETERS_START(1, 1)
1436                 Z_PARAM_STR(str)
1437         ZEND_PARSE_PARAMETERS_END();
1438
1439         ION_STRING is;
1440         ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&is, str)));
1441 }
1442 static ZEND_METHOD(ion_Writer_Writer, writeCLob)
1443 {
1444         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1445         OBJ_CHECK(obj);
1446
1447         zend_string *str;
1448         ZEND_PARSE_PARAMETERS_START(1, 1)
1449                 Z_PARAM_STR(str)
1450         ZEND_PARSE_PARAMETERS_END();
1451
1452         ION_CHECK(ion_writer_write_clob(obj->writer, (BYTE *) str->val, str->len));
1453 }
1454 static ZEND_METHOD(ion_Writer_Writer, writeBLob)
1455 {
1456         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1457         OBJ_CHECK(obj);
1458
1459         zend_string *str;
1460         ZEND_PARSE_PARAMETERS_START(1, 1)
1461                 Z_PARAM_STR(str)
1462         ZEND_PARSE_PARAMETERS_END();
1463
1464         ION_CHECK(ion_writer_write_blob(obj->writer, (BYTE *) str->val, str->len));
1465 }
1466 static ZEND_METHOD(ion_Writer_Writer, startLob)
1467 {
1468         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1469         OBJ_CHECK(obj);
1470
1471         zend_object *typ_obj;
1472         ZEND_PARSE_PARAMETERS_START(1, 1)
1473                 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1474         ZEND_PARSE_PARAMETERS_END();
1475
1476         php_ion_type *typ = php_ion_obj(type, typ_obj);
1477         OBJ_CHECK(typ);
1478         ION_CHECK(ion_writer_start_lob(obj->writer, php_ion_obj(type, typ)->typ));
1479 }
1480 static ZEND_METHOD(ion_Writer_Writer, appendLob)
1481 {
1482         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1483         OBJ_CHECK(obj);
1484
1485         zend_string *str;
1486         ZEND_PARSE_PARAMETERS_START(1, 1)
1487                 Z_PARAM_STR(str)
1488         ZEND_PARSE_PARAMETERS_END();
1489
1490         ION_CHECK(ion_writer_append_lob(obj->writer, (BYTE *) str->val, str->len));
1491 }
1492 static ZEND_METHOD(ion_Writer_Writer, finishLob)
1493 {
1494         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1495         OBJ_CHECK(obj);
1496
1497         ZEND_PARSE_PARAMETERS_NONE();
1498
1499         ION_CHECK(ion_writer_finish_lob(obj->writer));
1500 }
1501 static ZEND_METHOD(ion_Writer_Writer, startContainer)
1502 {
1503         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1504         OBJ_CHECK(obj);
1505
1506         zend_object *typ_obj;
1507         ZEND_PARSE_PARAMETERS_START(1, 1)
1508                 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1509         ZEND_PARSE_PARAMETERS_END();
1510
1511         php_ion_type *typ = php_ion_obj(type, typ_obj);
1512         OBJ_CHECK(typ);
1513         ION_CHECK(ion_writer_start_container(obj->writer, php_ion_obj(type, typ)->typ));
1514 }
1515 static ZEND_METHOD(ion_Writer_Writer, finishContainer)
1516 {
1517         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1518         OBJ_CHECK(obj);
1519
1520         ZEND_PARSE_PARAMETERS_NONE();
1521
1522         ION_CHECK(ion_writer_finish_container(obj->writer));
1523 }
1524 static ZEND_METHOD(ion_Writer_Writer, writeFieldName)
1525 {
1526         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1527         OBJ_CHECK(obj);
1528
1529         zend_object *sym_obj;
1530         zend_string *sym_str;
1531         ZEND_PARSE_PARAMETERS_START(1, 1)
1532                 Z_PARAM_OBJ_OF_CLASS_OR_STR(sym_obj, ce_Symbol, sym_str);
1533         ZEND_PARSE_PARAMETERS_END();
1534
1535         if (sym_str) {
1536                 ION_STRING is;
1537                 ION_CHECK(ion_writer_write_field_name(obj->writer, ion_string_from_zend(&is, sym_str)));
1538         } else {
1539                 php_ion_symbol *sym = php_ion_obj(symbol, sym_obj);
1540                 PTR_CHECK(sym);
1541                 ION_CHECK(ion_writer_write_field_name_symbol(obj->writer, &sym->sym));
1542         }
1543 }
1544 static ZEND_METHOD(ion_Writer_Writer, writeAnnotation)
1545 {
1546         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1547         OBJ_CHECK(obj);
1548
1549         zval *args;
1550         unsigned argc;
1551         ZEND_PARSE_PARAMETERS_START(1, -1)
1552                 Z_PARAM_VARIADIC('+', args, argc);
1553         ZEND_PARSE_PARAMETERS_END();
1554
1555         for (unsigned i = 0; i < argc; ++i) {
1556                 switch (Z_TYPE(args[i])) {
1557                 case IS_STRING:
1558                         ION_STRING is;
1559                         ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_zend(&is, Z_STR(args[i]))));
1560                         break;
1561
1562                 case IS_OBJECT:
1563                         ION_CHECK(ion_writer_add_annotation_symbol(obj->writer, &php_ion_obj(symbol, Z_OBJ(args[i]))->sym));
1564                         break;
1565                 }
1566         }
1567 }
1568 static ZEND_METHOD(ion_Writer_Writer, getDepth)
1569 {
1570         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1571         OBJ_CHECK(obj);
1572
1573         ZEND_PARSE_PARAMETERS_NONE();
1574
1575         SIZE depth;
1576         ION_CHECK(ion_writer_get_depth(obj->writer, &depth));
1577         RETURN_LONG(depth);
1578 }
1579 static ZEND_METHOD(ion_Writer_Writer, flush)
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_flush(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, finish)
1594 {
1595         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1596         OBJ_CHECK(obj);
1597
1598         ZEND_PARSE_PARAMETERS_NONE();
1599
1600         SIZE flushed;
1601         ION_CHECK(ion_writer_finish(obj->writer, &flushed));
1602         if (obj->type == BUFFER_WRITER) {
1603                 smart_str_0(&obj->buffer.str);
1604         }
1605         RETURN_LONG(flushed);
1606 }
1607 static ZEND_METHOD(ion_Writer_Writer, writeOne)
1608 {
1609 }
1610 static ZEND_METHOD(ion_Writer_Writer, writeAll)
1611 {
1612 }
1613 static ZEND_METHOD(ion_Writer_Buffer_Writer, __construct)
1614 {
1615         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1616         PTR_CHECK(obj);
1617
1618         zval *ref;
1619         ZEND_PARSE_PARAMETERS_START(1, 2)
1620                 Z_PARAM_ZVAL(ref)
1621                 Z_PARAM_OPTIONAL
1622                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1623         ZEND_PARSE_PARAMETERS_END();
1624
1625         obj->type = BUFFER_WRITER;
1626         ZVAL_COPY(&obj->buffer.val, ref);
1627         zval_dtor(Z_REFVAL_P(ref));
1628
1629         php_ion_writer_ctor(obj);
1630 }
1631 static ZEND_METHOD(ion_Writer_Buffer_Writer, getBuffer)
1632 {
1633         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1634         OBJ_CHECK(obj);
1635
1636         ZEND_PARSE_PARAMETERS_NONE();
1637
1638         RETVAL_STR(zend_string_dup(obj->buffer.str.s, 0));
1639 }
1640 static ZEND_METHOD(ion_Writer_Stream_Writer, __construct)
1641 {
1642         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1643         PTR_CHECK(obj);
1644
1645         zval *zstream;
1646         ZEND_PARSE_PARAMETERS_START(1, 2)
1647                 Z_PARAM_RESOURCE(zstream)
1648                 Z_PARAM_OPTIONAL
1649                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1650         ZEND_PARSE_PARAMETERS_END();
1651
1652         obj->type = STREAM_WRITER;
1653         php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1654
1655         php_ion_writer_ctor(obj);
1656 }
1657 static ZEND_METHOD(ion_Writer_Stream_Writer, getStream)
1658 {
1659         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1660         OBJ_CHECK(obj);
1661
1662         ZEND_PARSE_PARAMETERS_NONE();
1663         PTR_CHECK(obj->stream.ptr);
1664
1665         GC_ADDREF(obj->stream.ptr->res);
1666         RETURN_RES(obj->stream.ptr->res);
1667 }
1668
1669 static ZEND_METHOD(ion_Serializer_PHP, __construct)
1670 {
1671         php_ion_serializer_php *obj = php_ion_obj(serializer_php, Z_OBJ_P(ZEND_THIS));
1672         PTR_CHECK(obj);
1673
1674         obj->serializer.call_magic = true;
1675
1676         ZEND_PARSE_PARAMETERS_START(0, 3)
1677                 Z_PARAM_OPTIONAL
1678                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1679                 Z_PARAM_BOOL(obj->serializer.multi_seq)
1680                 Z_PARAM_BOOL(obj->serializer.call_magic)
1681                 Z_PARAM_STR_OR_NULL(obj->serializer.call_custom)
1682         ZEND_PARSE_PARAMETERS_END();
1683
1684         php_ion_serializer_php_ctor(obj);
1685 }
1686 static ZEND_METHOD(ion_Serializer_PHP, __invoke)
1687 {
1688         zend_object *obj = Z_OBJ_P(ZEND_THIS);
1689
1690         zval *data;
1691         ZEND_PARSE_PARAMETERS_START(1, 1)
1692                 Z_PARAM_ZVAL(data)
1693         ZEND_PARSE_PARAMETERS_END();
1694
1695         if (obj->ce == ce_Serializer_PHP) {
1696                 // default, fast path
1697                 php_ion_serialize(&php_ion_obj(serializer_php, obj)->serializer, data, return_value);
1698         } else {
1699                 zend_call_method_with_1_params(obj, obj->ce, NULL /* TODO */, "serialize", return_value, data);
1700         }
1701 }
1702 static ZEND_FUNCTION(ion_serialize)
1703 {
1704         zval *data;
1705         zend_object *zo_ser = NULL;
1706         ZEND_PARSE_PARAMETERS_START(1, 2)
1707                 Z_PARAM_ZVAL(data)
1708                 Z_PARAM_OPTIONAL
1709                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(zo_ser, ce_Serializer)
1710         ZEND_PARSE_PARAMETERS_END();
1711
1712         if (!zo_ser || zo_ser->ce == ce_Serializer_PHP) {
1713                 // default, fast path
1714                 php_ion_serializer *ser = zo_ser ? &php_ion_obj(serializer_php, zo_ser)->serializer : NULL;
1715                 php_ion_serialize(ser, data, return_value);
1716         } else {
1717                 zend_call_method_with_1_params(zo_ser, NULL, NULL, "__invoke", return_value, data);
1718         }
1719 }
1720 static ZEND_METHOD(ion_Serializer_PHP, serialize)
1721 {
1722         //zend_object *obj = Z_OBJ_P(ZEND_THIS);
1723
1724         zval *data;
1725         ZEND_PARSE_PARAMETERS_START(1, 1)
1726                 Z_PARAM_ZVAL(data)
1727         ZEND_PARSE_PARAMETERS_END();
1728
1729         // TODO
1730         zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Not implemented");
1731 }
1732
1733 static ZEND_METHOD(ion_Unserializer_PHP, __construct)
1734 {
1735         php_ion_unserializer_php *obj = php_ion_obj(unserializer_php, Z_OBJ_P(ZEND_THIS));
1736         PTR_CHECK(obj);
1737
1738         obj->unserializer.call_magic = true;
1739
1740         ZEND_PARSE_PARAMETERS_START(0, 3)
1741                 Z_PARAM_OPTIONAL
1742                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Reader_Options)
1743                 Z_PARAM_BOOL(obj->unserializer.multi_seq)
1744                 Z_PARAM_BOOL(obj->unserializer.call_magic)
1745                 Z_PARAM_STR_OR_NULL(obj->unserializer.call_custom)
1746         ZEND_PARSE_PARAMETERS_END();
1747
1748         php_ion_unserializer_php_ctor(obj);
1749 }
1750 static ZEND_METHOD(ion_Unserializer_PHP, __invoke)
1751 {
1752         zend_object *obj = Z_OBJ_P(ZEND_THIS);
1753
1754         zval *data;
1755         ZEND_PARSE_PARAMETERS_START(1, 1)
1756                 Z_PARAM_ZVAL(data)
1757         ZEND_PARSE_PARAMETERS_END();
1758
1759         if (obj->ce == ce_Unserializer_PHP) {
1760                 php_ion_unserialize(&php_ion_obj(unserializer_php, obj)->unserializer, data, return_value);
1761         } else {
1762                 zend_call_method_with_1_params(obj, obj->ce, NULL /* TODO */, "unserialize", return_value, data);
1763         }
1764 }
1765 static ZEND_FUNCTION(ion_unserialize)
1766 {
1767         zval *data;
1768         zend_object *zo_ser = NULL;
1769         ZEND_PARSE_PARAMETERS_START(1, 2)
1770                 Z_PARAM_ZVAL(data)
1771                 Z_PARAM_OPTIONAL
1772                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(zo_ser, ce_Unserializer)
1773         ZEND_PARSE_PARAMETERS_END();
1774
1775         if (!zo_ser || zo_ser->ce == ce_Unserializer_PHP) {
1776                 // default, fast path
1777                 php_ion_unserializer *ser = zo_ser ? &php_ion_obj(unserializer_php, zo_ser)->unserializer : NULL;
1778                 php_ion_unserialize(ser, data, return_value);
1779         } else {
1780                 zend_call_method_with_1_params(zo_ser, NULL, NULL, "__invoke", return_value, data);
1781         }
1782 }
1783 static ZEND_METHOD(ion_Unserializer_PHP, unserialize)
1784 {
1785         //zend_object *obj = Z_OBJ_P(ZEND_THIS);
1786
1787         zval *data;
1788         ZEND_PARSE_PARAMETERS_START(1, 1)
1789                 Z_PARAM_ZVAL(data)
1790         ZEND_PARSE_PARAMETERS_END();
1791
1792         // TODO
1793         zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Not implemented");
1794 }
1795
1796 PHP_RINIT_FUNCTION(ion)
1797 {
1798 #if defined(ZTS) && defined(COMPILE_DL_ION)
1799         ZEND_TSRMLS_CACHE_UPDATE();
1800 #endif
1801
1802         php_ion_globals_symbols_init();
1803         php_ion_globals_serializer_init();
1804         php_ion_globals_unserializer_init();
1805         return SUCCESS;
1806 }
1807
1808 PHP_RSHUTDOWN_FUNCTION(ion)
1809 {
1810         php_ion_globals_unserializer_dtor();
1811         php_ion_globals_serializer_dtor();
1812         php_ion_globals_symbols_dtor();
1813         return SUCCESS;
1814 }
1815
1816 #define ZEND_ARG_VARIADIC_OBJ_TYPE_MASK(pass_by_ref, name, classname, type_mask, default_value) \
1817         { #name, ZEND_TYPE_INIT_CLASS_CONST_MASK(#classname, type_mask | _ZEND_ARG_INFO_FLAGS(pass_by_ref, 1, 0)), default_value },
1818 #include "ion_arginfo.h"
1819
1820 PHP_MINIT_FUNCTION(ion)
1821 {
1822         // true globals
1823         if (SUCCESS != g_sym_init())  {
1824                 return FAILURE;
1825         }
1826
1827         // Catalog
1828         php_ion_register(catalog, Catalog, zend_ce_countable);
1829
1830         // Decimal
1831         php_ion_register(decimal, Decimal);
1832         php_ion_register(decimal_ctx, Decimal_Context);
1833         ce_Decimal_Context_Rounding = register_class_ion_Decimal_Context_Rounding();
1834
1835         // LOB
1836         ce_LOB = register_class_ion_LOB();
1837
1838         // Reader
1839         ce_Reader = register_class_ion_Reader(spl_ce_RecursiveIterator);
1840         php_ion_register(reader_options, Reader_Options);
1841         php_ion_register(reader, Reader_Reader, ce_Reader);
1842         ce_Reader_Buffer = register_class_ion_Reader_Buffer(ce_Reader);
1843         ce_Reader_Buffer_Reader = register_class_ion_Reader_Buffer_Reader(ce_Reader_Reader, ce_Reader_Buffer);
1844         ce_Reader_Stream = register_class_ion_Reader_Stream(ce_Reader);
1845         ce_Reader_Stream_Reader = register_class_ion_Reader_Stream_Reader(ce_Reader_Reader, ce_Reader_Stream);
1846
1847         // Serializer
1848         ce_Serializer = register_class_ion_Serializer();
1849         php_ion_register(serializer_php, Serializer_PHP, ce_Serializer);
1850
1851         // Symbol
1852         php_ion_register(symbol, Symbol);
1853         oh_Symbol.compare = php_ion_symbol_zval_compare;
1854         php_ion_register(symbol_iloc, Symbol_ImportLocation);
1855         php_ion_register(symbol_table, Symbol_Table);
1856         ce_Symbol_Table->create_object = NULL;
1857         ce_Symbol_Table_Local = register_class_ion_Symbol_Table_Local(ce_Symbol_Table);
1858         ce_Symbol_Table_Local->create_object = create_ion_Symbol_Table;
1859         ce_Symbol_Table_Shared = register_class_ion_Symbol_Table_Shared(ce_Symbol_Table);
1860         ce_Symbol_Table_Shared->create_object = create_ion_Symbol_Table;
1861         ce_Symbol_Enum = register_class_ion_Symbol_Enum();
1862         ce_Symbol_Table_System = register_class_ion_Symbol_Table_System(ce_Symbol_Enum);
1863         ce_Symbol_Table_PHP = register_class_ion_Symbol_Table_PHP(ce_Symbol_Enum);
1864
1865         // Timestamp
1866         ce_Timestamp = register_class_ion_Timestamp(php_date_get_date_ce());
1867         ce_Timestamp_Precision = register_class_ion_Timestamp_Precision();
1868
1869         // Type
1870         php_ion_register(type, Type);
1871
1872         // Writer
1873         ce_Writer = register_class_ion_Writer();
1874         php_ion_register(writer_options, Writer_Options);
1875         php_ion_register(writer, Writer_Writer, ce_Writer);
1876         ce_Writer_Buffer = register_class_ion_Writer_Buffer(ce_Writer);
1877         ce_Writer_Buffer_Writer = register_class_ion_Writer_Buffer_Writer(ce_Writer_Writer, ce_Writer_Buffer);
1878         ce_Writer_Stream = register_class_ion_Writer_Stream(ce_Writer);
1879         ce_Writer_Stream_Writer = register_class_ion_Writer_Stream_Writer(ce_Writer_Writer, ce_Writer_Stream);
1880
1881         // Unserializer
1882         ce_Unserializer = register_class_ion_Unserializer();
1883         php_ion_register(unserializer_php, Unserializer_PHP, ce_Unserializer);
1884
1885         return SUCCESS;
1886 }
1887
1888 PHP_MSHUTDOWN_FUNCTION(ion)
1889 {
1890         if (g_sym_tab_php) {
1891                 ion_symbol_table_close(g_sym_tab_php);
1892         }
1893         zend_hash_destroy(&g_sym_hash);
1894         return SUCCESS;
1895 }
1896
1897 PHP_MINFO_FUNCTION(ion)
1898 {
1899         php_info_print_table_start();
1900         php_info_print_table_header(2, "ion support", "enabled");
1901         php_info_print_table_end();
1902 }
1903
1904 PHP_GINIT_FUNCTION(ion)
1905 {
1906         memset(ion_globals, 0, sizeof(*ion_globals));
1907
1908         php_ion_decimal_ctx_init_max(&ion_globals->decimal.ctx, DEC_ROUND_HALF_EVEN);
1909         php_ion_decimal_from_zend_long(&ion_globals->decimal.zend_max, &ion_globals->decimal.ctx, ZEND_LONG_MAX);
1910         php_ion_decimal_from_zend_long(&ion_globals->decimal.zend_min, &ion_globals->decimal.ctx, ZEND_LONG_MIN);
1911 }
1912
1913 PHP_GSHUTDOWN_FUNCTION(ion)
1914 {
1915 }
1916
1917 static zend_module_dep ion_module_deps[] = {
1918         ZEND_MOD_REQUIRED("date")
1919         ZEND_MOD_REQUIRED("spl")
1920         ZEND_MOD_END
1921 };
1922
1923 zend_module_entry ion_module_entry = {
1924         STANDARD_MODULE_HEADER_EX,
1925         NULL,
1926         ion_module_deps,
1927         "ion",                                  /* Extension name */
1928         ext_functions,                  /* zend_function_entry */
1929         PHP_MINIT(ion),                 /* PHP_MINIT - Module initialization */
1930         PHP_MSHUTDOWN(ion),             /* PHP_MSHUTDOWN - Module shutdown */
1931         PHP_RINIT(ion),                 /* PHP_RINIT - Request initialization */
1932         PHP_RSHUTDOWN(ion),             /* PHP_RSHUTDOWN - Request shutdown */
1933         PHP_MINFO(ion),                 /* PHP_MINFO - Module info */
1934         PHP_ION_VERSION,                /* Version */
1935         ZEND_MODULE_GLOBALS(ion),
1936         PHP_GINIT(ion),                 /* PHP_GINIT */
1937         PHP_GSHUTDOWN(ion),             /* PHP_GSHUTDOWN */
1938         NULL,
1939         STANDARD_MODULE_PROPERTIES_EX
1940 };
1941
1942 #ifdef COMPILE_DL_ION
1943 # ifdef ZTS
1944 ZEND_TSRMLS_CACHE_DEFINE()
1945 # endif
1946 ZEND_GET_MODULE(ion)
1947 #endif