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

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: ion                                                        |
   4     +--------------------------------------------------------------------+
   5     | Redistribution and use in source and binary forms, with or without |
   6     | modification, are permitted provided that the conditions mentioned |
   7     | in the accompanying LICENSE file are met.                          |
   8     +--------------------------------------------------------------------+
   9     | Copyright (c) 2021, Michael Wallner <mike@php.net>                 |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include "config.h"
  15 #endif
  16
  17 #include "php.h"
  18 #include "ext/standard/info.h"
  19
  20 #include "Zend/zend_enum.h"
  21 #include "Zend/zend_exceptions.h"
  22 #include "Zend/zend_closures.h"
  23 #include "Zend/zend_interfaces.h"
  24 #include "Zend/zend_smart_str.h"
  25
  26 #include "ext/date/php_date.h"
  27 #include "ext/spl/spl_exceptions.h"
  28 #include "ext/spl/spl_iterators.h"
  29
  30 #include "php_ion.h"
  31 #include "ion_private.h"
  32
  33 static ZEND_METHOD(ion_Symbol_ImportLocation, __construct)
  34 {
  35         php_ion_symbol_iloc *obj = php_ion_obj(symbol_iloc, Z_OBJ_P(ZEND_THIS));
  36         PTR_CHECK(obj);
  37
  38         zend_long location;
  39         ZEND_PARSE_PARAMETERS_START(2, 2)
  40                 Z_PARAM_STR(obj->name)
  41                 Z_PARAM_LONG(location)
  42         ZEND_PARSE_PARAMETERS_END();
  43
  44         obj->loc.location = location;
  45         php_ion_symbol_iloc_ctor(obj);
  46 }
  47 static ZEND_METHOD(ion_Symbol, __construct)
  48 {
  49         php_ion_symbol *obj = php_ion_obj(symbol, Z_OBJ_P(ZEND_THIS));
  50         PTR_CHECK(obj);
  51
  52         zend_long sid = -1;
  53         ZEND_PARSE_PARAMETERS_START(0, 3)
  54                 Z_PARAM_OPTIONAL
  55                 Z_PARAM_STR_OR_NULL(obj->value)
  56                 Z_PARAM_LONG(sid)
  57                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->iloc, ce_Symbol_ImportLocation)
  58         ZEND_PARSE_PARAMETERS_END();
  59
  60         obj->sym.sid = sid;
  61         php_ion_symbol_ctor(obj);
  62 }
  63 static ZEND_METHOD(ion_Symbol, equals)
  64 {
  65         php_ion_symbol *sym = php_ion_obj(symbol, Z_OBJ_P(ZEND_THIS));
  66         OBJ_CHECK(sym);
  67
  68         zend_object *other_obj;
  69         ZEND_PARSE_PARAMETERS_START(1, 1)
  70                 Z_PARAM_OBJ_OF_CLASS(other_obj, ce_Symbol)
  71         ZEND_PARSE_PARAMETERS_END();
  72
  73         BOOL eq = FALSE;
  74         iERR err = ion_symbol_is_equal(
  75                 &sym->sym,
  76                 &php_ion_obj(symbol, other_obj)->sym, &eq);
  77         ION_CHECK(err);
  78         RETVAL_BOOL(eq);
  79 }
  80 static ZEND_METHOD(ion_Symbol, __toString)
  81 {
  82         php_ion_symbol *sym = php_ion_obj(symbol, Z_OBJ_P(ZEND_THIS));
  83         OBJ_CHECK(sym);
  84
  85         ZEND_PARSE_PARAMETERS_NONE();
  86
  87         if (!sym->value) {
  88                 RETURN_EMPTY_STRING();
  89         }
  90         RETURN_STR_COPY(sym->value);
  91 }
  92 static ZEND_METHOD(ion_Symbol_Enum, toSymbol)
  93 {
  94         ZEND_PARSE_PARAMETERS_NONE();
  95
  96         zval *zc = zend_enum_fetch_case_name(Z_OBJ_P(ZEND_THIS));
  97         PTR_CHECK(zc);
  98
  99         zval *zsym = php_ion_global_symbol_fetch_by_enum(Z_STR_P(zc));
 100         PTR_CHECK(zsym);
 101         RETVAL_ZVAL(zsym, 1, 0);
 102 }
 103 static ZEND_METHOD(ion_Symbol_Enum, toSID)
 104 {
 105         ZEND_PARSE_PARAMETERS_NONE();
 106
 107         zval *zc = zend_enum_fetch_case_name(Z_OBJ_P(ZEND_THIS));
 108         PTR_CHECK(zc);
 109
 110         zval *zsym = php_ion_global_symbol_fetch_by_enum(Z_STR_P(zc));
 111         PTR_CHECK(zsym);
 112
 113         zval tmp;
 114         RETVAL_ZVAL(zend_read_property(Z_OBJCE_P(zsym), Z_OBJ_P(zsym), ZEND_STRL("sid"), 0, &tmp), 1, 0);
 115 }
 116 static ZEND_METHOD(ion_Symbol_Enum, toString)
 117 {
 118         ZEND_PARSE_PARAMETERS_NONE();
 119
 120         zval *zc = zend_enum_fetch_case_name(Z_OBJ_P(ZEND_THIS));
 121         PTR_CHECK(zc);
 122
 123         zval *zsym = php_ion_global_symbol_fetch_by_enum(Z_STR_P(zc));
 124         PTR_CHECK(zsym);
 125
 126         zval tmp;
 127         RETVAL_ZVAL(zend_read_property(Z_OBJCE_P(zsym), Z_OBJ_P(zsym), ZEND_STRL("value"), 0, &tmp), 1, 0);
 128 }
 129 static ZEND_FUNCTION(ion_Symbol_Table_System)
 130 {
 131         ZEND_PARSE_PARAMETERS_NONE();
 132
 133         object_init_ex(return_value, ce_Symbol_Table_Shared);
 134         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(return_value));
 135         ION_CHECK(ion_symbol_table_get_system_table(&obj->tab, 1));
 136         php_ion_symbol_table_ctor(obj);
 137         ion_symbol_table_lock(obj->tab);
 138 }
 139 static ZEND_FUNCTION(ion_Symbol_Table_PHP)
 140 {
 141         ZEND_PARSE_PARAMETERS_NONE();
 142
 143         object_init_ex(return_value, ce_Symbol_Table_Shared);
 144         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(return_value));
 145         obj->tab = g_sym_tab_php;
 146         php_ion_symbol_table_ctor(obj);
 147         ion_symbol_table_lock(obj->tab);
 148 }
 149 static ZEND_METHOD(ion_Symbol_Table_Local, __construct)
 150 {
 151         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 152         PTR_CHECK(obj);
 153
 154         ZEND_PARSE_PARAMETERS_NONE();
 155
 156         ION_CHECK(ion_symbol_table_open_with_type(&obj->tab, NULL, ist_LOCAL));
 157         obj->dtor = ion_symbol_table_close;
 158         OBJ_CHECK(obj);
 159 }
 160 static ZEND_METHOD(ion_Symbol_Table_Local, import)
 161 {
 162         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 163         OBJ_CHECK(obj);
 164
 165         zend_object *zo_import;
 166         ZEND_PARSE_PARAMETERS_START(1, 1)
 167                 Z_PARAM_OBJ_OF_CLASS(zo_import, ce_Symbol_Table);
 168         ZEND_PARSE_PARAMETERS_END();
 169
 170         php_ion_symbol_table_import(obj, php_ion_obj(symbol_table, zo_import));
 171 }
 172 static ZEND_METHOD(ion_Symbol_Table_Shared, __construct)
 173 {
 174         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 175         PTR_CHECK(obj);
 176
 177         zend_string *zname;
 178         zend_long version = 1;
 179         HashTable *ht_sym = NULL;
 180         ZEND_PARSE_PARAMETERS_START(1, 3)
 181                 Z_PARAM_STR(zname)
 182                 Z_PARAM_OPTIONAL
 183                 Z_PARAM_LONG(version)
 184                 Z_PARAM_ARRAY_HT_OR_NULL(ht_sym)
 185         ZEND_PARSE_PARAMETERS_END();
 186
 187         ION_CHECK(ion_symbol_table_open_with_type(&obj->tab, NULL, ist_SHARED));
 188         obj->dtor = ion_symbol_table_close;
 189
 190         ION_STRING is;
 191         ION_CHECK(ion_symbol_table_set_name(obj->tab, ion_string_from_zend(&is, zname)));
 192         ION_CHECK(ion_symbol_table_set_version(obj->tab, version));
 193
 194         php_ion_symbol_table_ctor(obj);
 195
 196         zval *zsym;
 197         if (ht_sym) ZEND_HASH_FOREACH_VAL(ht_sym, zsym)
 198         {
 199                 zend_string *str = zval_get_string(zsym);
 200                 if (EG(exception)) {
 201                         break;
 202                 }
 203
 204                 ION_STRING is;
 205                 ION_CHECK(ion_symbol_table_add_symbol(obj->tab, ion_string_from_zend(&is, str), NULL), zend_string_release(str));
 206                 zend_string_release(str);
 207         }
 208         ZEND_HASH_FOREACH_END();
 209 }
 210 static ZEND_METHOD(ion_Symbol_Table, getMaxId)
 211 {
 212         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 213         OBJ_CHECK(obj);
 214
 215         ZEND_PARSE_PARAMETERS_NONE();
 216
 217         SID max_sid;
 218         ION_CHECK(ion_symbol_table_get_max_sid(obj->tab, &max_sid));
 219         RETURN_LONG(max_sid);
 220 }
 221 static ZEND_METHOD(ion_Symbol_Table, add)
 222 {
 223         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 224         OBJ_CHECK(obj);
 225
 226         zend_object *zo_sym = NULL;
 227         zend_string *zs_sym = NULL;
 228         ZEND_PARSE_PARAMETERS_START(1, 1)
 229                 Z_PARAM_OBJ_OF_CLASS_OR_STR(zo_sym, ce_Symbol, zs_sym)
 230         ZEND_PARSE_PARAMETERS_END();
 231
 232         if (zo_sym) {
 233                 zval z_sym;
 234                 ZVAL_OBJ(&z_sym, zo_sym);
 235                 zs_sym = zval_get_string(&z_sym);
 236                 ION_CATCH();
 237         }
 238         SID sid;
 239         ION_STRING is;
 240         ION_CHECK(ion_symbol_table_add_symbol(obj->tab, ion_string_from_zend(&is, zs_sym), &sid),
 241                         if (zo_sym) {
 242                                 zend_string_release(zs_sym);
 243                         });
 244         if (zo_sym) {
 245                 zend_string_release(zs_sym);
 246         }
 247         RETURN_LONG(sid);
 248 }
 249 static ZEND_METHOD(ion_Symbol_Table, find)
 250 {
 251         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 252         OBJ_CHECK(obj);
 253
 254         zend_long zsid;
 255         zend_string *zstring = NULL;
 256         ZEND_PARSE_PARAMETERS_START(1, 1)
 257                 Z_PARAM_STR_OR_LONG(zstring, zsid)
 258         ZEND_PARSE_PARAMETERS_END();
 259
 260         if (zstring) {
 261                 SID sid;
 262                 ION_STRING is;
 263                 ION_CHECK(ion_symbol_table_find_by_name(obj->tab, ion_string_from_zend(&is, zstring), &sid));
 264                 zsid = sid;
 265         }
 266         ION_SYMBOL *sym;
 267         ION_CHECK(ion_symbol_table_get_symbol(obj->tab, zsid, &sym));
 268         if (sym) {
 269                 php_ion_symbol_table_symbol_zval(obj, sym, return_value);
 270         }
 271 }
 272 static ZEND_METHOD(ion_Symbol_Table, findLocal)
 273 {
 274         php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(ZEND_THIS));
 275         OBJ_CHECK(obj);
 276
 277         zend_long zsid;
 278         zend_string *zstring;
 279         ZEND_PARSE_PARAMETERS_START(1, 1)
 280                 Z_PARAM_STR_OR_LONG(zstring, zsid)
 281         ZEND_PARSE_PARAMETERS_END();
 282
 283         if (zstring) {
 284                 SID sid;
 285                 ION_STRING is;
 286                 ION_CHECK(ion_symbol_table_find_by_name(obj->tab, ion_string_from_zend(&is, zstring), &sid));
 287                 zsid = sid;
 288         }
 289         ION_SYMBOL *sym;
 290         ION_CHECK(ion_symbol_table_get_local_symbol(obj->tab, zsid, &sym));
 291         if (sym) {
 292                 php_ion_symbol_table_symbol_zval(obj, sym, return_value);
 293         }
 294 }
 295 static ZEND_METHOD(ion_Catalog, __construct)
 296 {
 297         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 298         PTR_CHECK(obj);
 299
 300         ZEND_PARSE_PARAMETERS_NONE();
 301
 302         php_ion_catalog_ctor(obj);
 303 }
 304 static ZEND_METHOD(ion_Catalog, count)
 305 {
 306         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 307         OBJ_CHECK(obj);
 308
 309         ZEND_PARSE_PARAMETERS_NONE();
 310
 311         int32_t c;
 312         ION_CHECK(ion_catalog_get_symbol_table_count(obj->cat, &c));
 313         RETURN_LONG(c);
 314 }
 315 static ZEND_METHOD(ion_Catalog, add)
 316 {
 317         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 318         OBJ_CHECK(obj);
 319
 320         zend_object *zo_symtab;
 321         ZEND_PARSE_PARAMETERS_START(1, 1)
 322                 Z_PARAM_OBJ_OF_CLASS(zo_symtab, ce_Symbol_Table)
 323         ZEND_PARSE_PARAMETERS_END();
 324
 325         php_ion_symbol_table *o_symtab = php_ion_obj(symbol_table, zo_symtab);
 326         php_ion_catalog_add_symbol_table(obj, o_symtab);
 327 }
 328
 329 static ZEND_METHOD(ion_Catalog, remove)
 330 {
 331         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 332         OBJ_CHECK(obj);
 333
 334         zend_object *zo_symtab = NULL;
 335         zend_string *zs_symtab = NULL;
 336         ZEND_PARSE_PARAMETERS_START(1, 1)
 337                 Z_PARAM_OBJ_OF_CLASS_OR_STR(zo_symtab, ce_Symbol_Table, zs_symtab)
 338         ZEND_PARSE_PARAMETERS_END();
 339
 340         RETVAL_FALSE;
 341
 342         zval tmp;
 343         zval *ztabs = zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("symbolTables"), 0, &tmp);
 344         if (ztabs) {
 345                 if (zo_symtab) {
 346                         // fast path
 347                         zend_ulong idx = (uintptr_t) &zo_symtab->gc;
 348                         RETVAL_BOOL(SUCCESS == zend_hash_index_del(Z_ARRVAL_P(ztabs), idx));
 349                         ION_CHECK(ion_catalog_release_symbol_table(obj->cat, php_ion_obj(symbol_table, zo_symtab)->tab));
 350                 } else {
 351                         bool deleted = false;
 352                         ION_SYMBOL_TABLE *tab;
 353                         ION_STRING is;
 354                         ion_string_from_zend(&is, zs_symtab);
 355                         do {
 356                                 tab = NULL;
 357                                 ION_CHECK(ion_catalog_find_best_match(obj->cat, &is, 0, &tab));
 358                                 if (tab) {
 359                                         ION_CHECK(ion_catalog_release_symbol_table(obj->cat, tab));
 360                                         deleted = true;
 361                                 }
 362                         } while(tab);
 363                         RETVAL_BOOL(deleted);
 364                 }
 365         }
 366 }
 367 static ZEND_METHOD(ion_Catalog, find)
 368 {
 369         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 370         OBJ_CHECK(obj);
 371
 372         zend_long zversion = 0;
 373         zend_string *zname;
 374         ZEND_PARSE_PARAMETERS_START(1, 2)
 375                 Z_PARAM_STR(zname)
 376                 Z_PARAM_OPTIONAL
 377                 Z_PARAM_LONG(zversion)
 378         ZEND_PARSE_PARAMETERS_END();
 379
 380         ION_STRING is;
 381         ION_SYMBOL_TABLE *tab_ptr = NULL;
 382         ION_CHECK(ion_catalog_find_symbol_table(obj->cat, ion_string_from_zend(&is, zname), zversion, &tab_ptr));
 383         if (tab_ptr) {
 384                 php_ion_catalog_symbol_table_zval(obj, tab_ptr, return_value);
 385         }
 386 }
 387 static ZEND_METHOD(ion_Catalog, findBest)
 388 {
 389         php_ion_catalog *obj = php_ion_obj(catalog, Z_OBJ_P(ZEND_THIS));
 390         OBJ_CHECK(obj);
 391
 392         zend_long zversion = 0;
 393         zend_string *zname;
 394         ZEND_PARSE_PARAMETERS_START(1, 2)
 395                 Z_PARAM_STR(zname)
 396                 Z_PARAM_OPTIONAL
 397                 Z_PARAM_LONG(zversion)
 398         ZEND_PARSE_PARAMETERS_END();
 399
 400         ION_STRING is;
 401         ION_SYMBOL_TABLE *tab_ptr = NULL;
 402         ION_CHECK(ion_catalog_find_best_match(obj->cat, ion_string_from_zend(&is, zname), zversion, &tab_ptr));
 403         if (tab_ptr) {
 404                 php_ion_catalog_symbol_table_zval(obj, tab_ptr, return_value);
 405         }
 406 }
 407 static ZEND_METHOD(ion_Timestamp, __construct)
 408 {
 409         php_ion_timestamp *obj = php_ion_obj(timestamp, Z_OBJ_P(ZEND_THIS));
 410         PTR_CHECK(obj);
 411
 412         zend_long precision;
 413         zend_object *precision_obj;
 414         zend_string *fmt = NULL, *dt = NULL;
 415         zval *tz = NULL;
 416         ZEND_PARSE_PARAMETERS_START(1, 4)
 417                 Z_PARAM_OBJ_OF_CLASS_OR_LONG(precision_obj, ce_Timestamp_Precision, precision)
 418                 Z_PARAM_OPTIONAL
 419                 Z_PARAM_STR_OR_NULL(fmt)
 420                 Z_PARAM_STR_OR_NULL(dt)
 421                 Z_PARAM_ZVAL(tz)
 422         ZEND_PARSE_PARAMETERS_END();
 423
 424         if (precision_obj) {
 425                 precision = Z_LVAL_P(zend_enum_fetch_case_value(precision_obj));
 426         }
 427         php_ion_timestamp_ctor(obj, precision, fmt, dt, tz);
 428 }
 429 static ZEND_METHOD(ion_Timestamp, __toString)
 430 {
 431         php_ion_timestamp *obj = php_ion_obj(timestamp, Z_OBJ_P(ZEND_THIS));
 432         OBJ_CHECK(obj);
 433
 434         ZEND_PARSE_PARAMETERS_NONE();
 435
 436         zval fmt;
 437         ZVAL_NULL(&fmt);
 438         zend_call_method_with_1_params(&obj->std, obj->std.ce, NULL, "format", return_value,
 439                 zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("format"), 0, &fmt));
 440 }
 441 static ZEND_METHOD(ion_Decimal_Context, __construct)
 442 {
 443         php_ion_decimal_ctx *obj = php_ion_obj(decimal_ctx, Z_OBJ_P(ZEND_THIS));
 444         PTR_CHECK(obj);
 445
 446         zend_bool clamp;
 447         zend_object *o_round = NULL;
 448         zend_long digits, emax, emin, round;
 449         ZEND_PARSE_PARAMETERS_START(5, 5)
 450                 Z_PARAM_LONG(digits)
 451                 Z_PARAM_LONG(emax)
 452                 Z_PARAM_LONG(emin)
 453                 Z_PARAM_OBJ_OF_CLASS_OR_LONG(o_round, ce_Decimal_Context_Rounding, round)
 454                 Z_PARAM_BOOL(clamp)
 455         ZEND_PARSE_PARAMETERS_END();
 456
 457         if (o_round) {
 458                 round = Z_LVAL_P(zend_enum_fetch_case_value(o_round));
 459         }
 460         php_ion_decimal_ctx_init(&obj->ctx, digits, emax, emin, round, clamp);
 461         php_ion_decimal_ctx_ctor(obj, o_round);
 462 }
 463 static inline void make_decimal_ctx(INTERNAL_FUNCTION_PARAMETERS, int kind)
 464 {
 465         ZEND_PARSE_PARAMETERS_NONE();
 466
 467         object_init_ex(return_value, ce_Decimal_Context);
 468         php_ion_decimal_ctx *obj = php_ion_obj(decimal_ctx, Z_OBJ_P(return_value));
 469         decContextDefault(&obj->ctx, kind);
 470         php_ion_decimal_ctx_ctor(obj, NULL);
 471 }
 472 static ZEND_METHOD(ion_Decimal_Context, Dec32)
 473 {
 474         make_decimal_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, DEC_INIT_DECIMAL32);
 475 }
 476 static ZEND_METHOD(ion_Decimal_Context, Dec64)
 477 {
 478         make_decimal_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, DEC_INIT_DECIMAL64);
 479 }
 480 static ZEND_METHOD(ion_Decimal_Context, Dec128)
 481 {
 482         make_decimal_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, DEC_INIT_DECIMAL128);
 483 }
 484 static ZEND_METHOD(ion_Decimal_Context, DecMax)
 485 {
 486         zend_object *o_round = NULL;
 487         zend_long round = DEC_ROUND_HALF_EVEN;
 488         ZEND_PARSE_PARAMETERS_START(0, 1)
 489                 Z_PARAM_OPTIONAL
 490                 Z_PARAM_OBJ_OF_CLASS_OR_LONG(o_round, ce_Decimal_Context_Rounding, round)
 491         ZEND_PARSE_PARAMETERS_END();
 492
 493         if (o_round) {
 494                 round = Z_LVAL_P(zend_enum_fetch_case_value(o_round));
 495         }
 496         object_init_ex(return_value, ce_Decimal_Context);
 497         php_ion_decimal_ctx *obj = php_ion_obj(decimal_ctx, Z_OBJ_P(return_value));
 498         php_ion_decimal_ctx_init_max(&obj->ctx, round);
 499         php_ion_decimal_ctx_ctor(obj, o_round);
 500 }
 501 static ZEND_METHOD(ion_Decimal, __construct)
 502 {
 503         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 504         PTR_CHECK(obj);
 505
 506         zend_long num;
 507         zend_string *zstr;
 508         ZEND_PARSE_PARAMETERS_START(1, 2)
 509                 Z_PARAM_STR_OR_LONG(zstr, num)
 510                 Z_PARAM_OPTIONAL
 511                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->ctx, ce_Decimal_Context)
 512         ZEND_PARSE_PARAMETERS_END();
 513
 514         if (obj->ctx) {
 515                 GC_ADDREF(obj->ctx);
 516         } else {
 517                 zval zdc;
 518                 object_init_ex(&zdc, ce_Decimal_Context);
 519                 obj->ctx = Z_OBJ(zdc);
 520                 php_ion_decimal_ctx_ctor(php_ion_obj(decimal_ctx, obj->ctx), NULL);
 521         }
 522
 523         decContext *ctx = &php_ion_obj(decimal_ctx, obj->ctx)->ctx;
 524
 525         if (zstr) {
 526                 ION_CHECK(ion_decimal_from_string(&obj->dec, zstr->val, ctx), OBJ_RELEASE(obj->ctx));
 527         } else {
 528                 php_ion_decimal_from_zend_long(&obj->dec, ctx, num);
 529         }
 530
 531         php_ion_decimal_ctor(obj);
 532         OBJ_RELEASE(obj->ctx);
 533 }
 534 static ZEND_METHOD(ion_Decimal, equals)
 535 {
 536         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 537         PTR_CHECK(obj);
 538
 539         zend_object *dec_obj;
 540         ZEND_PARSE_PARAMETERS_START(1, 1)
 541                 Z_PARAM_OBJ_OF_CLASS(dec_obj, ce_Decimal)
 542         ZEND_PARSE_PARAMETERS_END();
 543
 544         BOOL is = FALSE;
 545         ION_CHECK(ion_decimal_equals(&obj->dec, &php_ion_obj(decimal, dec_obj)->dec,
 546                 obj->ctx ? &php_ion_obj(decimal_ctx, obj->ctx)->ctx : NULL, &is));
 547         RETURN_BOOL(is);
 548 }
 549 static ZEND_METHOD(ion_Decimal, __toString)
 550 {
 551         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 552         PTR_CHECK(obj);
 553
 554         ZEND_PARSE_PARAMETERS_NONE();
 555
 556         RETURN_STR(php_ion_decimal_to_string(&obj->dec));
 557 }
 558 static ZEND_METHOD(ion_Decimal, toInt)
 559 {
 560         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 561         PTR_CHECK(obj);
 562
 563         ZEND_PARSE_PARAMETERS_NONE();
 564
 565         zend_long l;
 566         php_ion_decimal_to_zend_long(&obj->dec, &php_ion_obj(decimal_ctx, obj->ctx)->ctx, &l);
 567         RETURN_LONG(l);
 568 }
 569 static ZEND_METHOD(ion_Decimal, isInt)
 570 {
 571         php_ion_decimal *obj = php_ion_obj(decimal, Z_OBJ_P(ZEND_THIS));
 572         PTR_CHECK(obj);
 573
 574         ZEND_PARSE_PARAMETERS_NONE();
 575
 576         RETURN_BOOL(ion_decimal_is_integer(&obj->dec));
 577 }
 578 static ZEND_METHOD(ion_LOB, __construct)
 579 {
 580         zend_string *value;
 581         zend_object *type = NULL;
 582         ZEND_PARSE_PARAMETERS_START(1, 2)
 583                 Z_PARAM_STR(value)
 584                 Z_PARAM_OPTIONAL
 585                 Z_PARAM_OBJ_OF_CLASS(type, ce_Type)
 586         ZEND_PARSE_PARAMETERS_END();
 587
 588         if (!type) {
 589                 type = zend_enum_get_case_cstr(ce_Type, "CLob");
 590         }
 591         update_property_obj(Z_OBJ_P(ZEND_THIS), ZEND_STRL("type"), type);
 592         zend_update_property_str(Z_OBJCE_P(ZEND_THIS), Z_OBJ_P(ZEND_THIS), ZEND_STRL("value"), value);
 593 }
 594 static ZEND_METHOD(ion_Reader_Options, __construct)
 595 {
 596         php_ion_reader_options *opt = php_ion_obj(reader_options, Z_OBJ_P(ZEND_THIS));
 597         zend_bool ret_sys_val = false, skip_validation = false;
 598         zend_long ch_nl = 0xa, max_depth = 10, max_ann = 10, max_ann_buf = 512,
 599                         sym_thr = 0x4000, uval_thr = 0x4000, chunk_thr = 0x4000, alloc_pgsz = 0x10000;
 600
 601         PTR_CHECK(opt);
 602
 603         ZEND_PARSE_PARAMETERS_START(0, 13)
 604                 Z_PARAM_OPTIONAL
 605         // public readonly ?\ion\Catalog $catalog = null,
 606                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(opt->cat, ce_Catalog)
 607         // public readonly ?\ion\Decimal\Context $decimalContext = null,
 608                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(opt->dec_ctx, ce_Decimal_Context)
 609         // public readonly ?\Closure $onContextChange = null,
 610                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(opt->cb, zend_ce_closure);
 611         // public readonly bool $returnSystemValues = false,
 612                 Z_PARAM_BOOL(ret_sys_val)
 613         // public readonly int $newLine = 0xa,
 614                 Z_PARAM_LONG(ch_nl)
 615         // public readonly int $maxContainerDepth = 10,
 616                 Z_PARAM_LONG(max_depth)
 617         // public readonly int $maxAnnotations = 10,
 618                 Z_PARAM_LONG(max_ann)
 619         // public readonly int $maxAnnotationBuffered = 512,
 620                 Z_PARAM_LONG(max_ann_buf)
 621         // public readonly int $symbolThreshold = 0x4000,
 622                 Z_PARAM_LONG(sym_thr)
 623         // public readonly int $userValueThreshold = 0x4000,
 624                 Z_PARAM_LONG(uval_thr)
 625         // public readonly int $chunkThreshold = 0x4000,
 626                 Z_PARAM_LONG(chunk_thr)
 627         // public readonly int $allocationPageSize = 0x10000,
 628                 Z_PARAM_LONG(alloc_pgsz)
 629         // public readonly bool $skipCharacterValidation = false,
 630                 Z_PARAM_BOOL(skip_validation)
 631         ZEND_PARSE_PARAMETERS_END();
 632
 633         if (opt->cb) {
 634                 zval zcb;
 635                 ZVAL_OBJ(&zcb, opt->cb);
 636                 zend_fcall_info_init(&zcb, 0, &opt->ccn.fci, &opt->ccn.fcc, NULL, NULL);
 637                 opt->opt.context_change_notifier.context = &opt->ccn;
 638                 update_property_obj(&opt->std, ZEND_STRL("onContextChange"), opt->cb);
 639         } else {
 640                 zend_update_property_null(NULL, &opt->std, ZEND_STRL("onContextChange"));
 641         }
 642         if (opt->cat) {
 643                 update_property_obj(&opt->std, ZEND_STRL("catalog"), opt->cat);
 644                 opt->opt.pcatalog = php_ion_obj(catalog, opt->cat)->cat;
 645         } else {
 646                 zend_update_property_null(NULL, &opt->std, ZEND_STRL("catalog"));
 647         }
 648         if (opt->dec_ctx) {
 649                 update_property_obj(&opt->std, ZEND_STRL("decimalContext"), opt->dec_ctx);
 650                 opt->opt.decimal_context = &php_ion_obj(decimal_ctx, opt->dec_ctx)->ctx;
 651         } else {
 652                 zend_update_property_null(NULL, &opt->std, ZEND_STRL("decimalContext"));
 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("maxAnnotations"),
 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         } else {
1259                 zend_update_property_null(NULL, &obj->std, ZEND_STRL("catalog"));
1260         }
1261         if (obj->dec_ctx) {
1262                 update_property_obj(&obj->std, ZEND_STRL("decimalContext"), obj->dec_ctx);
1263                 obj->opt.decimal_context = &php_ion_obj(decimal_ctx, obj->dec_ctx)->ctx;
1264         } else {
1265                 zend_update_property_null(NULL, &obj->std, ZEND_STRL("decimalContext"));
1266         }
1267         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("outputBinary"),
1268                         obj->opt.output_as_binary = binary);
1269         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("compactFloats"),
1270                         obj->opt.compact_floats = compact_floats);
1271         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("escapeNonAscii"),
1272                         obj->opt.escape_all_non_ascii = escape);
1273         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("prettyPrint"),
1274                         obj->opt.pretty_print = pretty);
1275         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("indentTabs"),
1276                         obj->opt.indent_with_tabs = tabs);
1277         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("indentSize"),
1278                         obj->opt.indent_size = indent);
1279         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("smallContainersInline"),
1280                         obj->opt.small_containers_in_line = small_cntr_inl);
1281         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("suppressSystemValues"),
1282                         obj->opt.supress_system_values = suppress_sys);
1283         zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("flushEveryValue"),
1284                         obj->opt.flush_every_value = flush);
1285         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("maxContainerDepth"),
1286                         obj->opt.max_container_depth = max_depth);
1287         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("maxAnnotations"),
1288                         obj->opt.max_annotation_count = max_ann);
1289         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("tempBufferSize"),
1290                         obj->opt.temp_buffer_size = temp);
1291         zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("allocationPageSize"),
1292                         obj->opt.allocation_page_size = alloc);
1293 }
1294 static ZEND_METHOD(ion_Writer_Writer, writeNull)
1295 {
1296         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1297         OBJ_CHECK(obj);
1298
1299         ZEND_PARSE_PARAMETERS_NONE();
1300
1301         ION_CHECK(ion_writer_write_null(obj->writer));
1302 }
1303 static ZEND_METHOD(ion_Writer_Writer, writeTypedNull)
1304 {
1305         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1306         OBJ_CHECK(obj);
1307
1308         zend_object *typ_obj;
1309         ZEND_PARSE_PARAMETERS_START(1, 1)
1310                 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1311         ZEND_PARSE_PARAMETERS_END();
1312
1313         php_ion_type *typ = php_ion_obj(type, typ_obj);
1314         OBJ_CHECK(typ);
1315         ION_CHECK(ion_writer_write_typed_null(obj->writer, php_ion_obj(type, typ)->typ));
1316 }
1317 static ZEND_METHOD(ion_Writer_Writer, writeBool)
1318 {
1319         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1320         OBJ_CHECK(obj);
1321
1322         zend_bool b;
1323         ZEND_PARSE_PARAMETERS_START(1, 1)
1324                 Z_PARAM_BOOL(b)
1325         ZEND_PARSE_PARAMETERS_END();
1326
1327         ION_CHECK(ion_writer_write_bool(obj->writer, b));
1328 }
1329 static ZEND_METHOD(ion_Writer_Writer, writeInt)
1330 {
1331         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1332         OBJ_CHECK(obj);
1333
1334         zend_long l;
1335         zend_string *s;
1336         ZEND_PARSE_PARAMETERS_START(1, 1)
1337                 Z_PARAM_STR_OR_LONG(s, l)
1338         ZEND_PARSE_PARAMETERS_END();
1339
1340         if (s) {
1341                 ION_INT *i;
1342                 ION_CHECK(ion_int_alloc(obj->writer, &i));
1343                 ION_CHECK(ion_int_from_chars(i, s->val, s->len));
1344                 ION_CHECK(ion_writer_write_ion_int(obj->writer, i));
1345                 ion_int_free(i);
1346         } else {
1347                 ION_CHECK(ion_writer_write_int64(obj->writer, l));
1348         }
1349 }
1350 static ZEND_METHOD(ion_Writer_Writer, writeFloat)
1351 {
1352         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1353         OBJ_CHECK(obj);
1354
1355         double d;
1356         ZEND_PARSE_PARAMETERS_START(1, 1)
1357                 Z_PARAM_DOUBLE(d)
1358         ZEND_PARSE_PARAMETERS_END();
1359
1360         ION_CHECK(ion_writer_write_double(obj->writer, d));
1361 }
1362 static ZEND_METHOD(ion_Writer_Writer, writeDecimal)
1363 {
1364         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1365         OBJ_CHECK(obj);
1366
1367         zend_object *dec_obj;
1368         zend_string *dec_str;
1369         ZEND_PARSE_PARAMETERS_START(1, 1)
1370                 Z_PARAM_OBJ_OF_CLASS_OR_STR(dec_obj, ce_Decimal, dec_str)
1371         ZEND_PARSE_PARAMETERS_END();
1372
1373         if (dec_str) {
1374                 ION_STRING s;
1375                 ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&s, dec_str)));
1376         } else {
1377                 php_ion_decimal *dec = php_ion_obj(decimal, dec_obj);
1378                 ION_CHECK(ion_writer_write_ion_decimal(obj->writer, &dec->dec));
1379         }
1380 }
1381 static ZEND_METHOD(ion_Writer_Writer, writeTimestamp)
1382 {
1383         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1384         OBJ_CHECK(obj);
1385
1386         zend_object *ts_obj;
1387         zend_string *ts_str;
1388         ZEND_PARSE_PARAMETERS_START(1, 1)
1389                 Z_PARAM_OBJ_OF_CLASS_OR_STR(ts_obj, ce_Timestamp, ts_str)
1390         ZEND_PARSE_PARAMETERS_END();
1391
1392         decContext *ctx = NULL;
1393         if (obj->opt) {
1394                 ctx = php_ion_obj(reader_options, obj->opt)->opt.decimal_context;
1395         }
1396
1397         ION_TIMESTAMP tmp = {0};
1398         if (ts_str) {
1399                 SIZE used;
1400                 ION_CHECK(ion_timestamp_parse(&tmp, ts_str->val, ts_str->len, &used, ctx));
1401         } else {
1402                 php_ion_timestamp *ts = php_ion_obj(timestamp, ts_obj);
1403                 OBJ_CHECK(ts);
1404                 ion_timestamp_from_php(&tmp, ts, ctx);
1405         }
1406         ION_CHECK(ion_writer_write_timestamp(obj->writer, &tmp));
1407 }
1408 static ZEND_METHOD(ion_Writer_Writer, writeSymbol)
1409 {
1410         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1411         OBJ_CHECK(obj);
1412
1413         zend_object *sym_obj;
1414         zend_string *sym_str;
1415         ZEND_PARSE_PARAMETERS_START(1, 1)
1416                 Z_PARAM_OBJ_OF_CLASS_OR_STR(sym_obj, ce_Symbol, sym_str);
1417         ZEND_PARSE_PARAMETERS_END();
1418
1419         if (sym_str) {
1420                 ION_STRING is;
1421                 ION_CHECK(ion_writer_write_symbol(obj->writer, ion_string_from_zend(&is, sym_str)));
1422         } else {
1423                 php_ion_symbol *sym = php_ion_obj(symbol, sym_obj);
1424                 PTR_CHECK(sym);
1425                 ION_CHECK(ion_writer_write_ion_symbol(obj->writer, &sym->sym));
1426         }
1427 }
1428 static ZEND_METHOD(ion_Writer_Writer, writeString)
1429 {
1430         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1431         OBJ_CHECK(obj);
1432
1433         zend_string *str;
1434         ZEND_PARSE_PARAMETERS_START(1, 1)
1435                 Z_PARAM_STR(str)
1436         ZEND_PARSE_PARAMETERS_END();
1437
1438         ION_STRING is;
1439         ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&is, str)));
1440 }
1441 static ZEND_METHOD(ion_Writer_Writer, writeCLob)
1442 {
1443         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1444         OBJ_CHECK(obj);
1445
1446         zend_string *str;
1447         ZEND_PARSE_PARAMETERS_START(1, 1)
1448                 Z_PARAM_STR(str)
1449         ZEND_PARSE_PARAMETERS_END();
1450
1451         ION_CHECK(ion_writer_write_clob(obj->writer, (BYTE *) str->val, str->len));
1452 }
1453 static ZEND_METHOD(ion_Writer_Writer, writeBLob)
1454 {
1455         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1456         OBJ_CHECK(obj);
1457
1458         zend_string *str;
1459         ZEND_PARSE_PARAMETERS_START(1, 1)
1460                 Z_PARAM_STR(str)
1461         ZEND_PARSE_PARAMETERS_END();
1462
1463         ION_CHECK(ion_writer_write_blob(obj->writer, (BYTE *) str->val, str->len));
1464 }
1465 static ZEND_METHOD(ion_Writer_Writer, startLob)
1466 {
1467         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1468         OBJ_CHECK(obj);
1469
1470         zend_object *typ_obj;
1471         ZEND_PARSE_PARAMETERS_START(1, 1)
1472                 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1473         ZEND_PARSE_PARAMETERS_END();
1474
1475         php_ion_type *typ = php_ion_obj(type, typ_obj);
1476         OBJ_CHECK(typ);
1477         ION_CHECK(ion_writer_start_lob(obj->writer, php_ion_obj(type, typ)->typ));
1478 }
1479 static ZEND_METHOD(ion_Writer_Writer, appendLob)
1480 {
1481         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1482         OBJ_CHECK(obj);
1483
1484         zend_string *str;
1485         ZEND_PARSE_PARAMETERS_START(1, 1)
1486                 Z_PARAM_STR(str)
1487         ZEND_PARSE_PARAMETERS_END();
1488
1489         ION_CHECK(ion_writer_append_lob(obj->writer, (BYTE *) str->val, str->len));
1490 }
1491 static ZEND_METHOD(ion_Writer_Writer, finishLob)
1492 {
1493         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1494         OBJ_CHECK(obj);
1495
1496         ZEND_PARSE_PARAMETERS_NONE();
1497
1498         ION_CHECK(ion_writer_finish_lob(obj->writer));
1499 }
1500 static ZEND_METHOD(ion_Writer_Writer, startContainer)
1501 {
1502         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1503         OBJ_CHECK(obj);
1504
1505         zend_object *typ_obj;
1506         ZEND_PARSE_PARAMETERS_START(1, 1)
1507                 Z_PARAM_OBJ_OF_CLASS(typ_obj, ce_Type)
1508         ZEND_PARSE_PARAMETERS_END();
1509
1510         php_ion_type *typ = php_ion_obj(type, typ_obj);
1511         OBJ_CHECK(typ);
1512         ION_CHECK(ion_writer_start_container(obj->writer, php_ion_obj(type, typ)->typ));
1513 }
1514 static ZEND_METHOD(ion_Writer_Writer, finishContainer)
1515 {
1516         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1517         OBJ_CHECK(obj);
1518
1519         ZEND_PARSE_PARAMETERS_NONE();
1520
1521         ION_CHECK(ion_writer_finish_container(obj->writer));
1522 }
1523 static ZEND_METHOD(ion_Writer_Writer, writeFieldName)
1524 {
1525         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1526         OBJ_CHECK(obj);
1527
1528         zend_object *sym_obj;
1529         zend_string *sym_str;
1530         ZEND_PARSE_PARAMETERS_START(1, 1)
1531                 Z_PARAM_OBJ_OF_CLASS_OR_STR(sym_obj, ce_Symbol, sym_str);
1532         ZEND_PARSE_PARAMETERS_END();
1533
1534         if (sym_str) {
1535                 ION_STRING is;
1536                 ION_CHECK(ion_writer_write_field_name(obj->writer, ion_string_from_zend(&is, sym_str)));
1537         } else {
1538                 php_ion_symbol *sym = php_ion_obj(symbol, sym_obj);
1539                 PTR_CHECK(sym);
1540                 ION_CHECK(ion_writer_write_field_name_symbol(obj->writer, &sym->sym));
1541         }
1542 }
1543 static ZEND_METHOD(ion_Writer_Writer, writeAnnotation)
1544 {
1545         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1546         OBJ_CHECK(obj);
1547
1548         zval *args;
1549         unsigned argc;
1550         ZEND_PARSE_PARAMETERS_START(1, -1)
1551                 Z_PARAM_VARIADIC('+', args, argc);
1552         ZEND_PARSE_PARAMETERS_END();
1553
1554         for (unsigned i = 0; i < argc; ++i) {
1555                 switch (Z_TYPE(args[i])) {
1556                 case IS_STRING:
1557                         ION_STRING is;
1558                         ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_zend(&is, Z_STR(args[i]))));
1559                         break;
1560
1561                 case IS_OBJECT:
1562                         ION_CHECK(ion_writer_add_annotation_symbol(obj->writer, &php_ion_obj(symbol, Z_OBJ(args[i]))->sym));
1563                         break;
1564                 }
1565         }
1566 }
1567 static ZEND_METHOD(ion_Writer_Writer, getDepth)
1568 {
1569         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1570         OBJ_CHECK(obj);
1571
1572         ZEND_PARSE_PARAMETERS_NONE();
1573
1574         SIZE depth;
1575         ION_CHECK(ion_writer_get_depth(obj->writer, &depth));
1576         RETURN_LONG(depth);
1577 }
1578 static ZEND_METHOD(ion_Writer_Writer, flush)
1579 {
1580         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1581         OBJ_CHECK(obj);
1582
1583         ZEND_PARSE_PARAMETERS_NONE();
1584
1585         SIZE flushed;
1586         ION_CHECK(ion_writer_flush(obj->writer, &flushed));
1587         if (obj->type == BUFFER_WRITER) {
1588                 smart_str_0(&obj->buffer.str);
1589         }
1590         RETURN_LONG(flushed);
1591 }
1592 static ZEND_METHOD(ion_Writer_Writer, finish)
1593 {
1594         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1595         OBJ_CHECK(obj);
1596
1597         ZEND_PARSE_PARAMETERS_NONE();
1598
1599         SIZE flushed;
1600         ION_CHECK(ion_writer_finish(obj->writer, &flushed));
1601         if (obj->type == BUFFER_WRITER) {
1602                 smart_str_0(&obj->buffer.str);
1603         }
1604         RETURN_LONG(flushed);
1605 }
1606 static ZEND_METHOD(ion_Writer_Writer, writeOne)
1607 {
1608 }
1609 static ZEND_METHOD(ion_Writer_Writer, writeAll)
1610 {
1611 }
1612 static ZEND_METHOD(ion_Writer_Buffer_Writer, __construct)
1613 {
1614         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1615         PTR_CHECK(obj);
1616
1617         zval *ref;
1618         ZEND_PARSE_PARAMETERS_START(1, 2)
1619                 Z_PARAM_ZVAL(ref)
1620                 Z_PARAM_OPTIONAL
1621                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1622         ZEND_PARSE_PARAMETERS_END();
1623
1624         obj->type = BUFFER_WRITER;
1625         ZVAL_COPY(&obj->buffer.val, ref);
1626         zval_dtor(Z_REFVAL_P(ref));
1627
1628         php_ion_writer_ctor(obj);
1629 }
1630 static ZEND_METHOD(ion_Writer_Buffer_Writer, getBuffer)
1631 {
1632         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1633         OBJ_CHECK(obj);
1634
1635         ZEND_PARSE_PARAMETERS_NONE();
1636
1637         RETVAL_STR(zend_string_dup(obj->buffer.str.s, 0));
1638 }
1639 static ZEND_METHOD(ion_Writer_Stream_Writer, __construct)
1640 {
1641         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1642         PTR_CHECK(obj);
1643
1644         zval *zstream;
1645         ZEND_PARSE_PARAMETERS_START(1, 2)
1646                 Z_PARAM_RESOURCE(zstream)
1647                 Z_PARAM_OPTIONAL
1648                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1649         ZEND_PARSE_PARAMETERS_END();
1650
1651         obj->type = STREAM_WRITER;
1652         php_stream_from_zval_no_verify(obj->stream.ptr, zstream);
1653
1654         php_ion_writer_ctor(obj);
1655 }
1656 static ZEND_METHOD(ion_Writer_Stream_Writer, getStream)
1657 {
1658         php_ion_writer *obj = php_ion_obj(writer, Z_OBJ_P(ZEND_THIS));
1659         OBJ_CHECK(obj);
1660
1661         ZEND_PARSE_PARAMETERS_NONE();
1662         PTR_CHECK(obj->stream.ptr);
1663
1664         GC_ADDREF(obj->stream.ptr->res);
1665         RETURN_RES(obj->stream.ptr->res);
1666 }
1667
1668 static ZEND_METHOD(ion_Serializer_PHP, __construct)
1669 {
1670         php_ion_serializer_php *obj = php_ion_obj(serializer_php, Z_OBJ_P(ZEND_THIS));
1671         PTR_CHECK(obj);
1672
1673         obj->serializer.call_magic = true;
1674
1675         ZEND_PARSE_PARAMETERS_START(0, 4)
1676                 Z_PARAM_OPTIONAL
1677                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Writer_Options)
1678                 Z_PARAM_BOOL(obj->serializer.multi_seq)
1679                 Z_PARAM_BOOL(obj->serializer.call_magic)
1680                 Z_PARAM_STR_OR_NULL(obj->serializer.call_custom)
1681         ZEND_PARSE_PARAMETERS_END();
1682
1683         php_ion_serializer_php_ctor(obj);
1684 }
1685 static ZEND_METHOD(ion_Serializer_PHP, __invoke)
1686 {
1687         zend_object *obj = Z_OBJ_P(ZEND_THIS);
1688
1689         zval *data;
1690         ZEND_PARSE_PARAMETERS_START(1, 1)
1691                 Z_PARAM_ZVAL(data)
1692         ZEND_PARSE_PARAMETERS_END();
1693
1694         if (obj->ce == ce_Serializer_PHP) {
1695                 // default, fast path
1696                 php_ion_serialize(&php_ion_obj(serializer_php, obj)->serializer, data, return_value);
1697         } else {
1698                 zend_call_method_with_1_params(obj, obj->ce, NULL /* TODO */, "serialize", return_value, data);
1699         }
1700 }
1701 static ZEND_FUNCTION(ion_serialize)
1702 {
1703         zval *data;
1704         zend_object *zo_ser = NULL;
1705         ZEND_PARSE_PARAMETERS_START(1, 2)
1706                 Z_PARAM_ZVAL(data)
1707                 Z_PARAM_OPTIONAL
1708                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(zo_ser, ce_Serializer)
1709         ZEND_PARSE_PARAMETERS_END();
1710
1711         if (!zo_ser || zo_ser->ce == ce_Serializer_PHP) {
1712                 // default, fast path
1713                 php_ion_serializer *ser = zo_ser ? &php_ion_obj(serializer_php, zo_ser)->serializer : NULL;
1714                 php_ion_serialize(ser, data, return_value);
1715         } else {
1716                 zend_call_method_with_1_params(zo_ser, NULL, NULL, "__invoke", return_value, data);
1717         }
1718 }
1719 static ZEND_METHOD(ion_Serializer_PHP, serialize)
1720 {
1721         //zend_object *obj = Z_OBJ_P(ZEND_THIS);
1722
1723         zval *data;
1724         ZEND_PARSE_PARAMETERS_START(1, 1)
1725                 Z_PARAM_ZVAL(data)
1726         ZEND_PARSE_PARAMETERS_END();
1727
1728         // TODO
1729         zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Not implemented");
1730 }
1731
1732 static ZEND_METHOD(ion_Unserializer_PHP, __construct)
1733 {
1734         php_ion_unserializer_php *obj = php_ion_obj(unserializer_php, Z_OBJ_P(ZEND_THIS));
1735         PTR_CHECK(obj);
1736
1737         obj->unserializer.call_magic = true;
1738
1739         ZEND_PARSE_PARAMETERS_START(0, 4)
1740                 Z_PARAM_OPTIONAL
1741                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(obj->opt, ce_Reader_Options)
1742                 Z_PARAM_BOOL(obj->unserializer.multi_seq)
1743                 Z_PARAM_BOOL(obj->unserializer.call_magic)
1744                 Z_PARAM_STR_OR_NULL(obj->unserializer.call_custom)
1745         ZEND_PARSE_PARAMETERS_END();
1746
1747         php_ion_unserializer_php_ctor(obj);
1748 }
1749 static ZEND_METHOD(ion_Unserializer_PHP, __invoke)
1750 {
1751         zend_object *obj = Z_OBJ_P(ZEND_THIS);
1752
1753         zval *data;
1754         ZEND_PARSE_PARAMETERS_START(1, 1)
1755                 Z_PARAM_ZVAL(data)
1756         ZEND_PARSE_PARAMETERS_END();
1757
1758         if (obj->ce == ce_Unserializer_PHP) {
1759                 php_ion_unserialize(&php_ion_obj(unserializer_php, obj)->unserializer, data, return_value);
1760         } else {
1761                 zend_call_method_with_1_params(obj, obj->ce, NULL /* TODO */, "unserialize", return_value, data);
1762         }
1763 }
1764 static ZEND_FUNCTION(ion_unserialize)
1765 {
1766         zval *data;
1767         zend_object *zo_ser = NULL;
1768         ZEND_PARSE_PARAMETERS_START(1, 2)
1769                 Z_PARAM_ZVAL(data)
1770                 Z_PARAM_OPTIONAL
1771                 Z_PARAM_OBJ_OF_CLASS_OR_NULL(zo_ser, ce_Unserializer)
1772         ZEND_PARSE_PARAMETERS_END();
1773
1774         if (!zo_ser || zo_ser->ce == ce_Unserializer_PHP) {
1775                 // default, fast path
1776                 php_ion_unserializer *ser = zo_ser ? &php_ion_obj(unserializer_php, zo_ser)->unserializer : NULL;
1777                 php_ion_unserialize(ser, data, return_value);
1778         } else {
1779                 zend_call_method_with_1_params(zo_ser, NULL, NULL, "__invoke", return_value, data);
1780         }
1781 }
1782 static ZEND_METHOD(ion_Unserializer_PHP, unserialize)
1783 {
1784         //zend_object *obj = Z_OBJ_P(ZEND_THIS);
1785
1786         zval *data;
1787         ZEND_PARSE_PARAMETERS_START(1, 1)
1788                 Z_PARAM_ZVAL(data)
1789         ZEND_PARSE_PARAMETERS_END();
1790
1791         // TODO
1792         zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Not implemented");
1793 }
1794
1795 PHP_RINIT_FUNCTION(ion)
1796 {
1797 #if defined(ZTS) && defined(COMPILE_DL_ION)
1798         ZEND_TSRMLS_CACHE_UPDATE();
1799 #endif
1800
1801         php_ion_globals_symbols_init();
1802         php_ion_globals_serializer_init();
1803         php_ion_globals_unserializer_init();
1804         return SUCCESS;
1805 }
1806
1807 PHP_RSHUTDOWN_FUNCTION(ion)
1808 {
1809         php_ion_globals_unserializer_dtor();
1810         php_ion_globals_serializer_dtor();
1811         php_ion_globals_symbols_dtor();
1812         return SUCCESS;
1813 }
1814
1815 #define ZEND_ARG_VARIADIC_OBJ_TYPE_MASK(pass_by_ref, name, classname, type_mask, default_value) \
1816         { #name, ZEND_TYPE_INIT_CLASS_CONST_MASK(#classname, type_mask | _ZEND_ARG_INFO_FLAGS(pass_by_ref, 1, 0)), default_value },
1817 #include "ion_arginfo.h"
1818
1819 PHP_MINIT_FUNCTION(ion)
1820 {
1821         // true globals
1822         if (SUCCESS != g_sym_init())  {
1823                 return FAILURE;
1824         }
1825
1826         // Catalog
1827         php_ion_register(catalog, Catalog, zend_ce_countable);
1828
1829         // Decimal
1830         php_ion_register(decimal, Decimal);
1831         php_ion_register(decimal_ctx, Decimal_Context);
1832         ce_Decimal_Context_Rounding = register_class_ion_Decimal_Context_Rounding();
1833
1834         // LOB
1835         ce_LOB = register_class_ion_LOB();
1836
1837         // Reader
1838         ce_Reader = register_class_ion_Reader(spl_ce_RecursiveIterator);
1839         php_ion_register(reader_options, Reader_Options);
1840         php_ion_register(reader, Reader_Reader, ce_Reader);
1841         ce_Reader_Buffer = register_class_ion_Reader_Buffer(ce_Reader);
1842         ce_Reader_Buffer_Reader = register_class_ion_Reader_Buffer_Reader(ce_Reader_Reader, ce_Reader_Buffer);
1843         ce_Reader_Stream = register_class_ion_Reader_Stream(ce_Reader);
1844         ce_Reader_Stream_Reader = register_class_ion_Reader_Stream_Reader(ce_Reader_Reader, ce_Reader_Stream);
1845
1846         // Serializer
1847         ce_Serializer = register_class_ion_Serializer();
1848         php_ion_register(serializer_php, Serializer_PHP, ce_Serializer);
1849
1850         // Symbol
1851         php_ion_register(symbol, Symbol);
1852         oh_Symbol.compare = php_ion_symbol_zval_compare;
1853         php_ion_register(symbol_iloc, Symbol_ImportLocation);
1854         php_ion_register(symbol_table, Symbol_Table);
1855         ce_Symbol_Table->create_object = NULL;
1856         ce_Symbol_Table_Local = register_class_ion_Symbol_Table_Local(ce_Symbol_Table);
1857         ce_Symbol_Table_Local->create_object = create_ion_Symbol_Table;
1858         ce_Symbol_Table_Shared = register_class_ion_Symbol_Table_Shared(ce_Symbol_Table);
1859         ce_Symbol_Table_Shared->create_object = create_ion_Symbol_Table;
1860         ce_Symbol_Enum = register_class_ion_Symbol_Enum();
1861         ce_Symbol_Table_System = register_class_ion_Symbol_Table_System(ce_Symbol_Enum);
1862         ce_Symbol_Table_PHP = register_class_ion_Symbol_Table_PHP(ce_Symbol_Enum);
1863
1864         // Timestamp
1865         ce_Timestamp = register_class_ion_Timestamp(php_date_get_date_ce());
1866         ce_Timestamp_Precision = register_class_ion_Timestamp_Precision();
1867
1868         // Type
1869         php_ion_register(type, Type);
1870
1871         // Writer
1872         ce_Writer = register_class_ion_Writer();
1873         php_ion_register(writer_options, Writer_Options);
1874         php_ion_register(writer, Writer_Writer, ce_Writer);
1875         ce_Writer_Buffer = register_class_ion_Writer_Buffer(ce_Writer);
1876         ce_Writer_Buffer_Writer = register_class_ion_Writer_Buffer_Writer(ce_Writer_Writer, ce_Writer_Buffer);
1877         ce_Writer_Stream = register_class_ion_Writer_Stream(ce_Writer);
1878         ce_Writer_Stream_Writer = register_class_ion_Writer_Stream_Writer(ce_Writer_Writer, ce_Writer_Stream);
1879
1880         // Unserializer
1881         ce_Unserializer = register_class_ion_Unserializer();
1882         php_ion_register(unserializer_php, Unserializer_PHP, ce_Unserializer);
1883
1884         return SUCCESS;
1885 }
1886
1887 PHP_MSHUTDOWN_FUNCTION(ion)
1888 {
1889         if (g_sym_tab_php) {
1890                 ion_symbol_table_close(g_sym_tab_php);
1891         }
1892         zend_hash_destroy(&g_sym_hash);
1893         return SUCCESS;
1894 }
1895
1896 PHP_MINFO_FUNCTION(ion)
1897 {
1898         php_info_print_table_start();
1899         php_info_print_table_header(2, "ion support", "enabled");
1900         php_info_print_table_end();
1901 }
1902
1903 PHP_GINIT_FUNCTION(ion)
1904 {
1905         memset(ion_globals, 0, sizeof(*ion_globals));
1906
1907         php_ion_decimal_ctx_init_max(&ion_globals->decimal.ctx, DEC_ROUND_HALF_EVEN);
1908         php_ion_decimal_from_zend_long(&ion_globals->decimal.zend_max, &ion_globals->decimal.ctx, ZEND_LONG_MAX);
1909         php_ion_decimal_from_zend_long(&ion_globals->decimal.zend_min, &ion_globals->decimal.ctx, ZEND_LONG_MIN);
1910 }
1911
1912 PHP_GSHUTDOWN_FUNCTION(ion)
1913 {
1914 }
1915
1916 static zend_module_dep ion_module_deps[] = {
1917         ZEND_MOD_REQUIRED("date")
1918         ZEND_MOD_REQUIRED("spl")
1919         ZEND_MOD_END
1920 };
1921
1922 zend_module_entry ion_module_entry = {
1923         STANDARD_MODULE_HEADER_EX,
1924         NULL,
1925         ion_module_deps,
1926         "ion",                                  /* Extension name */
1927         ext_functions,                  /* zend_function_entry */
1928         PHP_MINIT(ion),                 /* PHP_MINIT - Module initialization */
1929         PHP_MSHUTDOWN(ion),             /* PHP_MSHUTDOWN - Module shutdown */
1930         PHP_RINIT(ion),                 /* PHP_RINIT - Request initialization */
1931         PHP_RSHUTDOWN(ion),             /* PHP_RSHUTDOWN - Request shutdown */
1932         PHP_MINFO(ion),                 /* PHP_MINFO - Module info */
1933         PHP_ION_VERSION,                /* Version */
1934         ZEND_MODULE_GLOBALS(ion),
1935         PHP_GINIT(ion),                 /* PHP_GINIT */
1936         PHP_GSHUTDOWN(ion),             /* PHP_GSHUTDOWN */
1937         NULL,
1938         STANDARD_MODULE_PROPERTIES_EX
1939 };
1940
1941 #ifdef COMPILE_DL_ION
1942 # ifdef ZTS
1943 ZEND_TSRMLS_CACHE_DEFINE()
1944 # endif
1945 ZEND_GET_MODULE(ion)
1946 #endif