2 +--------------------------------------------------------------------+
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 +--------------------------------------------------------------------+
14 #include "ext/standard/php_var.h"
15 #include "ext/date/php_date.h"
20 # define LOCAL static inline
23 #define DECNUMDIGITS 34 /* DECQUAD_Pmax */
26 #define PHP_ION_SYMBOL_TABLE_VERSION 1
27 #define PHP_ION_SYMBOL(c, s) { \
30 { sizeof(s)-1, (BYTE *) s }, \
34 { sizeof(c)-1, (BYTE *) c } \
37 typedef struct php_ion_global_symbol
{
40 } php_ion_global_symbol
;
42 static php_ion_global_symbol g_sym_tab_php_sym
[] = {
43 #define PHP_ION_SYMBOL_PHP (g_sym_tab_php_sym[0]).s
44 PHP_ION_SYMBOL("PHP", "PHP")
45 #define PHP_ION_SYMBOL_REFERENCE (g_sym_tab_php_sym[1]).s
46 PHP_ION_SYMBOL("Reference", "R")
47 #define PHP_ION_SYMBOL_BACKREF (g_sym_tab_php_sym[2]).s
48 PHP_ION_SYMBOL("Backref", "r")
49 #define PHP_ION_SYMBOL_PROPERTY (g_sym_tab_php_sym[3]).s
50 PHP_ION_SYMBOL("Property", "p")
51 #define PHP_ION_SYMBOL_CLASS_OBJECT (g_sym_tab_php_sym[4]).s
52 PHP_ION_SYMBOL("ClassObject", "c")
53 #define PHP_ION_SYMBOL_CUSTOM_OBJECT (g_sym_tab_php_sym[5]).s
54 PHP_ION_SYMBOL("CustomObject", "C")
55 #define PHP_ION_SYMBOL_OBJECT (g_sym_tab_php_sym[6]).s
56 PHP_ION_SYMBOL("Object", "o")
57 #define PHP_ION_SYMBOL_MAGIC_OBJECT (g_sym_tab_php_sym[7]).s
58 PHP_ION_SYMBOL("MagicObject", "O")
59 #define PHP_ION_SYMBOL_SERIALIZEABLE (g_sym_tab_php_sym[8]).s
60 PHP_ION_SYMBOL("Serializable", "S")
61 #define PHP_ION_SYMBOL_ENUM (g_sym_tab_php_sym[9]).s
62 PHP_ION_SYMBOL("Enum", "E")
67 static ION_SYMBOL_TABLE
*g_sym_tab_php
;
69 /* [SID => STRING, STRING => SID] */
70 static HashTable g_sym_hash
;
71 /* [enum_case_name => SID] */
72 static HashTable g_sym_map
;
74 #define ION_SYS_SYMBOL_SYMBOL_TABLE \
75 ION_SYS_SYMBOL_ION_SYMBOL_TABLE
76 #define g_sym_add(enum_name, c_name) do { \
77 g_sym_hash_add(ION_SYS_SID_ ## c_name, ION_SYS_SYMBOL_ ## c_name, ION_SYS_STRLEN_ ## c_name); \
78 g_sym_map_add(ION_SYS_SID_ ## c_name, enum_name, sizeof(enum_name)-1); \
81 LOCAL
void g_sym_hash_add(int sid
, const char *str
, size_t len
)
85 ZVAL_STR(&zs
, zend_string_init_interned(str
, len
,1));
86 zend_hash_add(&g_sym_hash
, Z_STR(zs
), &zl
);
87 zend_hash_index_add(&g_sym_hash
, sid
, &zs
);
90 LOCAL
void g_sym_map_add(int sid
, const char *str
, size_t len
)
94 zend_hash_str_add(&g_sym_map
, str
, len
, &zv
);
97 LOCAL
int g_sym_init(void)
99 zend_hash_init(&g_sym_hash
, 0, NULL
, NULL
, 1);
100 zend_hash_init(&g_sym_map
, 0, NULL
, NULL
, 1);
102 g_sym_hash_add(0, ZEND_STRL(""));
103 g_sym_map_add(0, ZEND_STRL(""));
104 g_sym_add("Ion", ION
);
105 g_sym_add("Ivm_1_0", IVM
);
106 g_sym_add("IonSymbolTable", SYMBOL_TABLE
);
107 g_sym_add("Name", NAME
);
108 g_sym_add("Version", VERSION
);
109 g_sym_add("Imports", IMPORTS
);
110 g_sym_add("Symbols", SYMBOLS
);
111 g_sym_add("MaxId", MAX_ID
);
112 g_sym_add("SharedSymbolTable", SHARED_SYMBOL_TABLE
);
114 int sys_max_id
= ION_SYS_SID_SHARED_SYMBOL_TABLE
;
116 if (IERR_OK
!= ion_symbol_table_open_with_type(&g_sym_tab_php
, NULL
, ist_SHARED
)) {
119 php_ion_global_symbol
*ptr
= g_sym_tab_php_sym
;
120 ion_symbol_table_set_version(g_sym_tab_php
, PHP_ION_SYMBOL_TABLE_VERSION
);
121 ion_symbol_table_set_name(g_sym_tab_php
, &ptr
->s
.value
);
122 while (ptr
->e
.value
) {
123 ion_symbol_table_add_symbol(g_sym_tab_php
, &ptr
->s
.value
, &ptr
->s
.sid
);
124 g_sym_hash_add(sys_max_id
+ ptr
->s
.sid
, (const char *) ptr
->s
.value
.value
, ptr
->s
.value
.length
);
125 g_sym_map_add(sys_max_id
+ ptr
->s
.sid
, (const char *) ptr
->e
.value
, ptr
->e
.length
);
128 ion_symbol_table_lock(g_sym_tab_php
);
133 zend_string
*Year
, *Month
, *Day
, *Min
, *Sec
, *Frac
, *MinTZ
, *SecTZ
, *FracTZ
;
136 static void g_intern_str_init()
138 #define NEW_INTERN_STR(s) \
139 g_intern_str.s = zend_string_init_interned(#s, sizeof(#s)-1, 1)
140 NEW_INTERN_STR(Year
);
141 NEW_INTERN_STR(Month
);
145 NEW_INTERN_STR(Frac
);
146 NEW_INTERN_STR(MinTZ
);
147 NEW_INTERN_STR(SecTZ
);
148 NEW_INTERN_STR(FracTZ
);
149 #undef NEW_INTERN_STR
152 typedef struct php_ion_serializer
{
154 ION_WRITER_OPTIONS
*options
;
157 zend_string
*call_custom
;
158 zend_bool call_magic
;
164 } php_ion_serializer
;
166 typedef struct php_ion_annotations
{
167 uint8_t shared_symtab
:1;
170 uint8_t object_prop
:1;
172 zend_string
*object_class
;
173 zend_string
*property_class
;
174 } php_ion_annotations
;
176 typedef struct php_ion_unserializer
{
178 ION_READER_OPTIONS
*options
;
181 zend_string
*call_custom
;
182 zend_bool call_magic
;
190 php_ion_annotations annotations
;
191 } php_ion_unserializer
;
193 ZEND_BEGIN_MODULE_GLOBALS(ion
)
197 ION_DECIMAL zend_max
;
198 ION_DECIMAL zend_min
;
205 php_ion_serializer serializer
;
206 php_ion_unserializer unserializer
;
209 HashTable serializer
[2];
210 HashTable unserializer
[3];
213 ZEND_END_MODULE_GLOBALS(ion
);
216 # define php_ion_globals (*((zend_ion_globals *) (*((void ***) tsrm_get_ls_cache()))[TSRM_UNSHUFFLE_RSRC_ID(ion_globals_id)]))
218 # define php_ion_globals ion_globals
221 ZEND_DECLARE_MODULE_GLOBALS(ion
);
223 static zend_class_entry
227 *ce_Decimal_Context_Rounding
,
234 *ce_Reader_Buffer_Reader
,
235 *ce_Reader_Stream_Reader
,
239 *ce_Symbol_ImportLocation
,
242 *ce_Symbol_Table_Local
,
243 *ce_Symbol_Table_PHP
,
244 *ce_Symbol_Table_Shared
,
245 *ce_Symbol_Table_System
,
247 *ce_Timestamp_Format
,
248 *ce_Timestamp_Precision
,
251 *ce_Unserializer_PHP
,
255 *ce_Writer_Buffer_Writer
,
257 *ce_Writer_Stream_Writer
,
261 LOCAL
void php_ion_globals_symbols_init(void)
263 zend_hash_init(&php_ion_globals
.symbol
.cache
, 0, NULL
, ZVAL_PTR_DTOR
, 0);
266 LOCAL
void php_ion_globals_symbols_dtor(void)
268 zend_hash_destroy(&php_ion_globals
.symbol
.cache
);
271 LOCAL
void php_ion_globals_serializer_init(void)
273 php_ion_serializer
*s
= &php_ion_globals
.serializer
;
274 HashTable
*h
= php_ion_globals
._ht
.serializer
;
276 zend_hash_init(s
->tmp
= &h
[0], 0, NULL
, ZVAL_PTR_DTOR
, 0);
277 zend_hash_init(s
->ids
= &h
[1], 0, NULL
, NULL
, 0);
280 LOCAL
uint32_t php_ion_globals_serializer_step(void)
282 php_ion_serializer
*s
= &php_ion_globals
.serializer
;
285 if (!(level
= s
->level
++)) {
286 zend_hash_clean(s
->ids
);
287 zend_hash_clean(s
->tmp
);
292 LOCAL
uint32_t php_ion_globals_serializer_exit(void)
294 php_ion_serializer
*s
= &php_ion_globals
.serializer
;
296 ZEND_ASSERT(s
->level
);
298 zend_hash_clean(s
->ids
);
299 zend_hash_clean(s
->tmp
);
304 LOCAL
void php_ion_globals_serializer_dtor(void)
306 php_ion_serializer
*s
= &php_ion_globals
.serializer
;
308 zend_hash_destroy(s
->tmp
);
309 zend_hash_destroy(s
->ids
);
312 void ZVAL_ADDREF(zval
*zv
)
315 Z_TRY_ADDREF_P(Z_REFVAL_P(zv
));
320 LOCAL
void php_ion_globals_unserializer_init(void)
322 php_ion_unserializer
*s
= &php_ion_globals
.unserializer
;
323 HashTable
*h
= php_ion_globals
._ht
.unserializer
;
325 zend_hash_init(s
->tmp
= &h
[0], 0, NULL
, ZVAL_PTR_DTOR
, 0);
326 zend_hash_init(s
->ids
= &h
[1], 0, NULL
, NULL
, 0);
327 zend_hash_init(s
->addref
= &h
[2], 0, NULL
, ZVAL_ADDREF
, 0);
330 LOCAL
void php_ion_globals_unserializer_step(void)
332 php_ion_unserializer
*s
= &php_ion_globals
.unserializer
;
335 zend_hash_clean(s
->addref
);
336 zend_hash_clean(s
->ids
);
337 zend_hash_clean(s
->tmp
);
341 LOCAL
void php_ion_globals_unserializer_exit(void)
343 php_ion_unserializer
*s
= &php_ion_globals
.unserializer
;
345 ZEND_ASSERT(s
->level
);
347 zend_hash_clean(s
->addref
);
348 zend_hash_clean(s
->ids
);
349 zend_hash_clean(s
->tmp
);
353 LOCAL
void php_ion_globals_unserializer_dtor(void)
355 php_ion_unserializer
*s
= &php_ion_globals
.unserializer
;
357 zend_hash_destroy(s
->addref
);
358 zend_hash_destroy(s
->ids
);
359 zend_hash_destroy(s
->tmp
);
362 #define php_ion_obj(type, zo) \
363 ((php_ion_ ##type *) php_ion_obj_ex(zo, XtOffsetOf(php_ion_ ## type, std)))
364 LOCAL
void *php_ion_obj_ex(void *obj
, ptrdiff_t offset
) {
366 return ((char *) obj
) - offset
;
371 #define php_ion_decl(type, cname) \
372 static zend_object_handlers oh_ ## cname; \
373 LOCAL zend_object *create_ion_ ## cname(zend_class_entry *ce) \
375 if (!ce) ce = ce_ ## cname; \
376 php_ion_ ## type *o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce)); \
377 zend_object_std_init(&o->std, ce); \
378 object_properties_init(&o->std, ce); \
379 o->std.handlers = &oh_ ## cname; \
382 LOCAL void free_ion_ ## cname(zend_object *std) \
384 php_ion_ ## type *obj = php_ion_obj(type, std); \
385 php_ion_ ## type ## _dtor(obj); \
386 zend_object_std_dtor(std); \
388 LOCAL zend_object *clone_ion_ ## cname(zend_object *std) \
390 php_ion_ ## type *old_obj = php_ion_obj(type, std), \
391 *new_obj = php_ion_obj(type, create_ion_ ## cname(std->ce)); \
392 php_ion_ ## type ## _copy(new_obj, old_obj); \
394 return &new_obj->std; \
396 #define php_ion_register(type, cname, ...) do { \
397 ce_ ## cname = register_class_ion_ ## cname(__VA_ARGS__); \
398 ce_ ## cname ->create_object = create_ion_ ## cname; \
399 memcpy(&oh_ ## cname, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); \
400 oh_ ## cname .offset = offsetof(php_ion_ ## type, std); \
401 oh_ ## cname .free_obj = free_ion_ ## cname; \
402 oh_ ## cname .clone_obj = clone_ion_ ## cname; \
405 #define ION_CHECK_RETURN(r, err, ...) do { \
408 zend_throw_exception_ex(spl_ce_RuntimeException, __err, "%s: %s", ion_error_to_str(__err), #err); \
414 #define ION_CHECK(err, ...) \
415 ION_CHECK_RETURN(, err, __VA_ARGS__)
417 #define ION_CATCH(...) do { \
418 if (EG(exception)) { \
424 #define PTR_CHECK_RETURN(ret, ptr, ...) do { \
426 zend_throw_error(NULL, "Uninitialized object"); \
431 #define PTR_CHECK(ptr, ...) PTR_CHECK_RETURN(, ptr, __VA_ARGS__)
433 #define OBJ_CHECK_RETURN(ret, obj, ...) do { \
434 PTR_CHECK_RETURN(ret, obj, __VA_ARGS__); \
435 PTR_CHECK_RETURN(ret, *((void **)obj), __VA_ARGS__); \
437 #define OBJ_CHECK(obj, ...) OBJ_CHECK_RETURN(, obj, __VA_ARGS__)
439 LOCAL ION_STRING
*ion_string_from_zend(ION_STRING
*is
, const zend_string
*zs
)
441 is
->length
= zs
? (SIZE
) zs
->len
: 0;
442 is
->value
= (BYTE
*) (zs
? zs
->val
: NULL
);
446 LOCAL zend_string
*zend_string_from_ion(const ION_STRING
*s
)
448 return zend_string_init((const char *) s
->value
, s
->length
, 0);
451 LOCAL
void update_property_obj(zend_object
*obj
, const char *n
, size_t l
, zend_object
*p
)
455 zend_update_property(obj
->ce
, obj
, n
, l
, &zobj
);
458 LOCAL zend_object
*get_property_obj(zend_object
*obj
, const char *n
, size_t l
, int type
)
460 zval tmp
, *zv
= zend_read_property(obj
->ce
, obj
, n
, l
, 0, &tmp
);
461 if (zv
&& type
& Z_TYPE_P(zv
)) {
467 #define RETURN_IONTYPE(typ) do { \
468 zend_object *__zo = php_ion_type_fetch(typ); \
469 if (UNEXPECTED(!__zo)) { \
472 RETURN_OBJ_COPY(__zo); \
475 LOCAL zend_object
*php_ion_type_fetch(ION_TYPE typ
)
477 zend_long index
= ION_TYPE_INT(typ
);
478 zval
*ztype
= zend_hash_index_find(ce_Type
->backed_enum_table
, index
);
480 if (UNEXPECTED(!ztype
|| Z_TYPE_P(ztype
) != IS_STRING
)) {
481 zend_value_error(ZEND_LONG_FMT
" is not a valid backing value for enum \"%s\"", index
, ZSTR_VAL(ce_Type
->name
));
484 return zend_enum_get_case(ce_Type
, Z_STR_P(ztype
));
487 LOCAL ION_TYPE
ion_type_from_enum(zend_object
*zo
)
489 return (ION_TYPE
) Z_LVAL_P(zend_enum_fetch_case_value(zo
));
492 typedef struct php_ion_symbol_iloc
{
493 ION_SYMBOL_IMPORT_LOCATION loc
;
496 } php_ion_symbol_iloc
;
498 LOCAL
void php_ion_symbol_iloc_ctor(php_ion_symbol_iloc
*obj
)
500 zend_update_property_long(obj
->std
.ce
, &obj
->std
, ZEND_STRL("location"), obj
->loc
.location
);
501 zend_update_property_str(obj
->std
.ce
, &obj
->std
, ZEND_STRL("name"), obj
->name
);
502 ion_string_from_zend(&obj
->loc
.name
, obj
->name
);
505 LOCAL
void php_ion_symbol_iloc_dtor(php_ion_symbol_iloc
*obj
)
507 zend_string_release(obj
->name
);
510 LOCAL
void php_ion_symbol_iloc_copy(php_ion_symbol_iloc
*new_obj
, php_ion_symbol_iloc
*old_obj
)
512 zend_objects_clone_members(&new_obj
->std
, &old_obj
->std
);
513 new_obj
->name
= zend_string_copy(old_obj
->name
);
514 ion_string_from_zend(&new_obj
->loc
.name
, new_obj
->name
);
515 new_obj
->loc
.location
= old_obj
->loc
.location
;
518 php_ion_decl(symbol_iloc
, Symbol_ImportLocation
);
520 typedef struct php_ion_symbol
{
523 zend_object
*iloc
, std
;
526 LOCAL
int php_ion_symbol_zval_compare(zval
*zv1
, zval
*zv2
) {
527 zend_string
*zs1
= zval_get_string(zv1
);
528 zend_string
*zs2
= zval_get_string(zv2
);
535 if (zs1
->len
> zs2
->len
) {
537 } else if (zs2
->len
> zs1
->len
) {
540 result
= memcmp(zs1
->val
, zs2
->val
, zs1
->len
);
542 zend_string_release(zs1
);
543 zend_string_release(zs2
);
547 LOCAL
void php_ion_symbol_ctor(php_ion_symbol
*obj
)
549 zend_update_property_long(obj
->std
.ce
, &obj
->std
, ZEND_STRL("sid"),
552 zend_update_property_str(obj
->std
.ce
, &obj
->std
, ZEND_STRL("value"), obj
->value
);
554 zend_update_property_null(obj
->std
.ce
, &obj
->std
, ZEND_STRL("value"));
556 ion_string_from_zend(&obj
->sym
.value
, obj
->value
);
558 update_property_obj(&obj
->std
, ZEND_STRL("importLocation"), obj
->iloc
);
559 obj
->sym
.import_location
= php_ion_obj(symbol_iloc
, obj
->iloc
)->loc
;
561 zend_update_property_null(obj
->std
.ce
, &obj
->std
, ZEND_STRL("importLocation"));
565 LOCAL
void php_ion_symbol_dtor(php_ion_symbol
*obj
)
568 zend_string_release(obj
->value
);
572 LOCAL
void php_ion_symbol_copy(php_ion_symbol
*new_obj
, php_ion_symbol
*old_obj
)
574 zend_objects_clone_members(&new_obj
->std
, &old_obj
->std
);
575 new_obj
->sym
= old_obj
->sym
;
576 if (old_obj
->value
) {
577 new_obj
->value
= zend_string_copy(old_obj
->value
);
578 ion_string_from_zend(&new_obj
->sym
.value
, new_obj
->value
);
581 if ((new_obj
->iloc
= old_obj
->iloc
)) {
582 new_obj
->sym
.import_location
= php_ion_obj(symbol_iloc
, new_obj
->iloc
)->loc
;
586 LOCAL
void php_ion_symbol_zval(ION_SYMBOL
*sym_ptr
, zval
*return_value
)
588 object_init_ex(return_value
, ce_Symbol
);
589 php_ion_symbol
*sym
= php_ion_obj(symbol
, Z_OBJ_P(return_value
));
591 sym
->sym
.sid
= sym_ptr
->sid
;
592 sym
->value
= zend_string_from_ion(&sym_ptr
->value
);
593 if (!ION_SYMBOL_IMPORT_LOCATION_IS_NULL(sym_ptr
)) {
595 object_init_ex(&ziloc
, ce_Symbol_ImportLocation
);
596 sym
->iloc
= Z_OBJ(ziloc
);
598 php_ion_symbol_iloc
*iloc
= php_ion_obj(symbol_iloc
, sym
->iloc
);
599 iloc
->loc
.location
= sym_ptr
->import_location
.location
;
600 iloc
->name
= zend_string_from_ion(&sym_ptr
->import_location
.name
);
602 php_ion_symbol_iloc_ctor(iloc
);
605 php_ion_symbol_ctor(sym
);
607 if (!ION_SYMBOL_IMPORT_LOCATION_IS_NULL(sym_ptr
)) {
608 GC_DELREF(sym
->iloc
);
612 LOCAL zval
*php_ion_global_symbol_fetch_by_enum(zend_string
*name
)
614 zval
*zgs
= zend_hash_find(&php_ion_globals
.symbol
.cache
, name
);
616 zval
*zid
= zend_hash_find(&g_sym_map
, name
);
618 zval
*zss
= zend_hash_index_find(&g_sym_hash
, Z_LVAL_P(zid
));
621 object_init_ex(&zsym
, ce_Symbol
);
622 php_ion_symbol
*sym
= php_ion_obj(symbol
, Z_OBJ(zsym
));
623 sym
->sym
.sid
= Z_LVAL_P(zid
);
624 sym
->value
= zval_get_string(zss
);
625 php_ion_symbol_ctor(sym
);
626 zgs
= zend_hash_add(&php_ion_globals
.symbol
.cache
, name
, &zsym
);
633 php_ion_decl(symbol
, Symbol
);
635 typedef struct php_ion_symbol_table
{
636 ION_SYMBOL_TABLE
*tab
;
637 int (*dtor
)(ION_SYMBOL_TABLE
*);
639 } php_ion_symbol_table
;
641 LOCAL
void php_ion_symbol_table_ctor(php_ion_symbol_table
*obj
)
646 if (IERR_OK
== ion_symbol_table_get_name(obj
->tab
, &is
)) {
647 zend_update_property_stringl(obj
->std
.ce
, &obj
->std
, ZEND_STRL("name"), (char *) is
.value
, is
.length
);
650 if (IERR_OK
== ion_symbol_table_get_version(obj
->tab
, &iv
)) {
651 zend_update_property_long(obj
->std
.ce
, &obj
->std
, ZEND_STRL("version"), iv
);
655 LOCAL
void php_ion_symbol_table_dtor(php_ion_symbol_table
*obj
)
665 LOCAL
void php_ion_symbol_table_copy(php_ion_symbol_table
*new_obj
, php_ion_symbol_table
*old_obj
)
667 // do not clone cache members
668 // zend_objects_clone_members(...)
669 if ((new_obj
->dtor
= old_obj
->dtor
)) {
670 ION_CHECK(ion_symbol_table_clone_with_owner(old_obj
->tab
, &new_obj
->tab
, NULL
));
672 new_obj
->tab
= old_obj
->tab
;
674 // update non-cache members
675 php_ion_symbol_table_ctor(new_obj
);
678 LOCAL
void php_ion_symbol_table_import(php_ion_symbol_table
*obj
, php_ion_symbol_table
*import
)
684 zval
*zimports
= zend_read_property(obj
->std
.ce
, &obj
->std
, ZEND_STRL("imports"), 0, &tmp
);
686 zend_ulong idx
= (uintptr_t) &import
->std
.gc
;
687 if (!zend_hash_index_exists(Z_ARRVAL_P(zimports
), idx
)) {
688 ION_CHECK(ion_symbol_table_import_symbol_table(obj
->tab
, import
->tab
));
690 SEPARATE_ARRAY(zimports
);
691 GC_ADDREF(&import
->std
);
692 add_index_object(zimports
, idx
, &import
->std
);
693 zend_update_property(obj
->std
.ce
, &obj
->std
, ZEND_STRL("imports"), zimports
);
698 LOCAL
void php_ion_symbol_table_symbol_zval(php_ion_symbol_table
*obj
, ION_SYMBOL
*sym
, zval
*return_value
)
701 zval
*zsyms
= zend_read_property(obj
->std
.ce
, &obj
->std
, ZEND_STRL("symbols"), 0, &tmp
);
703 zval
*zsym
= zend_hash_index_find(Z_ARRVAL_P(zsyms
), sym
->sid
);
709 php_ion_symbol_zval(sym
, return_value
);
712 SEPARATE_ARRAY(zsyms
);
713 ZVAL_ADDREF(return_value
);
714 add_index_zval(zsyms
, sym
->sid
, return_value
);
718 php_ion_decl(symbol_table
, Symbol_Table
);
720 typedef struct php_ion_decimal_ctx
{
723 } php_ion_decimal_ctx
;
725 #define php_ion_decimal_ctx_init_max(c, rounding) \
726 php_ion_decimal_ctx_init((c), DEC_MAX_DIGITS, DEC_MAX_EMAX, DEC_MIN_EMIN, (rounding), false)
727 LOCAL
void php_ion_decimal_ctx_init(decContext
*ctx
,
728 int digits
, int emax
, int emin
, enum rounding round
, zend_bool clamp
)
730 memset(ctx
, 0, sizeof(*ctx
));
731 ctx
->digits
= digits
;
738 LOCAL
void php_ion_decimal_ctx_ctor(php_ion_decimal_ctx
*obj
, zend_object
*o_round
)
740 if (!obj
->ctx
.digits
) {
741 php_ion_decimal_ctx_init_max(&obj
->ctx
, DEC_ROUND_HALF_EVEN
);
744 update_property_obj(&obj
->std
, ZEND_STRL("round"), o_round
);
746 zend_update_property_long(obj
->std
.ce
, &obj
->std
, ZEND_STRL("round"), obj
->ctx
.round
);
748 zend_update_property_long(obj
->std
.ce
, &obj
->std
, ZEND_STRL("digits"), obj
->ctx
.digits
);
749 zend_update_property_long(obj
->std
.ce
, &obj
->std
, ZEND_STRL("eMax"), obj
->ctx
.emax
);
750 zend_update_property_long(obj
->std
.ce
, &obj
->std
, ZEND_STRL("eMin"), obj
->ctx
.emin
);
751 zend_update_property_bool(obj
->std
.ce
, &obj
->std
, ZEND_STRL("clamp"), obj
->ctx
.clamp
);
754 LOCAL
void php_ion_decimal_ctx_dtor(php_ion_decimal_ctx
*obj
)
758 LOCAL
void php_ion_decimal_ctx_copy(php_ion_decimal_ctx
*new_obj
, php_ion_decimal_ctx
*old_obj
)
760 zend_objects_clone_members(&new_obj
->std
, &old_obj
->std
);
761 new_obj
->ctx
= old_obj
->ctx
;
764 php_ion_decl(decimal_ctx
, Decimal_Context
);
766 typedef struct php_ion_decimal
{
768 zend_object
*ctx
, std
;
771 LOCAL
void php_ion_decimal_from_zend_long(ION_DECIMAL
*dec
, decContext
*ctx
, zend_long num
)
773 if (num
<= INT32_MAX
&& num
>= INT32_MIN
) {
774 ION_CHECK(ion_decimal_from_int32(dec
, num
));
775 } else if (num
> 0 && num
<= UINT32_MAX
) {
776 ION_CHECK(ion_decimal_from_uint32(dec
, num
));
779 ION_CHECK(ion_int_alloc(NULL
, &iint
));
780 ION_CHECK(ion_int_from_long(iint
, num
),
782 /* WATCH OUT: BS API */
783 dec
->type
= ION_DECIMAL_TYPE_QUAD
;
784 ION_CHECK(ion_decimal_from_ion_int(dec
, ctx
, iint
),
790 LOCAL zend_string
*php_ion_decimal_to_string(ION_DECIMAL
*dec
)
792 zend_string
*zstr
= zend_string_alloc(ION_DECIMAL_STRLEN(dec
), 0);
793 (void) ion_decimal_to_string(dec
, zstr
->val
);
794 return zend_string_truncate(zstr
, strlen(zstr
->val
), 0);
797 LOCAL
void php_ion_decimal_to_zend_long(ION_DECIMAL
*dec
, decContext
*ctx
, zend_long
*l
)
800 ION_CHECK(ion_int_alloc(NULL
, &ii
));
801 ION_CHECK(ion_decimal_to_ion_int(dec
, ctx
, ii
), ion_int_free(ii
));
803 ION_CHECK(ion_int_to_int64(ii
, &i64
), ion_int_free(ii
));
808 LOCAL
bool php_ion_decimal_fits_zend_long(php_ion_decimal
*obj
)
812 if (!ion_decimal_is_integer(&obj
->dec
)) {
817 ion_decimal_compare(&obj
->dec
, &php_ion_globals
.decimal
.zend_max
, &php_ion_globals
.decimal
.ctx
, &result
);
822 ion_decimal_compare(&obj
->dec
, &php_ion_globals
.decimal
.zend_min
, &php_ion_globals
.decimal
.ctx
, &result
);
829 LOCAL
void php_ion_decimal_ctor(php_ion_decimal
*obj
)
833 object_init_ex(&zdc
, ce_Decimal_Context
);
834 obj
->ctx
= Z_OBJ(zdc
);
835 php_ion_decimal_ctx_ctor(php_ion_obj(decimal_ctx
, obj
->ctx
), NULL
);
838 update_property_obj(&obj
->std
, ZEND_STRL("context"), obj
->ctx
);
840 if (php_ion_decimal_fits_zend_long(obj
)) {
842 php_ion_decimal_to_zend_long(&obj
->dec
, &php_ion_obj(decimal_ctx
, obj
->ctx
)->ctx
, &l
);
843 zend_update_property_long(obj
->std
.ce
, &obj
->std
, ZEND_STRL("number"), l
);
845 zend_string
*zstr
= php_ion_decimal_to_string(&obj
->dec
);
846 zend_update_property_str(obj
->std
.ce
, &obj
->std
, ZEND_STRL("number"), zstr
);
847 zend_string_release(zstr
);
851 LOCAL
void php_ion_decimal_dtor(php_ion_decimal
*obj
)
853 ion_decimal_free(&obj
->dec
);
856 LOCAL
void php_ion_decimal_copy(php_ion_decimal
*new_obj
, php_ion_decimal
*old_obj
)
858 zend_objects_clone_members(&new_obj
->std
, &old_obj
->std
);
859 new_obj
->ctx
= old_obj
->ctx
;
860 ION_CHECK(ion_decimal_copy(&new_obj
->dec
, &old_obj
->dec
));
863 php_ion_decl(decimal
, Decimal
);
865 typedef php_date_obj php_ion_timestamp
;
867 LOCAL zend_long
php_usec_from_ion(const decQuad
*frac
, decContext
*ctx
)
870 ctx
= &php_ion_globals
.decimal
.ctx
;
872 decQuad microsecs
, result
;
873 decQuadMultiply(&result
, decQuadFromInt32(µsecs
, 1000000), frac
, ctx
);
874 return (zend_long
) decQuadToUInt32(&result
, ctx
, DEC_ROUND_HALF_EVEN
);
877 LOCAL decQuad
*ion_ts_frac_from_usec(decQuad
*frac
, int usec
, decContext
*ctx
)
880 ctx
= &php_ion_globals
.decimal
.ctx
;
882 decQuad microsecs
, us
;
883 return decQuadDivide(frac
, decQuadFromInt32(&us
, usec
), decQuadFromInt32(µsecs
, 1000000), ctx
);
886 LOCAL zend_string
*php_ion_timestamp_format_fetch(zend_string
*fmt_case
)
888 return Z_STR_P(zend_enum_fetch_case_value(zend_enum_get_case(ce_Timestamp_Format
, fmt_case
)));
891 LOCAL zend_string
*php_dt_format_from_precision(uint8_t precision
)
894 case ION_TS_FRAC
| 0x80:
895 return php_ion_timestamp_format_fetch(g_intern_str
.FracTZ
);
897 return php_ion_timestamp_format_fetch(g_intern_str
.Frac
);
898 case ION_TS_SEC
| 0x80:
899 return php_ion_timestamp_format_fetch(g_intern_str
.SecTZ
);
901 return php_ion_timestamp_format_fetch(g_intern_str
.Sec
);
902 case ION_TS_MIN
| 0x80:
903 return php_ion_timestamp_format_fetch(g_intern_str
.MinTZ
);
905 return php_ion_timestamp_format_fetch(g_intern_str
.Min
);
907 return php_ion_timestamp_format_fetch(g_intern_str
.Day
);
909 return php_ion_timestamp_format_fetch(g_intern_str
.Month
);
911 return php_ion_timestamp_format_fetch(g_intern_str
.Year
);
913 return zend_one_char_string
['c'];
917 LOCAL timelib_time
* php_time_from_ion(const ION_TIMESTAMP
*ts
, decContext
*ctx
, zend_string
**fmt
)
919 timelib_time
*time
= ecalloc(1, sizeof(*time
));
926 switch (ts
->precision
& 0x7f) {
928 time
->us
= php_usec_from_ion(&ts
->fraction
, ctx
);
931 time
->s
= ts
->seconds
;
934 time
->i
= ts
->minutes
;
947 time
->z
= ts
->tz_offset
* 60;
948 if (time
->z
|| ts
->precision
& 0x80) {
949 time
->zone_type
= TIMELIB_ZONETYPE_OFFSET
;
951 time
->zone_type
= TIMELIB_ZONETYPE_ID
;
952 time
->tz_info
= get_timezone_info();
957 *fmt
= php_dt_format_from_precision(ts
->precision
);
962 LOCAL ION_TIMESTAMP
*ion_timestamp_from_php(ION_TIMESTAMP
*buf
, php_ion_timestamp
*ts
, decContext
*ctx
)
964 memset(buf
, 0, sizeof(*buf
));
967 int precision
= Z_LVAL_P(zend_read_property(ts
->std
.ce
, &ts
->std
, ZEND_STRL("precision"), 0, &tmp
));
969 if (!precision
|| precision
> (ION_TS_FRAC
|0x80)) {
970 zend_throw_exception_ex(spl_ce_InvalidArgumentException
, IERR_INVALID_ARG
,
971 "Invalid precision (%d) of ion\\Timestamp", precision
);
972 } else switch ((buf
->precision
= precision
) & 0x7f) {
974 ion_ts_frac_from_usec(&buf
->fraction
, (int) ts
->time
->us
, ctx
);
977 buf
->seconds
= ts
->time
->s
;
980 buf
->minutes
= ts
->time
->i
;
983 buf
->hours
= ts
->time
->h
;
984 buf
->day
= ts
->time
->d
;
987 buf
->month
= ts
->time
->m
;
990 buf
->year
= ts
->time
->y
;
993 buf
->tz_offset
= (short) (ts
->time
->z
/ 60);
994 if (buf
->tz_offset
) {
995 buf
->precision
|= 0x80;
1002 LOCAL
void php_ion_timestamp_ctor(php_ion_timestamp
*obj
, zend_long precision
, zend_string
*fmt
, zend_string
*dt
, zval
*tz
)
1005 php_date_initialize(obj
, dt
? dt
->val
: "", dt
? dt
->len
: 0, fmt
? fmt
->val
: NULL
, tz
, PHP_DATE_INIT_CTOR
);
1007 zend_update_property_long(obj
->std
.ce
, &obj
->std
, ZEND_STRL("precision"), precision
);
1009 fmt
= php_dt_format_from_precision(precision
);
1010 zend_update_property_str(obj
->std
.ce
, &obj
->std
, ZEND_STRL("format"), fmt
);
1011 zend_string_release(fmt
);
1014 typedef struct php_ion_catalog
{
1019 LOCAL
void php_ion_catalog_ctor(php_ion_catalog
*obj
)
1021 ION_CHECK(ion_catalog_open(&obj
->cat
));
1024 LOCAL
void php_ion_catalog_dtor(php_ion_catalog
*obj
)
1027 ion_catalog_close(obj
->cat
);
1031 LOCAL ION_COLLECTION
*php_ion_catalog_collection(php_ion_catalog
*cat
)
1033 /* do not look too close */
1036 ION_SYMBOL_TABLE
*sys
;
1037 ION_COLLECTION collection
;
1038 } *cat_ptr
= (void *) cat
->cat
;
1039 return &cat_ptr
->collection
;
1041 // see https://github.com/amzn/ion-c/issues/269
1042 #ifndef IPCN_pNODE_TO_pDATA
1043 # define IPCN_pNODE_TO_pDATA(x) (&((x)->_data[0]))
1046 LOCAL
void php_ion_catalog_copy(php_ion_catalog
*new_obj
, php_ion_catalog
*old_obj
)
1048 // do not clone cache members
1049 php_ion_catalog_ctor(new_obj
);
1052 ION_COLLECTION
*col
= php_ion_catalog_collection(old_obj
);
1053 if (!ION_COLLECTION_IS_EMPTY(col
)) {
1054 ION_COLLECTION_CURSOR cur
;
1055 ION_COLLECTION_OPEN(col
, cur
);
1057 ION_SYMBOL_TABLE
**ptr
;
1058 ION_COLLECTION_NEXT(cur
, ptr
);
1060 ION_CHECK(ion_catalog_add_symbol_table(new_obj
->cat
, *ptr
));
1066 LOCAL zend_string
*ion_symbol_table_to_key(ION_SYMBOL_TABLE
*tab
)
1070 ION_CHECK_RETURN(NULL
, ion_symbol_table_get_name(tab
, &is
));
1071 ION_CHECK_RETURN(NULL
, ion_symbol_table_get_version(tab
, &version
));
1074 smart_str_appendl(&s
, (char *) is
.value
, is
.length
);
1075 smart_str_appendc(&s
, ':');
1076 smart_str_append_long(&s
, version
);
1082 LOCAL
void php_ion_catalog_add_symbol_table(php_ion_catalog
*obj
, php_ion_symbol_table
*tab
)
1088 zval
*ztabs
= zend_read_property(obj
->std
.ce
, &obj
->std
, ZEND_STRL("symbolTables"), 0, &tmp
);
1090 zend_ulong idx
= (uintptr_t) &tab
->std
.gc
;
1091 if (!zend_hash_index_exists(Z_ARRVAL_P(ztabs
), idx
)) {
1092 zend_string
*key
= ion_symbol_table_to_key(tab
->tab
);
1094 ION_CHECK(ion_catalog_add_symbol_table(obj
->cat
, tab
->tab
),
1095 zend_string_release(key
));
1096 SEPARATE_ARRAY(ztabs
);
1097 GC_ADDREF(&tab
->std
);
1098 add_index_object(ztabs
, idx
, &tab
->std
);
1099 GC_ADDREF(&tab
->std
);
1100 add_assoc_object_ex(ztabs
, key
->val
, key
->len
, &tab
->std
);
1101 zend_update_property(obj
->std
.ce
, &obj
->std
, ZEND_STRL("symbolTables"), ztabs
);
1102 zend_string_release(key
);
1108 LOCAL
void php_ion_catalog_symbol_table_zval(php_ion_catalog
*obj
, ION_SYMBOL_TABLE
*tab
, zval
*return_value
)
1110 zend_string
*key
= ion_symbol_table_to_key(tab
);
1114 zval
*ztabs
= zend_read_property(obj
->std
.ce
, &obj
->std
, ZEND_STRL("symbolTables"), 0, &tmp
);
1116 zval
*ztab
= zend_hash_find(Z_ARRVAL_P(ztabs
), key
);
1118 zend_string_release(key
);
1123 php_error_docref(NULL
, E_NOTICE
, "Previously unknown ion\\Symbol\\Table encountered: %s", key
->val
);
1125 object_init_ex(return_value
, ce_Symbol_Table_Shared
);
1126 php_ion_symbol_table
*o_tab
= php_ion_obj(symbol_table
, Z_OBJ_P(return_value
));
1127 OBJ_CHECK(o_tab
, zend_string_release(key
));
1128 php_ion_symbol_table_ctor(o_tab
);
1131 SEPARATE_ARRAY(ztabs
);
1132 ZVAL_ADDREF(return_value
);
1133 add_index_zval(ztabs
, (uintptr_t) &o_tab
->std
.gc
, return_value
);
1134 ZVAL_ADDREF(return_value
);
1135 add_assoc_zval_ex(ztabs
, key
->val
, key
->len
, return_value
);
1137 zend_string_release(key
);
1140 php_ion_decl(catalog
, Catalog
);
1142 typedef struct php_ion_reader_options_ccn_ctx
{
1144 zend_fcall_info fci
;
1145 zend_fcall_info_cache fcc
;
1146 } php_ion_reader_options_ccn_ctx
;
1148 typedef struct php_ion_reader_options
{
1149 ION_READER_OPTIONS opt
;
1150 php_ion_reader_options_ccn_ctx ccn
;
1151 zend_object
*cat
, *dec_ctx
, *cb
, std
;
1152 } php_ion_reader_options
;
1154 LOCAL
void php_ion_reader_options_dtor(php_ion_reader_options
*obj
)
1157 zend_fcall_info_args_clear(&obj
->ccn
.fci
, true);
1161 LOCAL
void php_ion_reader_options_copy(php_ion_reader_options
*new_obj
, php_ion_reader_options
*old_obj
)
1163 zend_objects_clone_members(&new_obj
->std
, &old_obj
->std
);
1165 new_obj
->opt
= old_obj
->opt
;
1166 new_obj
->cat
= old_obj
->cat
;
1167 new_obj
->dec_ctx
= old_obj
->dec_ctx
;
1168 new_obj
->cb
= old_obj
->cb
;
1171 ZVAL_OBJ(&zcb
, new_obj
->cb
);
1172 zend_fcall_info_init(&zcb
, 0, &new_obj
->ccn
.fci
, &new_obj
->ccn
.fcc
, NULL
, NULL
);
1173 new_obj
->opt
.context_change_notifier
.context
= &new_obj
->ccn
;
1177 php_ion_decl(reader_options
, Reader_Options
);
1179 LOCAL zend_object
*php_ion_reader_options_new(void)
1181 zend_object
*obj
= create_ion_Reader_Options(NULL
);
1182 zend_call_known_instance_method_with_0_params(obj
->ce
->constructor
, obj
, NULL
);
1186 typedef struct php_ion_reader
{
1194 zend_string
*buffer
;
1200 zend_object
*opt
, std
;
1203 LOCAL iERR
php_ion_reader_stream_handler(struct _ion_user_stream
*user
)
1205 php_ion_reader
*reader
= (php_ion_reader
*) user
->handler_state
;
1206 size_t remaining
= 0, spare
= reader
->stream
.buf
.length
;
1208 if (user
->curr
&& user
->limit
&& (remaining
= user
->limit
- user
->curr
)) {
1209 memmove(reader
->stream
.buf
.value
, user
->curr
, remaining
);
1210 user
->limit
-= remaining
;
1213 user
->curr
= user
->limit
= reader
->stream
.buf
.value
;
1216 ssize_t read
= php_stream_read(reader
->stream
.ptr
, (char *) user
->limit
, spare
);
1217 if (EXPECTED(read
> 0)) {
1218 user
->limit
+= read
;
1222 if (EXPECTED(read
== 0)) {
1226 return IERR_READ_ERROR
;
1229 LOCAL iERR
on_context_change(void *context
, ION_COLLECTION
*imports
)
1234 php_ion_reader_options_ccn_ctx
*ctx
= context
;
1237 ZVAL_OBJ(&zobj
, ctx
->obj
);
1238 zend_fcall_info_argn(&ctx
->fci
, 1, &zobj
);
1239 if (SUCCESS
!= zend_fcall_info_call(&ctx
->fci
, &ctx
->fcc
, NULL
, NULL
)) {
1240 e
= IERR_INTERNAL_ERROR
;
1242 zend_fcall_info_args_clear(&ctx
->fci
, false);
1247 LOCAL
void php_ion_reader_ctor(php_ion_reader
*obj
)
1250 php_ion_reader_options
*opt
= php_ion_obj(reader_options
, obj
->opt
);
1252 if (opt
&& opt
->opt
.context_change_notifier
.context
) {
1253 php_ion_reader_options_ccn_ctx
*ctx
= opt
->opt
.context_change_notifier
.context
;
1254 ctx
->obj
= &obj
->std
;
1255 opt
->opt
.context_change_notifier
.notify
= on_context_change
;
1257 if (obj
->type
== STREAM_READER
) {
1258 PTR_CHECK(obj
->stream
.ptr
);
1259 GC_ADDREF(obj
->stream
.ptr
->res
);
1261 obj
->stream
.buf
.length
= opt
&& opt
->opt
.allocation_page_size
? opt
->opt
.allocation_page_size
: 0x10000;
1262 obj
->stream
.buf
.value
= emalloc(obj
->stream
.buf
.length
);
1263 err
= ion_reader_open_stream(&obj
->reader
, obj
, php_ion_reader_stream_handler
, opt
? &opt
->opt
: NULL
);
1266 err
= ion_reader_open_buffer(&obj
->reader
, (BYTE
*) obj
->buffer
->val
, (SIZE
) obj
->buffer
->len
, opt
? &opt
->opt
: NULL
);
1273 LOCAL
void php_ion_reader_dtor(php_ion_reader
*obj
)
1276 ion_reader_close(obj
->reader
);
1278 if (obj
->type
== STREAM_READER
) {
1279 if (obj
->stream
.buf
.value
) {
1280 efree(obj
->stream
.buf
.value
);
1282 if (obj
->stream
.ptr
) {
1283 zend_list_delete(obj
->stream
.ptr
->res
);
1287 zend_string_release(obj
->buffer
);
1292 #define php_ion_reader_copy(n,o)
1293 php_ion_decl(reader
, Reader_Reader
);
1294 #define clone_ion_Reader_Reader NULL
1296 typedef struct php_ion_writer_options
{
1297 ION_WRITER_OPTIONS opt
;
1298 zend_object
*cat
, *dec_ctx
, std
;
1299 } php_ion_writer_options
;
1301 LOCAL
void php_ion_writer_options_copy(php_ion_writer_options
*new_obj
, php_ion_writer_options
*old_obj
)
1303 zend_objects_clone_members(&new_obj
->std
, &old_obj
->std
);
1305 new_obj
->opt
= old_obj
->opt
;
1306 new_obj
->cat
= old_obj
->cat
;
1307 new_obj
->dec_ctx
= old_obj
->dec_ctx
;
1310 LOCAL
void php_ion_writer_options_dtor(php_ion_writer_options
*obj
)
1314 php_ion_decl(writer_options
, Writer_Options
);
1316 LOCAL zend_object
*php_ion_writer_options_new(void)
1318 zend_object
*obj
= create_ion_Writer_Options(NULL
);
1319 zend_call_known_instance_method_with_0_params(obj
->ce
->constructor
, obj
, NULL
);
1323 typedef struct php_ion_writer
{
1332 struct _ion_user_stream
*usr
;
1339 zend_object
*opt
, std
;
1343 LOCAL iERR
php_ion_writer_stream_handler(struct _ion_user_stream
*user
)
1345 php_ion_writer
*writer
= (php_ion_writer
*) user
->handler_state
;
1347 if (EXPECTED(user
->limit
&& user
->curr
)) {
1348 ptrdiff_t len
= user
->curr
- writer
->stream
.buf
.value
;
1349 if (len
!= php_stream_write(writer
->stream
.ptr
, (char *) writer
->stream
.buf
.value
, len
)) {
1350 return IERR_WRITE_ERROR
;
1353 user
->curr
= writer
->stream
.buf
.value
;
1354 user
->limit
= writer
->stream
.buf
.value
+ writer
->stream
.buf
.length
;
1358 LOCAL
void php_ion_writer_stream_init(php_ion_writer
*obj
, php_ion_writer_options
*opt
)
1360 PTR_CHECK(obj
->stream
.ptr
);
1361 GC_ADDREF(obj
->stream
.ptr
->res
);
1363 obj
->stream
.buf
.length
= opt
? opt
->opt
.allocation_page_size
: 0x1000;
1364 obj
->stream
.buf
.value
= emalloc(obj
->stream
.buf
.length
);
1367 LOCAL
void php_ion_writer_buffer_offer(php_ion_writer
*obj
)
1369 if (obj
->buffer
.usr
) {
1370 obj
->buffer
.usr
->curr
= (BYTE
*) &obj
->buffer
.str
.s
->val
[obj
->buffer
.str
.s
->len
];
1371 obj
->buffer
.usr
->limit
= obj
->buffer
.usr
->curr
+ obj
->buffer
.str
.a
- obj
->buffer
.str
.s
->len
;
1375 LOCAL
void php_ion_writer_buffer_init(php_ion_writer
*obj
)
1377 smart_str_alloc(&obj
->buffer
.str
, 0, false);
1378 php_ion_writer_buffer_offer(obj
);
1381 LOCAL
void php_ion_writer_buffer_reset(php_ion_writer
*obj
)
1383 smart_str_free(&obj
->buffer
.str
);
1384 memset(&obj
->buffer
.str
, 0, sizeof(obj
->buffer
.str
));
1385 php_ion_writer_buffer_init(obj
);
1388 LOCAL zend_string
*php_ion_writer_buffer_copy(php_ion_writer
*obj
)
1390 if (obj
->buffer
.usr
) {
1391 // ensure that brain-dead ion_stream interface calls us again
1392 obj
->buffer
.usr
->curr
= NULL
;
1393 obj
->buffer
.usr
->limit
= NULL
;
1395 smart_str_0(&obj
->buffer
.str
);
1396 return zend_string_copy(obj
->buffer
.str
.s
);
1399 LOCAL
void php_ion_writer_buffer_separate(php_ion_writer
*obj
, bool grow
)
1401 // see zend_string_separate and smart_str_erealloc
1402 zend_string
*old_str
= obj
->buffer
.str
.s
;
1403 zend_string
*new_str
= zend_string_alloc(obj
->buffer
.str
.a
<< grow
, false);
1404 memcpy(new_str
->val
, old_str
->val
, new_str
->len
= old_str
->len
);
1405 zend_string_release(old_str
);
1406 obj
->buffer
.str
.s
= new_str
;
1409 LOCAL
void php_ion_writer_buffer_grow(php_ion_writer
*obj
)
1411 if (obj
->buffer
.usr
&& obj
->buffer
.usr
->curr
) {
1412 obj
->buffer
.str
.s
->len
= obj
->buffer
.usr
->curr
- (BYTE
*) obj
->buffer
.str
.s
->val
;
1414 if (obj
->buffer
.usr
&& obj
->buffer
.usr
->curr
&& obj
->buffer
.usr
->curr
== obj
->buffer
.usr
->limit
) {
1415 if (UNEXPECTED(GC_REFCOUNT(obj
->buffer
.str
.s
) > 1)) {
1416 php_ion_writer_buffer_separate(obj
, true);
1418 smart_str_erealloc(&obj
->buffer
.str
, obj
->buffer
.str
.a
<< 1);
1420 } else if (UNEXPECTED(GC_REFCOUNT(obj
->buffer
.str
.s
) > 1)) {
1421 php_ion_writer_buffer_separate(obj
, false);
1423 php_ion_writer_buffer_offer(obj
);
1427 LOCAL iERR
php_ion_writer_buffer_handler(struct _ion_user_stream
*user
)
1429 php_ion_writer
*writer
= (php_ion_writer
*) user
->handler_state
;
1430 writer
->buffer
.usr
= user
;
1431 php_ion_writer_buffer_grow(writer
);
1435 LOCAL
void php_ion_writer_options_init_shared_imports(php_ion_writer_options
*opt
)
1437 php_ion_catalog
*cat
= php_ion_obj(catalog
, opt
->cat
);
1440 ION_CHECK(ion_writer_options_initialize_shared_imports(&opt
->opt
));
1442 ION_COLLECTION
*col
= php_ion_catalog_collection(cat
);
1443 if (!ION_COLLECTION_IS_EMPTY(col
)) {
1444 // holy, nah, forget it batman...
1445 ION_COLLECTION_CURSOR cur
;
1446 ION_COLLECTION_OPEN(col
, cur
);
1448 ION_SYMBOL_TABLE
**ptr
;
1449 ION_COLLECTION_NEXT(cur
, ptr
);
1451 ION_CHECK(ion_writer_options_add_shared_imports_symbol_tables(&opt
->opt
, ptr
, 1));
1457 LOCAL
void php_ion_writer_ctor(php_ion_writer
*obj
)
1459 php_ion_writer_options
*opt
= NULL
;
1462 update_property_obj(&obj
->std
, ZEND_STRL("options"), obj
->opt
);
1463 opt
= php_ion_obj(writer_options
, obj
->opt
);
1465 php_ion_writer_options_init_shared_imports(opt
);
1469 ION_STREAM_HANDLER h
;
1470 if (obj
->type
== STREAM_WRITER
) {
1471 h
= php_ion_writer_stream_handler
;
1472 php_ion_writer_stream_init(obj
, opt
);
1474 h
= php_ion_writer_buffer_handler
;
1475 php_ion_writer_buffer_init(obj
);
1479 ION_CHECK(ion_writer_open_stream(&obj
->writer
, h
, obj
, opt
? &opt
->opt
: NULL
));
1483 LOCAL
void php_ion_writer_dtor(php_ion_writer
*obj
)
1486 ion_writer_close(obj
->writer
);
1489 php_ion_writer_options
*opt
= php_ion_obj(writer_options
, obj
->opt
);
1491 ion_writer_options_close_shared_imports(&opt
->opt
);
1494 if (obj
->type
== STREAM_WRITER
) {
1495 if (obj
->stream
.buf
.value
) {
1496 efree(obj
->stream
.buf
.value
);
1498 if (obj
->stream
.ptr
) {
1499 zend_list_delete(obj
->stream
.ptr
->res
);
1502 if (obj
->buffer
.str
.s
) {
1503 smart_str_0(&obj
->buffer
.str
);
1504 zend_string_release(obj
->buffer
.str
.s
);
1509 #define php_ion_writer_copy(o,n)
1510 php_ion_decl(writer
, Writer_Writer
);
1511 #define clone_ion_Writer_Writer NULL
1513 typedef struct php_ion_serializer_php
{
1514 php_ion_serializer serializer
;
1515 zend_object
*opt
, std
;
1516 } php_ion_serializer_php
;
1518 LOCAL
void php_ion_serializer_php_ctor(php_ion_serializer_php
*ser_obj
)
1520 php_ion_serializer
*global_ser
= &php_ion_globals
.serializer
;
1521 ser_obj
->serializer
.ids
= global_ser
->ids
;
1522 ser_obj
->serializer
.tmp
= global_ser
->tmp
;
1524 zend_update_property_bool(ser_obj
->std
.ce
, &ser_obj
->std
, ZEND_STRL("multiSequence"),
1525 ser_obj
->serializer
.multi_seq
);
1526 zend_update_property_bool(ser_obj
->std
.ce
, &ser_obj
->std
, ZEND_STRL("callMagicSerialize"),
1527 ser_obj
->serializer
.call_magic
);
1528 if (ser_obj
->serializer
.call_custom
) {
1529 zend_update_property_str(ser_obj
->std
.ce
, &ser_obj
->std
, ZEND_STRL("callCustomSerialize"),
1530 ser_obj
->serializer
.call_custom
);
1531 ser_obj
->serializer
.call_custom
= zend_string_tolower(ser_obj
->serializer
.call_custom
);
1533 zend_update_property_null(ser_obj
->std
.ce
, &ser_obj
->std
, ZEND_STRL("callCustomSerialize"));
1535 if (!ser_obj
->opt
) {
1536 ser_obj
->opt
= php_ion_writer_options_new();
1538 GC_ADDREF(ser_obj
->opt
);
1540 ser_obj
->serializer
.options
= &php_ion_obj(writer_options
, ser_obj
->opt
)->opt
;
1541 update_property_obj(&ser_obj
->std
, ZEND_STRL("writerOptions"), ser_obj
->opt
);
1542 GC_DELREF(ser_obj
->opt
);
1545 LOCAL
void php_ion_serializer_php_dtor(php_ion_serializer_php
*obj
)
1547 if (obj
->serializer
.call_custom
) {
1548 zend_string_release(obj
->serializer
.call_custom
);
1552 LOCAL
void php_ion_serialize_zval(php_ion_serializer
*, zval
*);
1554 LOCAL
void php_ion_serialize_struct(php_ion_serializer
*ser
, zend_array
*arr
, bool unmangle_props
, bool annotate_props
)
1556 ION_CHECK(ion_writer_start_container(ser
->writer
, tid_STRUCT
));
1560 zend_string
*k
= NULL
;
1561 if (arr
) ZEND_HASH_FOREACH_KEY_VAL_IND(arr
, h
, k
, v
)
1562 char buf
[MAX_LENGTH_OF_LONG
+ 1];
1566 const char *class_name
, *prop_name
;
1567 if (unmangle_props
&& (SUCCESS
== zend_unmangle_property_name_ex(k
, &class_name
, &prop_name
, &prop_len
)) && class_name
) {
1568 if (annotate_props
) {
1569 ION_CHECK(ion_writer_add_annotation_symbol(ser
->writer
, &PHP_ION_SYMBOL_PROPERTY
));
1570 ION_CHECK(ion_writer_add_annotation(ser
->writer
, ion_string_assign_cstr(&is
, (char *) class_name
, prop_name
- class_name
- 1)));
1576 ion_string_assign_cstr(&is
, (char *) prop_name
, (SIZE
) prop_len
);
1578 char *end
= buf
+ sizeof(buf
) - 1;
1579 char *ptr
= zend_print_long_to_buf(end
, (zend_long
) h
);
1580 ion_string_assign_cstr(&is
, ptr
, (SIZE
) (end
- ptr
));
1583 // WATCH OUT: field names need to be copied
1585 ION_CHECK(ion_string_copy_to_owner(ser
->writer
, &fn
, &is
));
1586 ION_CHECK(ion_writer_write_field_name(ser
->writer
, &fn
));
1588 php_ion_serialize_zval(ser
, v
);
1590 ZEND_HASH_FOREACH_END();
1592 ION_CHECK(ion_writer_finish_container(ser
->writer
));
1595 LOCAL
void php_ion_serialize_list(php_ion_serializer
*ser
, zend_array
*arr
)
1597 ION_CHECK(ion_writer_start_container(ser
->writer
, tid_LIST
));
1600 ZEND_HASH_FOREACH_VAL_IND(arr
, v
)
1601 php_ion_serialize_zval(ser
, v
);
1603 ZEND_HASH_FOREACH_END();
1605 ION_CHECK(ion_writer_finish_container(ser
->writer
));
1608 LOCAL
void php_ion_serialize_array(php_ion_serializer
*ser
, zend_array
*arr
)
1610 if (zend_array_is_list(arr
)) {
1611 php_ion_serialize_list(ser
, arr
);
1613 php_ion_serialize_struct(ser
, arr
, false, false);
1617 LOCAL
void php_ion_serialize_object_iface(php_ion_serializer
*ser
, zend_object
*zobject
)
1623 ZVAL_OBJ(&tmp
, zobject
);
1624 if (SUCCESS
== zobject
->ce
->serialize(&tmp
, &buf
, &len
, NULL
)) {
1626 ION_CHECK(ion_writer_add_annotation_symbol(ser
->writer
, &PHP_ION_SYMBOL_SERIALIZEABLE
));
1627 ION_CHECK(ion_writer_add_annotation(ser
->writer
, ion_string_from_zend(&is
, zobject
->ce
->name
)));
1628 ION_CHECK(ion_writer_write_clob(ser
->writer
, buf
, len
));
1630 } else if (!EG(exception
)){
1631 zend_throw_exception_ex(spl_ce_UnexpectedValueException
, IERR_INTERNAL_ERROR
,
1632 "Failed to serialize class %s", zobject
->ce
->name
->val
);
1636 LOCAL
void php_ion_serialize_object_magic(php_ion_serializer
*ser
, zend_object
*zobject
, zend_function
*fn
)
1641 zend_call_known_instance_method_with_0_params(fn
? fn
: zobject
->ce
->__serialize
, zobject
, &rv
);
1644 if (IS_ARRAY
== Z_TYPE(rv
)) {
1646 ION_CHECK(ion_writer_add_annotation_symbol(ser
->writer
, fn
? &PHP_ION_SYMBOL_CUSTOM_OBJECT
: &PHP_ION_SYMBOL_MAGIC_OBJECT
));
1647 ION_CHECK(ion_writer_add_annotation(ser
->writer
, ion_string_from_zend(&is
, zobject
->ce
->name
)));
1648 php_ion_serialize_zval(ser
, &rv
);
1651 zend_throw_exception_ex(spl_ce_UnexpectedValueException
, IERR_INTERNAL_ERROR
,
1652 "%s serializer %s::%s did not return an array",
1653 fn
? "Custom" : "Magic", zobject
->ce
->name
->val
,
1654 fn
? fn
->common
.function_name
->val
: "__serialize");
1658 LOCAL
void php_ion_serialize_object_enum(php_ion_serializer
*ser
, zend_object
*zobject
)
1661 ION_CHECK(ion_writer_add_annotation_symbol(ser
->writer
, &PHP_ION_SYMBOL_ENUM
));
1663 ION_CHECK(ion_writer_add_annotation(ser
->writer
, ion_string_from_zend(&is
, zobject
->ce
->name
)));
1664 zval
*z_cname
= zend_enum_fetch_case_name(zobject
);
1665 ION_CHECK(ion_writer_write_symbol(ser
->writer
, ion_string_from_zend(&is
, Z_STR_P(z_cname
))));
1668 LOCAL
void php_ion_serialize_object_std(php_ion_serializer
*ser
, zend_object
*zobject
)
1672 if (zobject
->ce
!= zend_standard_class_def
) {
1673 ION_CHECK(ion_writer_add_annotation_symbol(ser
->writer
, &PHP_ION_SYMBOL_CLASS_OBJECT
));
1674 ION_CHECK(ion_writer_add_annotation(ser
->writer
, ion_string_from_zend(&is
, zobject
->ce
->name
)));
1676 ION_CHECK(ion_writer_add_annotation_symbol(ser
->writer
, &PHP_ION_SYMBOL_OBJECT
));
1680 ZVAL_OBJ(&zobj
, zobject
);
1681 HashTable
*props
= zend_get_properties_for(&zobj
, ZEND_PROP_PURPOSE_SERIALIZE
);
1683 php_ion_serialize_struct(ser
, props
, true, true);
1684 zend_release_properties(props
);
1686 zend_throw_exception_ex(spl_ce_UnexpectedValueException
, IERR_INTERNAL_ERROR
,
1687 "Could not get properties for serialization of class %s",
1688 zobject
->ce
->name
->val
);
1692 LOCAL
void php_ion_serialize_object_lob(php_ion_serializer
*ser
, zend_object
*zobject
)
1694 zval tmp_type
, *type
= zend_read_property(NULL
, zobject
, ZEND_STRL("type"), 0, &tmp_type
);
1695 zval tmp_value
, *value
= zend_read_property(NULL
, zobject
, ZEND_STRL("value"), 0, &tmp_value
);
1696 switch (Z_LVAL_P(zend_enum_fetch_case_value(Z_OBJ_P(type
)))) {
1698 ION_CHECK(ion_writer_write_blob(ser
->writer
, (BYTE
*) Z_STRVAL_P(value
), Z_STRLEN_P(value
)));
1701 ION_CHECK(ion_writer_write_clob(ser
->writer
, (BYTE
*) Z_STRVAL_P(value
), Z_STRLEN_P(value
)));
1704 zend_throw_exception_ex(spl_ce_InvalidArgumentException
, IERR_INVALID_ARG
,
1705 "Unsupported LOB type: ion\\Type::%s", Z_STRVAL_P(zend_enum_fetch_case_name(Z_OBJ_P(type
))));
1710 LOCAL
bool can_call_magic_serialize(php_ion_serializer
*ser
, zend_class_entry
*ce
)
1712 return ce
->__serialize
&& ser
->call_magic
;
1715 LOCAL
bool can_call_iface_serialize(php_ion_serializer
*ser
, zend_class_entry
*ce
)
1718 return !!ce
->serialize
; // NOLINT
1721 LOCAL
bool can_call_custom_serialize(php_ion_serializer
*ser
, zend_object
*zobject
, zend_function
**fn
)
1723 if (ser
->call_custom
) {
1724 return !!(*fn
= zend_hash_find_ptr(&zobject
->ce
->function_table
, ser
->call_custom
)); // NOLINT
1729 LOCAL
void php_ion_serialize_object(php_ion_serializer
*ser
, zend_object
*zobject
)
1732 zend_class_entry
*ce
= zobject
->ce
;
1735 if (ce
->ce_flags
& ZEND_ACC_NOT_SERIALIZABLE
) {
1736 zend_throw_exception_ex(spl_ce_InvalidArgumentException
, IERR_INVALID_ARG
,
1737 "Serializing %s is not allowed", ce
->name
->val
);
1741 if (can_call_magic_serialize(ser
, ce
)) {
1742 php_ion_serialize_object_magic(ser
, zobject
, NULL
);
1743 } else if (can_call_iface_serialize(ser
, ce
)) {
1744 php_ion_serialize_object_iface(ser
, zobject
);
1745 } else if (can_call_custom_serialize(ser
, zobject
, &fn
)) {
1746 php_ion_serialize_object_magic(ser
, zobject
, fn
);
1747 } else if (zobject
->ce
->ce_flags
& ZEND_ACC_ENUM
) {
1748 php_ion_serialize_object_enum(ser
, zobject
);
1749 } else if (ce
== ce_Symbol
) {
1750 ION_CHECK(ion_writer_write_ion_symbol(ser
->writer
, &php_ion_obj(symbol
, zobject
)->sym
));
1751 } else if (ce
== ce_Decimal
) {
1752 ION_CHECK(ion_writer_write_ion_decimal(ser
->writer
, &php_ion_obj(decimal
, zobject
)->dec
));
1753 } else if (ce
== ce_Timestamp
) {
1755 php_ion_timestamp
*pts
= php_ion_obj(timestamp
, zobject
);
1756 decContext
*ctx
= ser
->options
? ser
->options
->decimal_context
: NULL
;
1757 ION_CHECK(ion_writer_write_timestamp(ser
->writer
, ion_timestamp_from_php(&its
, pts
, ctx
)));
1758 } else if (ce
== ce_LOB
) {
1759 php_ion_serialize_object_lob(ser
, zobject
);
1761 php_ion_serialize_object_std(ser
, zobject
);
1765 LOCAL
bool php_ion_serialize_system_value(php_ion_serializer
*ser
, zval
*zv
)
1767 if (1 == php_ion_globals
.serializer
.level
) {
1768 if (Z_TYPE_P(zv
) == IS_OBJECT
) {
1769 if (Z_OBJCE_P(zv
) == ce_Symbol_Table_Shared
) {
1770 php_ion_symbol_table
*obj
= php_ion_obj(symbol_table
, Z_OBJ_P(zv
));
1771 ION_CHECK_RETURN(true, ion_symbol_table_unload(obj
->tab
, ser
->writer
));
1779 LOCAL
bool php_ion_serialize_backref(php_ion_serializer
*ser
, zval
*zv
)
1781 if (Z_TYPE_P(zv
) == IS_STRING
&& Z_STR_P(zv
) == zend_empty_string
) {
1784 if (Z_TYPE_P(zv
) == IS_ARRAY
&& Z_ARR_P(zv
) == &zend_empty_array
) {
1788 zend_ulong idx
= (zend_ulong
) (uintptr_t) Z_COUNTED_P(zv
);
1789 zval
*ref
= zend_hash_index_find(ser
->ids
, idx
);
1793 ZVAL_LONG(&num
, zend_hash_num_elements(ser
->ids
));
1794 zend_hash_index_add(ser
->ids
, idx
, &num
);
1797 zend_hash_next_index_insert(ser
->tmp
, zv
);
1802 ION_CHECK_RETURN(true, ion_writer_add_annotation_symbol(ser
->writer
, &PHP_ION_SYMBOL_BACKREF
));
1803 ION_CHECK_RETURN(true, ion_writer_write_int64(ser
->writer
, Z_LVAL_P(ref
)));
1807 LOCAL
void php_ion_serialize_refcounted(php_ion_serializer
*ser
, zval
*zv
)
1809 if (php_ion_serialize_system_value(ser
, zv
)) {
1812 if (php_ion_serialize_backref(ser
, zv
)) {
1817 switch (Z_TYPE_P(zv
)) {
1819 ION_CHECK(ion_writer_write_string(ser
->writer
, ion_string_from_zend(&is
, Z_STR_P(zv
))));
1823 php_ion_serialize_array(ser
, Z_ARRVAL_P(zv
));
1827 php_ion_serialize_object(ser
, Z_OBJ_P(zv
));
1831 ION_CHECK(ion_writer_add_annotation_symbol(ser
->writer
, &PHP_ION_SYMBOL_REFERENCE
));
1832 php_ion_serialize_zval(ser
, Z_REFVAL_P(zv
));
1837 LOCAL
void php_ion_serialize_zval(php_ion_serializer
*ser
, zval
*zv
)
1841 switch (Z_TYPE_P(zv
)) {
1843 ION_CHECK(ion_writer_write_null(ser
->writer
));
1846 ION_CHECK(ion_writer_write_bool(ser
->writer
, TRUE
));
1849 ION_CHECK(ion_writer_write_bool(ser
->writer
, FALSE
));
1852 ION_CHECK(ion_writer_write_int64(ser
->writer
, Z_LVAL_P(zv
)));
1855 ION_CHECK(ion_writer_write_double(ser
->writer
, Z_DVAL_P(zv
)));
1861 php_ion_serialize_refcounted(ser
, zv
);
1864 zend_throw_exception_ex(spl_ce_InvalidArgumentException
, IERR_INVALID_ARG
,
1865 "Failed to serialize value of type %s", zend_zval_type_name(zv
));
1869 #define php_ion_serializer_php_copy(o,n)
1870 php_ion_decl(serializer_php
, Serializer_PHP
);
1871 #define clone_ion_Serializer_PHP NULL
1873 LOCAL
void php_ion_serialize_ex(php_ion_serializer
*ser
, zval
*zv
)
1876 HashTable
*arr
= NULL
;
1878 if (ser
->multi_seq
) {
1879 if (Z_TYPE_P(zv
) != IS_ARRAY
|| !zend_array_is_list(Z_ARRVAL_P(zv
))) {
1880 zend_throw_exception_ex(spl_ce_InvalidArgumentException
, IERR_INVALID_ARG
,
1881 "Expected a packed, consecutively numerically indexed array as argument to the multi sequence serializer");
1885 arr
= Z_ARRVAL_P(zv
);
1887 zend_hash_internal_pointer_reset_ex(arr
, &pos
);
1888 zv
= zend_hash_get_current_data_ex(arr
, &pos
);
1892 php_ion_globals_serializer_step();
1893 php_ion_serialize_zval(ser
, zv
);
1894 php_ion_globals_serializer_exit();
1896 if (!ser
->multi_seq
) {
1899 zend_hash_move_forward_ex(arr
, &pos
);
1900 zv
= zend_hash_get_current_data_ex(arr
, &pos
);
1904 void php_ion_serialize(php_ion_serializer
*ser
, zval
*zv
, zval
*return_value
)
1906 zend_object
*zo_opt
= NULL
, *zo_ser
= NULL
;
1909 zo_ser
= create_ion_Serializer_PHP(NULL
);
1910 php_ion_serializer_php
*o_ser
= php_ion_obj(serializer_php
, zo_ser
);
1912 o_ser
->serializer
.call_magic
= true;
1913 php_ion_serializer_php_ctor(o_ser
);
1915 ser
= &o_ser
->serializer
;
1918 zend_object
*zo_writer
= create_ion_Writer_Writer(ce_Writer_Buffer_Writer
);
1919 php_ion_writer
*writer
= php_ion_obj(writer
, zo_writer
);
1920 writer
->type
= BUFFER_WRITER
;
1923 zo_opt
= writer
->opt
= php_ion_writer_options_new();
1924 php_ion_obj(writer_options
, writer
->opt
)->opt
= *ser
->options
;
1927 php_ion_writer_ctor(writer
);
1928 ser
->writer
= writer
->writer
;
1929 ser
->buffer
= &writer
->buffer
.str
;
1931 if (!EG(exception
)) {
1932 php_ion_serialize_ex(ser
, zv
);
1935 /* make sure to flush when done, else str.s might not contain everything until the writer is closed */
1936 ion_writer_flush(ser
->writer
, NULL
);
1937 RETVAL_STR_COPY(ser
->buffer
->s
);
1939 OBJ_RELEASE(zo_writer
);
1941 OBJ_RELEASE(zo_opt
);
1944 OBJ_RELEASE(zo_ser
);
1948 typedef struct php_ion_unserializer_php
{
1949 php_ion_unserializer unserializer
;
1950 zend_object
*opt
, std
;
1951 } php_ion_unserializer_php
;
1953 LOCAL
void php_ion_unserializer_php_ctor(php_ion_unserializer_php
*ser_obj
)
1955 php_ion_unserializer
*global_ser
= &php_ion_globals
.unserializer
;
1956 ser_obj
->unserializer
.ids
= global_ser
->ids
;
1957 ser_obj
->unserializer
.tmp
= global_ser
->tmp
;
1958 ser_obj
->unserializer
.addref
= global_ser
->addref
;
1960 zend_update_property_bool(ser_obj
->std
.ce
, &ser_obj
->std
, ZEND_STRL("multiSequence"),
1961 ser_obj
->unserializer
.multi_seq
);
1962 zend_update_property_bool(ser_obj
->std
.ce
, &ser_obj
->std
, ZEND_STRL("callMagicUnserialize"),
1963 ser_obj
->unserializer
.call_magic
);
1964 if (ser_obj
->unserializer
.call_custom
) {
1965 zend_update_property_str(ser_obj
->std
.ce
, &ser_obj
->std
, ZEND_STRL("callCustomUnserialize"),
1966 ser_obj
->unserializer
.call_custom
);
1967 ser_obj
->unserializer
.call_custom
= zend_string_tolower(ser_obj
->unserializer
.call_custom
);
1969 zend_update_property_null(ser_obj
->std
.ce
, &ser_obj
->std
, ZEND_STRL("callCustomUnserialize"));
1971 if (!ser_obj
->opt
) {
1972 ser_obj
->opt
= php_ion_reader_options_new();
1974 GC_ADDREF(ser_obj
->opt
);
1976 ser_obj
->unserializer
.options
= &php_ion_obj(reader_options
, ser_obj
->opt
)->opt
;
1977 update_property_obj(&ser_obj
->std
, ZEND_STRL("readerOptions"), ser_obj
->opt
);
1978 GC_DELREF(ser_obj
->opt
);
1981 LOCAL
void php_ion_unserializer_php_dtor(php_ion_unserializer_php
*obj
)
1983 if (obj
->unserializer
.call_custom
) {
1984 zend_string_release(obj
->unserializer
.call_custom
);
1988 LOCAL
void php_ion_unserialize_zval(php_ion_unserializer
*ser
, zval
*return_value
, ION_TYPE
*typ
);
1990 LOCAL
bool can_call_magic_unserialize(php_ion_unserializer
*ser
, zend_class_entry
*ce
)
1992 return (ce
&& ce
->__unserialize
&& ser
->call_magic
);
1995 LOCAL
bool can_call_iface_unserialize(php_ion_unserializer
*ser
, zend_class_entry
*ce
)
1997 return (ce
&& ce
->unserialize
);
2000 LOCAL
bool can_call_custom_unserialize(php_ion_unserializer
*ser
, zend_object
*zobject
, zend_function
**fn
)
2002 if (ser
->call_custom
) {
2003 return !!(*fn
= zend_hash_find_ptr(&zobject
->ce
->function_table
, ser
->call_custom
)); // NOLINT
2008 LOCAL zval
*php_ion_unserialize_class(php_ion_unserializer
*ser
, zval
*return_value
)
2010 zend_class_entry
*ce
= zend_lookup_class(ser
->annotations
.object_class
);
2013 object_init_ex(return_value
, ce
);
2014 return zend_hash_next_index_insert(ser
->ids
, return_value
);
2017 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_IMPORT_NOT_FOUND
,
2018 "Could not find class %s", ser
->annotations
.object_class
->val
);
2022 LOCAL
void php_ion_unserialize_object_enum(php_ion_unserializer
*ser
, zval
*return_value
)
2024 zend_string
*zs_case
= zval_get_string(return_value
);
2025 zend_hash_next_index_insert(ser
->tmp
, return_value
);
2026 ZVAL_NULL(return_value
);
2029 zend_class_entry
*ce
= zend_lookup_class(ser
->annotations
.object_class
);
2030 if (!ce
|| !(ce
->ce_flags
& ZEND_ACC_ENUM
)) {
2031 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_TOKEN
,
2032 "Not a valid enum: %s", ser
->annotations
.object_class
->val
);
2035 if (!zend_hash_exists(CE_CONSTANTS_TABLE(ce
), zs_case
)) {
2036 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_TOKEN
,
2037 "Not a valid enum case: %s::%s", ser
->annotations
.object_class
->val
, zs_case
->val
);
2040 RETVAL_OBJ_COPY(zend_enum_get_case(ce
, zs_case
));
2041 zend_hash_next_index_insert(ser
->ids
, return_value
);
2042 zend_string_release(zs_case
);
2045 LOCAL
void php_ion_unserialize_object_iface(php_ion_unserializer
*ser
, zval
*return_value
)
2047 zend_class_entry
*ce
= zend_lookup_class(ser
->annotations
.object_class
);
2048 if (can_call_iface_unserialize(ser
, ce
)) {
2049 zend_string
*s
= zval_get_string(return_value
);
2050 zend_hash_next_index_insert(ser
->tmp
, return_value
);
2051 ZVAL_NULL(return_value
);
2052 zval
*backref
= zend_hash_next_index_insert(ser
->ids
, return_value
);
2053 if (SUCCESS
== ce
->unserialize(backref
, ce
, (BYTE
*) s
->val
, s
->len
, NULL
)) {
2054 RETVAL_ZVAL(backref
, 0, 0);
2055 } else if (!EG(exception
)) {
2056 zend_throw_exception_ex(spl_ce_UnexpectedValueException
, IERR_INTERNAL_ERROR
,
2057 "Failed to unserialize class %s", ce
->name
->val
);
2059 zend_string_release(s
);
2061 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_TOKEN
,
2062 "Class %s does not implement Serializable", ser
->annotations
.object_class
->val
);
2066 LOCAL
void php_ion_unserialize_field_name_ex(php_ion_unserializer
*ser
, ION_STRING
*name
, SID
*sid
)
2068 ION_CHECK(ion_reader_get_field_name(ser
->reader
, name
));
2069 if (!name
->length
) {
2071 ION_CHECK(ion_reader_get_field_name_symbol(ser
->reader
, &is_ptr
));
2072 if (!ION_SYMBOL_IS_NULL(is_ptr
) && is_ptr
->value
.length
) {
2073 ION_STRING_ASSIGN(name
, &is_ptr
->value
);
2080 LOCAL
void php_ion_unserialize_field_name(php_ion_unserializer
*ser
, zend_string
**key
, bool is_prop
)
2082 // FIXME: symbol table
2084 SID sid
= UNKNOWN_SID
;
2085 char buf
[MAX_LENGTH_OF_LONG
+ 1 + 1] = {0}, *end
= buf
+ sizeof(buf
) - 1, *ptr
;
2087 php_ion_unserialize_field_name_ex(ser
, &name
, &sid
);
2090 switch (name
.length
) {
2092 ptr
= zend_print_long_to_buf(end
, sid
);
2094 *key
= zend_string_init(ptr
, end
- ptr
, 0);
2097 *key
= zend_one_char_string
[*name
.value
];
2101 *key
= zend_string_init_interned((char *) name
.value
, name
.length
, 0);
2103 *key
= zend_string_from_ion(&name
);
2109 static void php_ion_unserialize_props(php_ion_unserializer
*ser
, zval
*return_value
)
2111 zend_hash_next_index_insert(ser
->ids
, return_value
);
2113 ION_CHECK(ion_reader_step_in(ser
->reader
));
2117 ION_CHECK(ion_reader_next(ser
->reader
, &typ
));
2119 if (typ
== tid_EOF
) {
2124 php_ion_unserialize_field_name(ser
, &key
, true);
2128 php_ion_unserialize_zval(ser
, &zvalue
, &typ
);
2129 ION_CATCH(zend_string_release(key
));
2131 zend_class_entry
*ce
= Z_OBJCE_P(return_value
);
2132 if (ser
->annotations
.object_prop
&& ser
->annotations
.property_class
->val
[0] != '*') {
2133 ce
= zend_lookup_class(ser
->annotations
.property_class
);
2135 zend_update_property_ex(ce
, Z_OBJ_P(return_value
), key
, &zvalue
);
2136 zval_ptr_dtor(&zvalue
);
2137 zend_string_release(key
);
2140 ION_CHECK(ion_reader_step_out(ser
->reader
));
2144 * @link https://amzn.github.io/ion-docs/docs/spec.html#struct
2145 * When two fields in the same struct have the same name [...] Implementations must preserve all such fields,
2146 * i.e., they may not discard fields that have repeated names. However, implementations may reorder fields
2147 * (the binary format identifies structs that are sorted by symbolID), so certain operations may lead to
2148 * nondeterministic behavior.
2150 LOCAL
void php_ion_unserialize_hash(php_ion_unserializer
*ser
, zval
*return_value
)
2152 zend_hash_next_index_insert(ser
->ids
, return_value
);
2154 ION_CHECK(ion_reader_step_in(ser
->reader
));
2158 ION_CHECK(ion_reader_next(ser
->reader
, &typ
));
2160 if (typ
== tid_EOF
) {
2165 php_ion_unserialize_field_name(ser
, &key
, false);
2169 php_ion_unserialize_zval(ser
, &zvalue
, &typ
);
2170 ION_CATCH(zend_string_release(key
));
2172 // FIXME:: too naive; b0rked if the previous value is an array
2173 if (zend_symtable_exists(HASH_OF(return_value
), key
)) {
2174 zval tmp
, *prev
= zend_hash_find(HASH_OF(return_value
), key
);
2175 if (Z_TYPE_P(prev
) != IS_ARRAY
) {
2177 Z_TRY_ADDREF_P(prev
);
2178 zend_hash_next_index_insert(Z_ARRVAL(tmp
), prev
);
2179 prev
= zend_hash_update(HASH_OF(return_value
), key
, &tmp
);
2181 zend_hash_next_index_insert(Z_ARRVAL_P(prev
), &zvalue
);
2183 zend_symtable_update(HASH_OF(return_value
), key
, &zvalue
);
2185 zend_string_release(key
);
2188 ION_CHECK(ion_reader_step_out(ser
->reader
));
2191 LOCAL
void verify_unserializer(php_ion_unserializer
*ser
, zend_object
*zobject
, zend_function
**fn
)
2193 switch (ser
->annotations
.object_type
) {
2199 if (!can_call_custom_unserialize(ser
, zobject
, fn
)) {
2200 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_TOKEN
,
2201 "Could not find custom serializer method of %s", ser
->annotations
.object_class
->val
);
2206 if (!can_call_magic_unserialize(ser
, zobject
->ce
)) {
2207 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_TOKEN
,
2208 "Could not find method %s::__unserialize()", ser
->annotations
.object_class
->val
);
2210 *fn
= zobject
->ce
->__unserialize
;
2214 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_TOKEN
,
2215 "Invalid object type %c", ser
->annotations
.object_type
);
2219 LOCAL
void php_ion_unserialize_object(php_ion_unserializer
*ser
, zval
*return_value
)
2221 // backup possible backref to array returned by magic/custom __serialize()
2222 zval
*input
= zend_hash_next_index_insert(ser
->tmp
, return_value
);
2223 ZVAL_NULL(return_value
);
2224 php_ion_unserialize_class(ser
, return_value
);
2227 zend_function
*fn
= NULL
;
2228 zend_object
*zobject
= Z_OBJ_P(return_value
);
2229 verify_unserializer(ser
, zobject
, &fn
);
2234 php_ion_unserialize_props(ser
, return_value
);
2239 if (Z_TYPE_P(input
) != IS_ARRAY
) {
2240 zval_ptr_dtor(input
);
2242 zend_hash_real_init_mixed(Z_ARRVAL_P(input
));
2243 php_ion_unserialize_hash(ser
, input
);
2248 zend_call_method_with_1_params(zobject
, zobject
->ce
, &fn
, "", &rv
, input
);
2252 LOCAL
void php_ion_unserialize_struct(php_ion_unserializer
*ser
, zval
*return_value
)
2254 if (ser
->annotations
.object_class
) {
2255 switch (ser
->annotations
.object_type
) {
2257 php_ion_unserialize_object_iface(ser
, return_value
);
2260 php_ion_unserialize_object_enum(ser
, return_value
);
2263 php_ion_unserialize_object(ser
, return_value
);
2265 } else if (!ser
->annotations
.object_type
) {
2266 bool is_shared_symtab
= ser
->annotations
.shared_symtab
;
2267 array_init(return_value
);
2268 php_ion_unserialize_hash(ser
, return_value
);
2269 if (is_shared_symtab
) {
2271 object_init_ex(&zobj
, ce_Symbol_Table_Shared
);
2272 zend_call_known_function(Z_OBJCE(zobj
)->constructor
, Z_OBJ(zobj
), Z_OBJCE(zobj
), NULL
, 0, NULL
, Z_ARRVAL_P(return_value
));
2273 zval_ptr_dtor(return_value
);
2274 RETURN_COPY_VALUE(&zobj
);
2276 } else if (ser
->annotations
.object_type
== 'o') {
2277 object_init(return_value
);
2278 php_ion_unserialize_hash(ser
, return_value
);
2280 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_TOKEN
,
2281 "Invalid object annotation %c::", ser
->annotations
.object_type
);
2285 LOCAL
void php_ion_unserialize_list(php_ion_unserializer
*ser
, zval
*return_value
)
2287 ION_CHECK(ion_reader_step_in(ser
->reader
));
2288 array_init(return_value
);
2289 zend_hash_next_index_insert(ser
->ids
, return_value
);
2293 ION_CHECK(ion_reader_next(ser
->reader
, &typ
));
2295 if (typ
== tid_EOF
) {
2300 php_ion_unserialize_zval(ser
, &next
, &typ
);
2303 zend_hash_next_index_insert(Z_ARRVAL_P(return_value
), &next
);
2306 ION_CHECK(ion_reader_step_out(ser
->reader
));
2309 LOCAL
void php_ion_reader_read_lob(ION_READER
*reader
, zval
*return_value
)
2311 zend_string
*zstr
= zend_string_alloc(0x1000, 0);
2314 iERR err
= ion_reader_read_lob_bytes(reader
, (BYTE
*) zstr
->val
, (SIZE
) zstr
->len
, &read
);
2315 if (err
== IERR_BUFFER_TOO_SMALL
) {
2316 zstr
= zend_string_extend(zstr
, zstr
->len
<< 2, 0);
2319 ION_CHECK(err
, zend_string_release(zstr
));
2320 if (zstr
->len
> read
) {
2321 zstr
->val
[read
] = 0;
2322 zstr
= zend_string_truncate(zstr
, read
, 0);
2327 LOCAL
void php_ion_reader_read_timestamp(ION_READER
*reader
, ION_READER_OPTIONS
*opt
, zval
*return_value
)
2330 ION_CHECK(ion_reader_read_timestamp(reader
, &ts
));
2332 object_init_ex(return_value
, ce_Timestamp
);
2333 php_ion_timestamp
*ts_obj
= php_ion_obj(timestamp
, Z_OBJ_P(return_value
));
2335 zend_string
*fmt
= NULL
;
2336 decContext
*ctx
= opt
? opt
->decimal_context
: NULL
;
2337 ts_obj
->time
= php_time_from_ion(&ts
, ctx
, &fmt
);
2338 php_ion_timestamp_ctor(ts_obj
, ts
.precision
, fmt
, NULL
, NULL
);
2339 zend_string_release(fmt
);
2344 LOCAL
void php_ion_reader_read_int(ION_READER
*reader
, zval
*return_value
)
2346 ION_INT
*num
= NULL
;
2347 ION_CHECK(ion_int_alloc(reader
, &num
));
2348 ION_CHECK(ion_reader_read_ion_int(reader
, num
));
2350 // TODO: SIZEOF_ZEND_LONG == 4
2352 iERR err
= ion_int_to_int64(num
, &i64
);
2358 case IERR_NUMERIC_OVERFLOW
: ;
2360 ION_CHECK(ion_int_char_length(num
, &max
));
2361 zend_string
*zs
= zend_string_alloc(max
, 0);
2363 err
= ion_int_to_char(num
, (BYTE
*) zs
->val
, max
, &len
);
2364 zs
->val
[zs
->len
= len
] = 0;
2375 LOCAL
void php_ion_unserialize_backref(php_ion_unserializer
*ser
, zval
*return_value
)
2377 zval
*backref
= zend_hash_index_find(ser
->ids
, Z_LVAL_P(return_value
));
2380 ZVAL_COPY_VALUE(return_value
, backref
);
2381 zend_hash_next_index_insert(ser
->addref
, return_value
);
2383 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INTERNAL_ERROR
,
2384 "Could not find back reference " ZEND_LONG_FMT
, Z_LVAL_P(return_value
));
2388 LOCAL
void php_ion_unserialize_annotations(php_ion_unserializer
*ser
)
2390 memset(&ser
->annotations
, 0, sizeof(ser
->annotations
));
2393 ION_CHECK(ion_reader_get_annotation_count(ser
->reader
, &ann_cnt
));
2394 for (int32_t i
= 0; i
< ann_cnt
; ++i
) {
2396 ION_CHECK(ion_reader_get_an_annotation(ser
->reader
, i
, &ann_str
));
2398 if (ann_str
.length
!= 1) {
2399 if (ION_STRING_EQUALS(&ann_str
, &ION_SYMBOL_SHARED_SYMBOL_TABLE_STRING
)) {
2400 ser
->annotations
.shared_symtab
= true;
2405 switch (*ann_str
.value
) {
2407 if (ser
->annotations
.makeref
) {
2408 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_SYNTAX
,
2409 "Invalid multiple reference annotations");
2412 ser
->annotations
.makeref
= true;
2416 if (ser
->annotations
.backref
) {
2417 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_SYNTAX
,
2418 "Invalid multiple back reference annotations");
2421 ser
->annotations
.backref
= true;
2425 if (ser
->annotations
.object_prop
) {
2426 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_SYNTAX
,
2427 "Invalid multiple object property annotations");
2430 ser
->annotations
.object_prop
= true;
2432 ION_STRING prop_class
;
2433 ION_CHECK(ion_reader_get_an_annotation(ser
->reader
, ++i
, &prop_class
));
2434 ser
->annotations
.property_class
= zend_string_from_ion(&prop_class
);
2437 ZVAL_STR(&zptmp
, ser
->annotations
.property_class
);
2438 zend_hash_next_index_insert(ser
->tmp
, &zptmp
);
2447 if (ser
->annotations
.object_type
) {
2448 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_SYNTAX
,
2449 "Invalid multiple object type annotations: %c::%c",
2450 ser
->annotations
.object_type
, *ann_str
.value
);
2453 if ('o' != (ser
->annotations
.object_type
= *ann_str
.value
)) {
2454 ION_STRING class_name
;
2455 ION_CHECK(ion_reader_get_an_annotation(ser
->reader
, ++i
, &class_name
));
2456 ser
->annotations
.object_class
= zend_string_from_ion(&class_name
);
2459 ZVAL_STR(&zctmp
, ser
->annotations
.object_class
);
2460 zend_hash_next_index_insert(ser
->tmp
, &zctmp
);
2466 if (ser
->annotations
.object_type
&& ser
->annotations
.object_type
!= 'o' && !ser
->annotations
.object_class
) {
2467 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_SYNTAX
,
2468 "Invalid object annotation without class name: %c::", ser
->annotations
.object_type
);
2471 if (ser
->annotations
.object_type
== 'o' && ser
->annotations
.object_class
) {
2472 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_SYNTAX
,
2473 "Invalid object annotation with class name: o::%s", ser
->annotations
.object_class
->val
);
2479 LOCAL
void php_ion_unserialize_zval(php_ion_unserializer
*ser
, zval
*return_value
, ION_TYPE
*typ
)
2482 memcpy(&ser
->type
, typ
, sizeof(ser
->type
)); // NOLINT
2485 ION_CHECK(ion_reader_next(ser
->reader
, typ
));
2488 php_ion_unserialize_annotations(ser
);
2491 if (ser
->annotations
.makeref
) {
2492 ZVAL_MAKE_REF(return_value
);
2493 zend_hash_next_index_insert(ser
->ids
, return_value
);
2494 ZVAL_DEREF(return_value
);
2497 if (ION_TYPE_INT(*typ
) > 0) {
2499 ION_CHECK(ion_reader_is_null(ser
->reader
, &is_null
));
2505 switch (ION_TYPE_INT(*typ
)) {
2507 ION_CHECK(ion_reader_read_null(ser
->reader
, typ
));
2510 case tid_BOOL_INT
: ;
2512 ION_CHECK(ion_reader_read_bool(ser
->reader
, &bval
));
2516 php_ion_reader_read_int(ser
->reader
, return_value
);
2517 if (ser
->annotations
.backref
) {
2519 php_ion_unserialize_backref(ser
, return_value
);
2521 if (ser
->annotations
.object_type
) {
2522 if (!ser
->annotations
.backref
) {
2523 zend_throw_exception_ex(spl_ce_RuntimeException
, IERR_INVALID_SYNTAX
,
2524 "Invalid object type annotation: %c::" ZEND_LONG_FMT
,
2525 ser
->annotations
.object_type
, Z_LVAL_P(return_value
));
2528 goto unserialize_struct
;
2532 case tid_FLOAT_INT
: ;
2534 ION_CHECK(ion_reader_read_double(ser
->reader
, &d
));
2537 case tid_DECIMAL_INT
:
2538 object_init_ex(return_value
, ce_Decimal
);
2539 php_ion_decimal
*dec
= php_ion_obj(decimal
, Z_OBJ_P(return_value
));
2540 ION_CHECK(ion_reader_read_ion_decimal(ser
->reader
, &dec
->dec
));
2541 php_ion_decimal_ctor(dec
);
2542 zend_hash_next_index_insert(ser
->ids
, return_value
);
2545 case tid_TIMESTAMP_INT
:
2546 php_ion_reader_read_timestamp(ser
->reader
, ser
->options
, return_value
);
2547 zend_hash_next_index_insert(ser
->ids
, return_value
);
2550 case tid_SYMBOL_INT
: ;
2552 ION_CHECK(ion_reader_read_ion_symbol(ser
->reader
, &sym
));
2553 php_ion_symbol_zval(&sym
, return_value
);
2554 if (ser
->annotations
.object_type
) {
2555 goto unserialize_struct
;
2557 zend_hash_next_index_insert(ser
->ids
, return_value
);
2560 case tid_STRING_INT
: ;
2562 ION_CHECK(ion_reader_read_string(ser
->reader
, &str
));
2563 RETVAL_STRINGL((char *) str
.value
, str
.length
);
2564 if (ser
->annotations
.object_type
) {
2565 goto unserialize_struct
;
2567 zend_hash_next_index_insert(ser
->ids
, return_value
);
2572 php_ion_reader_read_lob(ser
->reader
, return_value
);
2573 if (ser
->annotations
.object_type
) {
2574 goto unserialize_struct
;
2576 zend_hash_next_index_insert(ser
->ids
, return_value
);
2580 case tid_SEXP_INT
: // FIXME
2581 php_ion_unserialize_list(ser
, return_value
);
2582 if (!ser
->annotations
.object_type
) {
2587 case tid_STRUCT_INT
:
2588 unserialize_struct
: ;
2589 php_ion_unserialize_struct(ser
, return_value
);
2596 case tid_DATAGRAM_INT
:
2597 ZEND_ASSERT(!"datagram");
2603 #define php_ion_unserializer_php_copy(o,n)
2604 php_ion_decl(unserializer_php
, Unserializer_PHP
);
2605 #define clone_ion_Unserializer_PHP NULL
2607 LOCAL
void php_ion_unserialize_ex(php_ion_unserializer
*ser
, zval
*return_value
)
2609 if (ser
->multi_seq
) {
2610 array_init(return_value
);
2616 php_ion_globals_unserializer_step();
2617 php_ion_unserialize_zval(ser
, &tmp
, NULL
);
2618 php_ion_globals_unserializer_exit();
2619 ION_CATCH(zval_ptr_dtor(&tmp
));
2621 if (!ser
->multi_seq
) {
2622 RETURN_COPY_VALUE(&tmp
);
2623 } else if (ser
->type
!= tid_EOF
) {
2624 zend_hash_next_index_insert(Z_ARRVAL_P(return_value
), &tmp
);
2626 } while (ser
->type
!= tid_EOF
);
2629 void php_ion_unserialize(php_ion_unserializer
*ser
, zval
*zdata
, zval
*return_value
)
2631 zend_object
*zo_opt
= NULL
, *zo_ser
= NULL
;
2634 zo_ser
= create_ion_Unserializer_PHP(NULL
);
2635 php_ion_unserializer_php
*o_ser
= php_ion_obj(unserializer_php
, zo_ser
);
2637 o_ser
->unserializer
.call_magic
= true;
2638 php_ion_unserializer_php_ctor(o_ser
);
2640 ser
= &o_ser
->unserializer
;
2643 zend_object
*zo_reader
;
2644 php_ion_reader
*reader
;
2647 if (Z_TYPE_P(zdata
) == IS_RESOURCE
) {
2648 zo_reader
= create_ion_Reader_Reader(ce_Reader_Stream_Reader
);
2649 reader
= php_ion_obj(reader
, zo_reader
);
2650 reader
->type
= STREAM_READER
;
2651 php_stream_from_zval_no_verify(reader
->stream
.ptr
, zdata
);
2652 } else if (Z_TYPE_P(zdata
) <= IS_STRING
) {
2653 zo_reader
= create_ion_Reader_Reader(ce_Reader_Buffer_Reader
);
2654 reader
= php_ion_obj(reader
, zo_reader
);
2655 reader
->type
= BUFFER_READER
;
2656 reader
->buffer
= zval_get_string(zdata
);
2658 zend_throw_exception_ex(spl_ce_InvalidArgumentException
, IERR_INVALID_ARG
,
2659 "Invalid source to unserialize: expected string or resource, got %s",
2660 zend_zval_type_name(zdata
));
2662 OBJ_RELEASE(zo_ser
);
2668 zo_opt
= reader
->opt
= php_ion_reader_options_new();
2669 php_ion_obj(reader_options
, reader
->opt
)->opt
= *ser
->options
;
2672 php_ion_reader_ctor(reader
);
2673 ser
->reader
= reader
->reader
;
2675 if (!EG(exception
)) {
2676 php_ion_unserialize_ex(ser
, return_value
);
2679 OBJ_RELEASE(zo_reader
);
2681 OBJ_RELEASE(zo_opt
);
2684 OBJ_RELEASE(zo_ser
);