X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=ion_private.h;h=57aaa6f9f886787e20b80036149482e14b89a2c2;hb=d31afba7b6dc66b25f6070b5fc5195e4a1c8a85c;hp=98a3291d0a5d51373d610b25141b4b6706fcda37;hpb=276e3951449b3c4a77ad843372de4e3b1f80b6e2;p=awesomized%2Fext-ion diff --git a/ion_private.h b/ion_private.h index 98a3291..57aaa6f 100644 --- a/ion_private.h +++ b/ion_private.h @@ -10,28 +10,178 @@ +--------------------------------------------------------------------+ */ -#include "ionc/ion.h" - #include "php.h" #include "ext/date/php_date.h" -typedef struct php_ion_global_serializer php_ion_global_serializer; -typedef struct php_ion_global_unserializer php_ion_global_unserializer; +#define DECNUMDIGITS 34 /* DECQUAD_Pmax */ +#include "ionc/ion.h" + +#define PHP_ION_SYMBOL_TABLE_VERSION 1 +#define PHP_ION_SYMBOL(c, s) { \ + { \ + 0, \ + { sizeof(s)-1, (BYTE *) s }, \ + { { 0, NULL }, 0 }, \ + 0 \ + }, \ + { sizeof(c)-1, (BYTE *) c } \ +}, + +typedef struct php_ion_global_symbol { + ION_SYMBOL s; + ION_STRING e; +} php_ion_global_symbol; + +static php_ion_global_symbol g_sym_tab_php_sym[] = { +#define PHP_ION_SYMBOL_PHP (g_sym_tab_php_sym[0]).s + PHP_ION_SYMBOL("PHP", "PHP") +#define PHP_ION_SYMBOL_REFERENCE (g_sym_tab_php_sym[1]).s + PHP_ION_SYMBOL("Reference", "R") +#define PHP_ION_SYMBOL_BACKREF (g_sym_tab_php_sym[2]).s + PHP_ION_SYMBOL("Backref", "r") +#define PHP_ION_SYMBOL_PROPERTY (g_sym_tab_php_sym[3]).s + PHP_ION_SYMBOL("Property", "p") +#define PHP_ION_SYMBOL_CLASS_OBJECT (g_sym_tab_php_sym[4]).s + PHP_ION_SYMBOL("ClassObject", "c") +#define PHP_ION_SYMBOL_CUSTOM_OBJECT (g_sym_tab_php_sym[5]).s + PHP_ION_SYMBOL("CustomObject", "C") +#define PHP_ION_SYMBOL_OBJECT (g_sym_tab_php_sym[6]).s + PHP_ION_SYMBOL("Object", "o") +#define PHP_ION_SYMBOL_MAGIC_OBJECT (g_sym_tab_php_sym[7]).s + PHP_ION_SYMBOL("MagicObject", "O") +#define PHP_ION_SYMBOL_SERIALIZEABLE (g_sym_tab_php_sym[8]).s + PHP_ION_SYMBOL("Serializable", "S") +#define PHP_ION_SYMBOL_ENUM (g_sym_tab_php_sym[9]).s + PHP_ION_SYMBOL("Enum", "E") + {{0}, {0}} +}; +#undef PHP_ION_SYMBOL + +static ION_SYMBOL_TABLE *g_sym_tab_php; + +/* [SID => STRING, STRING => SID] */ +static HashTable g_sym_hash; +/* [enum_case_name => SID] */ +static HashTable g_sym_map; + +#define ION_SYS_SYMBOL_SYMBOL_TABLE \ + ION_SYS_SYMBOL_ION_SYMBOL_TABLE +#define g_sym_add(enum_name, c_name) do { \ + g_sym_hash_add(ION_SYS_SID_ ## c_name, ION_SYS_SYMBOL_ ## c_name, ION_SYS_STRLEN_ ## c_name); \ + g_sym_map_add(ION_SYS_SID_ ## c_name, enum_name, sizeof(enum_name)-1); \ +} while (0) + +static inline void g_sym_hash_add(int sid, const char *str, size_t len) +{ + zval zl, zs; + ZVAL_LONG(&zl, sid); + ZVAL_STR(&zs, zend_string_init_interned(str, len ,1)); + zend_hash_add(&g_sym_hash, Z_STR(zs), &zl); + zend_hash_index_add(&g_sym_hash, sid, &zs); +} + +static inline void g_sym_map_add(int sid, const char *str, size_t len) +{ + zval zv; + ZVAL_LONG(&zv, sid); + zend_hash_str_add(&g_sym_map, str, len, &zv); +} + +static inline int g_sym_init(void) +{ + zend_hash_init(&g_sym_hash, 0, NULL, NULL, 1); + zend_hash_init(&g_sym_map, 0, NULL, NULL, 1); + + g_sym_hash_add(0, ZEND_STRL("")); + g_sym_map_add(0, ZEND_STRL("")); + g_sym_add("Ion", ION); + g_sym_add("Ivm_1_0", IVM); + g_sym_add("IonSymbolTable", SYMBOL_TABLE); + g_sym_add("Name", NAME); + g_sym_add("Version", VERSION); + g_sym_add("Imports", IMPORTS); + g_sym_add("Symbols", SYMBOLS); + g_sym_add("MaxId", MAX_ID); + g_sym_add("SharedSymbolTable", SHARED_SYMBOL_TABLE); + + int sys_max_id = ION_SYS_SID_SHARED_SYMBOL_TABLE; + + if (IERR_OK != ion_symbol_table_open_with_type(&g_sym_tab_php, NULL, ist_SHARED)) { + return FAILURE; + } + php_ion_global_symbol *ptr = g_sym_tab_php_sym; + ion_symbol_table_set_version(g_sym_tab_php, PHP_ION_SYMBOL_TABLE_VERSION); + ion_symbol_table_set_name(g_sym_tab_php, &ptr->s.value); + while (ptr->e.value) { + ion_symbol_table_add_symbol(g_sym_tab_php, &ptr->s.value, &ptr->s.sid); + g_sym_hash_add(sys_max_id + ptr->s.sid, (const char *) ptr->s.value.value, ptr->s.value.length); + g_sym_map_add(sys_max_id + ptr->s.sid, (const char *) ptr->e.value, ptr->e.length); + ++ptr; + } + ion_symbol_table_lock(g_sym_tab_php); + return SUCCESS; +} + +typedef struct php_ion_serializer { + ION_WRITER *writer; + ION_WRITER_OPTIONS *options; + smart_str *buffer; + + zend_string *call_custom; + zend_bool call_magic; + zend_bool multi_seq; + + uint32_t level; + HashTable *ids; + HashTable *tmp; +} php_ion_serializer; + +typedef struct php_ion_annotaions { + uint8_t shared_symtab:1; + uint8_t backref:1; + uint8_t makeref:1; + uint8_t object_prop:1; + uint8_t object_type; + zend_string *object_class; + zend_string *property_class; +} php_ion_annotations; + +typedef struct php_ion_unserializer { + ION_READER *reader; + ION_READER_OPTIONS *options; + ION_TYPE type; + + zend_string *call_custom; + zend_bool call_magic; + zend_bool multi_seq; + + uint32_t level; + HashTable *ids; + HashTable *tmp; + HashTable *addref; + + php_ion_annotations annotations; +} php_ion_unserializer; ZEND_BEGIN_MODULE_GLOBALS(ion) - struct php_ion_global_serializer { - HashTable ids; - HashTable tmp; - uint64_t level; - } serializer; + struct { + decContext ctx; + ION_DECIMAL zend_max; + ION_DECIMAL zend_min; + } decimal; + + struct { + HashTable cache; + } symbol; + + php_ion_serializer serializer; + php_ion_unserializer unserializer; - struct php_ion_global_unserializer { - HashTable ids; - HashTable tmp; - HashTable addref; - uint64_t level; - } unserializer; + struct { + HashTable serializer[2]; + HashTable unserializer[3]; + } _ht; ZEND_END_MODULE_GLOBALS(ion); @@ -43,41 +193,92 @@ ZEND_END_MODULE_GLOBALS(ion); ZEND_DECLARE_MODULE_GLOBALS(ion); +static zend_class_entry + *ce_Catalog, + *ce_Decimal, + *ce_Decimal_Context, + *ce_Decimal_Context_Rounding, + *ce_LOB, + *ce_Reader, + *ce_Reader_Options, + *ce_Reader_Reader, + *ce_Reader_Buffer, + *ce_Reader_Stream, + *ce_Reader_Buffer_Reader, + *ce_Reader_Stream_Reader, + *ce_Serializer, + *ce_Serializer_PHP, + *ce_Symbol, + *ce_Symbol_ImportLocation, + *ce_Symbol_Enum, + *ce_Symbol_Table, + *ce_Symbol_Table_Local, + *ce_Symbol_Table_PHP, + *ce_Symbol_Table_Shared, + *ce_Symbol_Table_System, + *ce_Timestamp, + *ce_Timestamp_Precision, + *ce_Type, + *ce_Unserializer, + *ce_Unserializer_PHP, + *ce_Writer, + *ce_Writer_Options, + *ce_Writer_Buffer, + *ce_Writer_Buffer_Writer, + *ce_Writer_Stream, + *ce_Writer_Stream_Writer, + *ce_Writer_Writer + ; + +static inline void php_ion_globals_symbols_init(void) +{ + zend_hash_init(&php_ion_globals.symbol.cache, 0, NULL, ZVAL_PTR_DTOR, 0); +} + +static inline void php_ion_globals_symbols_dtor(void) +{ + zend_hash_destroy(&php_ion_globals.symbol.cache); +} + static inline void php_ion_globals_serializer_init(void) { - php_ion_global_serializer *s = &php_ion_globals.serializer; + php_ion_serializer *s = &php_ion_globals.serializer; + HashTable *h = php_ion_globals._ht.serializer; - zend_hash_init(&s->tmp, 0, NULL, ZVAL_PTR_DTOR, 0); - zend_hash_init(&s->ids, 0, NULL, NULL, 0); + zend_hash_init(s->tmp = &h[0], 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(s->ids = &h[1], 0, NULL, NULL, 0); } -static inline void php_ion_globals_serializer_step(void) +static inline uint32_t php_ion_globals_serializer_step(void) { - php_ion_global_serializer *s = &php_ion_globals.serializer; + php_ion_serializer *s = &php_ion_globals.serializer; + uint32_t level; - if (!s->level++) { - zend_hash_clean(&s->ids); - zend_hash_clean(&s->tmp); + if (!(level = s->level++)) { + zend_hash_clean(s->ids); + zend_hash_clean(s->tmp); } + return level; } -static inline void php_ion_globals_serializer_exit(void) +static inline uint32_t php_ion_globals_serializer_exit(void) { - php_ion_global_serializer *s = &php_ion_globals.serializer; + php_ion_serializer *s = &php_ion_globals.serializer; ZEND_ASSERT(s->level); if (!--s->level) { - zend_hash_clean(&s->ids); - zend_hash_clean(&s->tmp); + zend_hash_clean(s->ids); + zend_hash_clean(s->tmp); } + return s->level; } static inline void php_ion_globals_serializer_dtor(void) { - php_ion_global_serializer *s = &php_ion_globals.serializer; + php_ion_serializer *s = &php_ion_globals.serializer; - zend_hash_destroy(&s->tmp); - zend_hash_destroy(&s->ids); + zend_hash_destroy(s->tmp); + zend_hash_destroy(s->ids); } void ZVAL_ADDREF(zval *zv) @@ -90,129 +291,87 @@ void ZVAL_ADDREF(zval *zv) } static inline void php_ion_globals_unserializer_init(void) { - php_ion_global_unserializer *s = &php_ion_globals.unserializer; - - zend_hash_init(&s->tmp, 0, NULL, ZVAL_PTR_DTOR, 0); - zend_hash_init(&s->ids, 0, NULL, NULL, 0); - zend_hash_init(&s->addref, 0, NULL, ZVAL_ADDREF, 0); + php_ion_unserializer *s = &php_ion_globals.unserializer; + HashTable *h = php_ion_globals._ht.unserializer; + zend_hash_init(s->tmp = &h[0], 0, NULL, ZVAL_PTR_DTOR, 0); + zend_hash_init(s->ids = &h[1], 0, NULL, NULL, 0); + zend_hash_init(s->addref = &h[2], 0, NULL, ZVAL_ADDREF, 0); } static inline void php_ion_globals_unserializer_step(void) { - php_ion_global_unserializer *s = &php_ion_globals.unserializer; + php_ion_unserializer *s = &php_ion_globals.unserializer; if (!s->level++) { - zend_hash_clean(&s->addref); - zend_hash_clean(&s->ids); - zend_hash_clean(&s->tmp); + zend_hash_clean(s->addref); + zend_hash_clean(s->ids); + zend_hash_clean(s->tmp); } } static inline void php_ion_globals_unserializer_exit(void) { - php_ion_global_unserializer *s = &php_ion_globals.unserializer; + php_ion_unserializer *s = &php_ion_globals.unserializer; ZEND_ASSERT(s->level); if (!--s->level) { - zend_hash_clean(&s->addref); - zend_hash_clean(&s->ids); - zend_hash_clean(&s->tmp); + zend_hash_clean(s->addref); + zend_hash_clean(s->ids); + zend_hash_clean(s->tmp); } } static inline void php_ion_globals_unserializer_dtor(void) { - php_ion_global_unserializer *s = &php_ion_globals.unserializer; + php_ion_unserializer *s = &php_ion_globals.unserializer; - zend_hash_destroy(&s->addref); - zend_hash_destroy(&s->ids); - zend_hash_destroy(&s->tmp); + zend_hash_destroy(s->addref); + zend_hash_destroy(s->ids); + zend_hash_destroy(s->tmp); } -static zend_class_entry - *ce_Annotation, - *ce_Catalog, - *ce_Collection, - *ce_Decimal, - *ce_Decimal_Context, - *ce_PHP_Serializer, - *ce_PHP_Unserializer, - *ce_Reader, - *ce_Reader_Options, - *ce_Reader_Reader, - *ce_Reader_Buffer, - *ce_Reader_Stream, - *ce_Reader_Buffer_Reader, - *ce_Reader_Stream_Reader, - *ce_Symbol, - *ce_Symbol_ImportLocation, - *ce_Symbol_System, - *ce_Symbol_System_SID, - *ce_Symbol_Table, - *ce_Timestamp, - *ce_Timestamp_Precision, - *ce_Type, - *ce_Writer, - *ce_Writer_Options, - *ce_Writer_Buffer, - *ce_Writer_Buffer_Writer, - *ce_Writer_Stream, - *ce_Writer_Stream_Writer, - *ce_Writer_Writer - ; -static zend_object_handlers - oh_catalog, - oh_decimal, - oh_decimal_ctx, - oh_reader_options, - oh_reader, - oh_symbol, - oh_symbol_iloc, - oh_symbol_table, - oh_timestamp, - oh_type, - oh_writer_options, - oh_writer - ; - -#define php_ion_decl(type, name, ...) \ - static zend_object *create_ion_ ## name(zend_class_entry *ce) \ +#define php_ion_decl(type, cname, ...) \ + static zend_object_handlers oh_ ## cname; \ + static inline zend_object *create_ion_ ## cname(zend_class_entry *ce) \ { \ - if (!ce) ce = ce_ ## name; \ + if (!ce) ce = ce_ ## cname; \ php_ion_ ## type *o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce)); \ zend_object_std_init(&o->std, ce); \ object_properties_init(&o->std, ce); \ - o->std.handlers = &oh_ ## type; \ + o->std.handlers = &oh_ ## cname; \ return &o->std; \ } \ - static void free_ion_ ## name(zend_object *std) \ + static inline void free_ion_ ## cname(zend_object *std) \ { \ php_ion_ ## type *obj = php_ion_obj(type, std); \ __VA_ARGS__; \ zend_object_std_dtor(std); \ (void) obj; \ } -#define php_ion_register(type, name, ...) do { \ - ce_ ## name = register_class_ion_ ## name(__VA_ARGS__); \ - ce_ ## name ->create_object = create_ion_ ## name; \ - memcpy(&oh_ ## type, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); \ - oh_ ## type .offset = offsetof(php_ion_ ## type, std); \ - oh_ ## type .free_obj = free_ion_ ## name; \ +#define php_ion_register(type, cname, ...) do { \ + ce_ ## cname = register_class_ion_ ## cname(__VA_ARGS__); \ + ce_ ## cname ->create_object = create_ion_ ## cname; \ + memcpy(&oh_ ## cname, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); \ + oh_ ## cname .offset = offsetof(php_ion_ ## type, std); \ + oh_ ## cname .free_obj = free_ion_ ## cname; \ } while (0) #define php_ion_obj(type, obj) \ - ((php_ion_ ## type *) (obj ? ((char *)(obj) - XtOffsetOf(php_ion_ ## type, std)) : NULL)) + ((php_ion_ ## type *) ((obj) ? ((char *)(obj) - XtOffsetOf(php_ion_ ## type, std)) : NULL)) -#define ION_CHECK(err, ...) do { \ +#define ION_CHECK_RETURN(r, err, ...) do { \ iERR __err = err; \ if (__err) { \ zend_throw_exception_ex(spl_ce_RuntimeException, __err, "%s: %s", ion_error_to_str(__err), #err); \ __VA_ARGS__; \ - return; \ + return r; \ } \ } while (0) +#define ION_CHECK(err, ...) \ + ION_CHECK_RETURN(, err, __VA_ARGS__) + #define ION_CATCH(...) do { \ if (EG(exception)) { \ __VA_ARGS__; \ @@ -220,29 +379,24 @@ static zend_object_handlers } \ } while (0) -#define PTR_CHECK(ptr, ...) do { \ +#define PTR_CHECK_RETURN(ret, ptr, ...) do { \ if (!(ptr)) { \ zend_throw_error(NULL, "Uninitialized object"); \ __VA_ARGS__; \ - return; \ + return ret; \ } \ } while (0) +#define PTR_CHECK(ptr, ...) PTR_CHECK_RETURN(, ptr, __VA_ARGS__) -#define OBJ_CHECK(obj) do { \ - PTR_CHECK(obj); \ - PTR_CHECK(*((void **)obj)); \ +#define OBJ_CHECK_RETURN(ret, obj, ...) do { \ + PTR_CHECK_RETURN(ret, obj, __VA_ARGS__); \ + PTR_CHECK_RETURN(ret, *((void **)obj), __VA_ARGS__); \ } while (0) - -static inline ION_STRING *ion_string_from_cstr(ION_STRING *is, const char *s, size_t l) -{ - is->length = l; - is->value = (BYTE *) s; - return is; -} +#define OBJ_CHECK(obj, ...) OBJ_CHECK_RETURN(, obj, __VA_ARGS__) static inline ION_STRING *ion_string_from_zend(ION_STRING *is, const zend_string *zs) { - is->length = zs ? zs->len : 0; + is->length = zs ? (SIZE) zs->len : 0; is->value = (BYTE *) (zs ? zs->val : NULL); return is; } @@ -259,11 +413,6 @@ static inline void update_property_obj(zend_object *obj, const char *n, size_t l zend_update_property(obj->ce, obj, n, l, &zobj); } -typedef struct php_ion_type { - ION_TYPE typ; - zend_object std; -} php_ion_type; - #define RETURN_IONTYPE(typ) do { \ zend_object *__zo = php_ion_type_fetch(typ); \ if (UNEXPECTED(!__zo)) { \ @@ -284,6 +433,11 @@ static inline zend_object *php_ion_type_fetch(ION_TYPE typ) return zend_enum_get_case(ce_Type, Z_STR_P(ztype)); } +static inline ION_TYPE ion_type_from_enum(zend_object *zo) +{ + return (ION_TYPE) Z_LVAL_P(zend_enum_fetch_case_value(zo)); +} + typedef struct php_ion_symbol_iloc { ION_SYMBOL_IMPORT_LOCATION loc; zend_string *name; @@ -302,12 +456,35 @@ static inline void php_ion_symbol_iloc_dtor(php_ion_symbol_iloc *obj) zend_string_release(obj->name); } +php_ion_decl(symbol_iloc, Symbol_ImportLocation, php_ion_symbol_iloc_dtor(obj)); + typedef struct php_ion_symbol { ION_SYMBOL sym; zend_string *value; zend_object *iloc, std; } php_ion_symbol; +static inline int php_ion_symbol_zval_compare(zval *zv1, zval *zv2) { + zend_string *zs1 = zval_get_string(zv1); + zend_string *zs2 = zval_get_string(zv2); + + if (EG(exception)) { + return 0; + } + + int result; + if (zs1->len > zs2->len) { + result = 1; + } else if (zs2->len > zs1->len) { + result = -1; + } else { + result = memcmp(zs1->val, zs2->val, zs1->len); + } + zend_string_release(zs1); + zend_string_release(zs2); + return result; +} + static inline void php_ion_symbol_ctor(php_ion_symbol *obj) { zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("sid"), @@ -353,44 +530,167 @@ static inline void php_ion_symbol_zval(ION_SYMBOL *sym_ptr, zval *return_value) } php_ion_symbol_ctor(sym); + + if (!ION_SYMBOL_IMPORT_LOCATION_IS_NULL(sym_ptr)) { + GC_DELREF(sym->iloc); + } } +static inline zval *php_ion_global_symbol_fetch_by_enum(zend_string *name) +{ + zval *zgs = zend_hash_find(&php_ion_globals.symbol.cache, name); + if (!zgs) { + zval *zid = zend_hash_find(&g_sym_map, name); + if (zid) { + zval *zss = zend_hash_index_find(&g_sym_hash, Z_LVAL_P(zid)); + if (zss) { + zval zsym; + object_init_ex(&zsym, ce_Symbol); + php_ion_symbol *sym = php_ion_obj(symbol, Z_OBJ(zsym)); + sym->sym.sid = Z_LVAL_P(zid); + sym->value = zval_get_string(zss); + php_ion_symbol_ctor(sym); + zgs = zend_hash_add(&php_ion_globals.symbol.cache, name, &zsym); + } + } + } + return zgs; +} + +php_ion_decl(symbol, Symbol, php_ion_symbol_dtor(obj)); + typedef struct php_ion_symbol_table { + ION_SYMBOL_TABLE *tab; + int (*dtor)(ION_SYMBOL_TABLE *); zend_object std; } php_ion_symbol_table; +static inline void php_ion_symbol_table_ctor(php_ion_symbol_table *obj) +{ + OBJ_CHECK(obj); + + ION_STRING is; + if (IERR_OK == ion_symbol_table_get_name(obj->tab, &is)) { + zend_update_property_stringl(obj->std.ce, &obj->std, ZEND_STRL("name"), (char *) is.value, is.length); + } + int32_t iv; + if (IERR_OK == ion_symbol_table_get_version(obj->tab, &iv)) { + zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("version"), iv); + } +} + +static inline void php_ion_symbol_table_dtor(php_ion_symbol_table *obj) +{ + if (obj->tab) { + if (obj->dtor) { + obj->dtor(obj->tab); + } + obj->tab = NULL; + } +} + +static inline void php_ion_symbol_table_import(php_ion_symbol_table *obj, php_ion_symbol_table *import) +{ + OBJ_CHECK(obj); + OBJ_CHECK(import); + + zval tmp; + zval *zimports = zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("imports"), 0, &tmp); + if (zimports) { + zend_ulong idx = (uintptr_t) &import->std.gc; + if (!zend_hash_index_exists(Z_ARRVAL_P(zimports), idx)) { + ION_CHECK(ion_symbol_table_import_symbol_table(obj->tab, import->tab)); + + SEPARATE_ARRAY(zimports); + GC_ADDREF(&import->std); + add_index_object(zimports, idx, &import->std); + zend_update_property(obj->std.ce, &obj->std, ZEND_STRL("imports"), zimports); + } + } +} + +static inline void php_ion_symbol_table_symbol_zval(php_ion_symbol_table *obj, ION_SYMBOL *sym, zval *return_value) +{ + zval tmp; + zval *zsyms = zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("symbols"), 0, &tmp); + if (zsyms) { + zval *zsym = zend_hash_index_find(Z_ARRVAL_P(zsyms), sym->sid); + if (zsym) { + RETURN_COPY(zsym); + } + } + + php_ion_symbol_zval(sym, return_value); + + if (zsyms) { + SEPARATE_ARRAY(zsyms); + ZVAL_ADDREF(return_value); + add_index_zval(zsyms, sym->sid, return_value); + } +} + +php_ion_decl(symbol_table, Symbol_Table, php_ion_symbol_table_dtor(obj)); + typedef struct php_ion_decimal_ctx { decContext ctx; zend_object std; } php_ion_decimal_ctx; -static inline void php_ion_decimal_ctx_ctor(php_ion_decimal_ctx *obj) { - zval tmp, *zbits = zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("bits"), 1, &tmp); +#define php_ion_decimal_ctx_init_max(c, rounding) \ + php_ion_decimal_ctx_init((c), DEC_MAX_DIGITS, DEC_MAX_EMAX, DEC_MIN_EMIN, (rounding), false) +static inline void php_ion_decimal_ctx_init(decContext *ctx, + int digits, int emax, int emin, enum rounding round, zend_bool clamp) +{ + memset(ctx, 0, sizeof(*ctx)); + ctx->digits = digits; + ctx->emax = emax; + ctx->emin = emin; + ctx->round = round; + ctx->clamp = clamp; +} - int bits = 128; - if (zbits != &EG(uninitialized_zval)) { - bits = Z_LVAL_P(zbits); - } else { - zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("bits"), bits); +static inline void php_ion_decimal_ctx_ctor(php_ion_decimal_ctx *obj, zend_object *o_round) +{ + if (!obj->ctx.digits) { + php_ion_decimal_ctx_init_max(&obj->ctx, DEC_ROUND_HALF_EVEN); } - switch (bits) { - case 32: - case 64: - case 128: - decContextDefault(&obj->ctx, bits); - break; - default: - zend_throw_exception_ex(spl_ce_InvalidArgumentException, IERR_INVALID_ARG, - "Decimal context only allows 32, 64 or 128 bits"); + if (o_round) { + update_property_obj(&obj->std, ZEND_STRL("round"), o_round); + } else { + zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("round"), obj->ctx.round); } - + zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("digits"), obj->ctx.digits); + zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("eMax"), obj->ctx.emax); + zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("eMin"), obj->ctx.emin); + zend_update_property_bool(obj->std.ce, &obj->std, ZEND_STRL("clamp"), obj->ctx.clamp); } +php_ion_decl(decimal_ctx, Decimal_Context); + typedef struct php_ion_decimal { ION_DECIMAL dec; zend_object *ctx, std; } php_ion_decimal; +static inline void php_ion_decimal_from_zend_long(ION_DECIMAL *dec, decContext *ctx, zend_long num) +{ + if (num <= INT32_MAX && num >= INT32_MIN) { + ION_CHECK(ion_decimal_from_int32(dec, num)); + } else if (num > 0 && num <= UINT32_MAX) { + ION_CHECK(ion_decimal_from_uint32(dec, num)); + } else { + ION_INT *iint; + ION_CHECK(ion_int_alloc(NULL, &iint)); + ION_CHECK(ion_int_from_long(iint, num), + ion_int_free(iint)); + /* WATCH OUT: BS API */ + dec->type = ION_DECIMAL_TYPE_QUAD; + ION_CHECK(ion_decimal_from_ion_int(dec, ctx, iint), + ion_int_free(iint)); + ion_int_free(iint); + } +} + static inline zend_string *php_ion_decimal_to_string(ION_DECIMAL *dec) { zend_string *zstr = zend_string_alloc(ION_DECIMAL_STRLEN(dec), 0); @@ -398,7 +698,7 @@ static inline zend_string *php_ion_decimal_to_string(ION_DECIMAL *dec) return zend_string_truncate(zstr, strlen(zstr->val), 0); } -static inline void php_ion_decimal_to_int(ION_DECIMAL *dec, decContext *ctx, zend_long *l) +static inline void php_ion_decimal_to_zend_long(ION_DECIMAL *dec, decContext *ctx, zend_long *l) { ION_INT *ii = NULL; ION_CHECK(ion_int_alloc(NULL, &ii)); @@ -409,19 +709,41 @@ static inline void php_ion_decimal_to_int(ION_DECIMAL *dec, decContext *ctx, zen ion_int_free(ii); } +static inline bool php_ion_decimal_fits_zend_long(php_ion_decimal *obj) +{ + int32_t result; + + if (!ion_decimal_is_integer(&obj->dec)) { + return false; + } + + result = 1; + ion_decimal_compare(&obj->dec, &php_ion_globals.decimal.zend_max, &php_ion_globals.decimal.ctx, &result); + if (result == 1) { + return false; + } + result = -1; + ion_decimal_compare(&obj->dec, &php_ion_globals.decimal.zend_min, &php_ion_globals.decimal.ctx, &result); + if (result == -1) { + return false; + } + return true; +} + static inline void php_ion_decimal_ctor(php_ion_decimal *obj) { if (!obj->ctx) { zval zdc; object_init_ex(&zdc, ce_Decimal_Context); obj->ctx = Z_OBJ(zdc); - php_ion_decimal_ctx_ctor(php_ion_obj(decimal_ctx, obj->ctx)); + php_ion_decimal_ctx_ctor(php_ion_obj(decimal_ctx, obj->ctx), NULL); + GC_DELREF(obj->ctx); } update_property_obj(&obj->std, ZEND_STRL("context"), obj->ctx); - if (ion_decimal_is_integer(&obj->dec)) { + if (php_ion_decimal_fits_zend_long(obj)) { zend_long l; - php_ion_decimal_to_int(&obj->dec, &php_ion_obj(decimal_ctx, obj->ctx)->ctx, &l); + php_ion_decimal_to_zend_long(&obj->dec, &php_ion_obj(decimal_ctx, obj->ctx)->ctx, &l); zend_update_property_long(obj->std.ce, &obj->std, ZEND_STRL("number"), l); } else { zend_string *zstr = php_ion_decimal_to_string(&obj->dec); @@ -435,24 +757,32 @@ static inline void php_ion_decimal_dtor(php_ion_decimal *obj) ion_decimal_free(&obj->dec); } +php_ion_decl(decimal, Decimal, php_ion_decimal_dtor(obj)); + typedef php_date_obj php_ion_timestamp; static inline zend_long php_usec_from_ion(const decQuad *frac, decContext *ctx) { + if (!ctx) { + ctx = &php_ion_globals.decimal.ctx; + } decQuad microsecs, result; decQuadMultiply(&result, decQuadFromInt32(µsecs, 1000000), frac, ctx); return (zend_long) decQuadToUInt32(&result, ctx, DEC_ROUND_HALF_EVEN); } -static inline decQuad *ion_ts_frac_from_usec(decQuad *frac, zend_long usec, decContext *ctx) +static inline decQuad *ion_ts_frac_from_usec(decQuad *frac, int usec, decContext *ctx) { + if (!ctx) { + ctx = &php_ion_globals.decimal.ctx; + } decQuad microsecs, us; return decQuadDivide(frac, decQuadFromInt32(&us, usec), decQuadFromInt32(µsecs, 1000000), ctx); } static inline zend_string *php_dt_format_from_precision(uint8_t precision) { - switch (precision) { + switch (precision & 0x7f) { case ION_TS_FRAC: return zend_string_init(ZEND_STRL("c"), 0); case ION_TS_SEC: @@ -472,9 +802,11 @@ static inline zend_string *php_dt_format_from_precision(uint8_t precision) static inline timelib_time* php_time_from_ion(const ION_TIMESTAMP *ts, decContext *ctx, zend_string **fmt) { - timelib_time *time = timelib_time_ctor(); + timelib_time *time = ecalloc(1, sizeof(*time)); - switch (ts->precision) { + int precision = ION_TS_FRAC; + ion_timestamp_get_precision(ts, &precision); + switch (precision) { case ION_TS_FRAC: time->us = php_usec_from_ion(&ts->fraction, ctx); /* fallthrough */ @@ -496,10 +828,16 @@ static inline timelib_time* php_time_from_ion(const ION_TIMESTAMP *ts, decContex /* fallthrough */ default: time->z = ts->tz_offset * 60; + if (time->z) { + time->zone_type = TIMELIB_ZONETYPE_OFFSET; + } else { + time->zone_type = TIMELIB_ZONETYPE_ID; + time->tz_info = get_timezone_info(); + } } if (fmt) { - *fmt = php_dt_format_from_precision(ts->precision); + *fmt = php_dt_format_from_precision(precision); } return time; } @@ -509,14 +847,14 @@ static inline ION_TIMESTAMP *ion_timestamp_from_php(ION_TIMESTAMP *buf, php_ion_ memset(buf, 0, sizeof(*buf)); zval tmp; - uint8_t precision = Z_LVAL_P(zend_read_property(ts->std.ce, &ts->std, ZEND_STRL("precision"), 0, &tmp)); + int precision = Z_LVAL_P(zend_read_property(ts->std.ce, &ts->std, ZEND_STRL("precision"), 0, &tmp)); if (!precision || precision > ION_TS_FRAC) { zend_throw_exception_ex(spl_ce_InvalidArgumentException, IERR_INVALID_ARG, - "Invalid precision (%u) of ion\\Timestamp", (unsigned) precision); + "Invalid precision (%d) of ion\\Timestamp", precision); } else switch ((buf->precision = precision)) { case ION_TS_FRAC: - ion_ts_frac_from_usec(&buf->fraction, ts->time->us, ctx); + ion_ts_frac_from_usec(&buf->fraction, (int) ts->time->us, ctx); /* fallthrough */ case ION_TS_SEC: buf->seconds = ts->time->s; @@ -535,7 +873,10 @@ static inline ION_TIMESTAMP *ion_timestamp_from_php(ION_TIMESTAMP *buf, php_ion_ buf->year = ts->time->y; /* fallthrough */ default: - buf->tz_offset = ts->time->z / 60; + buf->tz_offset = (short) (ts->time->z / 60); + if (buf->tz_offset) { + buf->precision |= 0x80; + } } return buf; @@ -553,23 +894,127 @@ static inline void php_ion_timestamp_ctor(php_ion_timestamp *obj, zend_long prec zend_string_release(fmt); } -static inline void php_ion_timestamp_dtor(php_ion_timestamp *obj) -{ - if (obj->time) { - timelib_time_dtor(obj->time); - } -} - typedef struct php_ion_catalog { ION_CATALOG *cat; zend_object std; } php_ion_catalog; +static inline void php_ion_catalog_ctor(php_ion_catalog *obj) +{ + ION_CHECK(ion_catalog_open(&obj->cat)); +} + +static inline void php_ion_catalog_dtor(php_ion_catalog *obj) +{ + if (obj->cat) { + ion_catalog_close(obj->cat); + } +} + +static inline zend_string *ion_symbol_table_to_key(ION_SYMBOL_TABLE *tab) +{ + int32_t version; + ION_STRING is; + ION_CHECK_RETURN(NULL, ion_symbol_table_get_name(tab, &is)); + ION_CHECK_RETURN(NULL, ion_symbol_table_get_version(tab, &version)); + + smart_str s = {0}; + smart_str_appendl(&s, (char *) is.value, is.length); + smart_str_appendc(&s, ':'); + smart_str_append_long(&s, version); + smart_str_0(&s); + + return s.s; +} + +static inline void php_ion_catalog_add_symbol_table(php_ion_catalog *obj, php_ion_symbol_table *tab) +{ + OBJ_CHECK(obj); + OBJ_CHECK(tab); + + zval tmp; + zval *ztabs = zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("symbolTables"), 0, &tmp); + if (ztabs) { + zend_ulong idx = (uintptr_t) &tab->std.gc; + if (!zend_hash_index_exists(Z_ARRVAL_P(ztabs), idx)) { + zend_string *key = ion_symbol_table_to_key(tab->tab); + if (key) { + ION_CHECK(ion_catalog_add_symbol_table(obj->cat, tab->tab), + zend_string_release(key)); + SEPARATE_ARRAY(ztabs); + GC_ADDREF(&tab->std); + add_index_object(ztabs, idx, &tab->std); + GC_ADDREF(&tab->std); + add_assoc_object_ex(ztabs, key->val, key->len, &tab->std); + zend_update_property(obj->std.ce, &obj->std, ZEND_STRL("symbolTables"), ztabs); + zend_string_release(key); + } + } + } +} + +static inline void php_ion_catalog_symbol_table_zval(php_ion_catalog *obj, ION_SYMBOL_TABLE *tab, zval *return_value) +{ + zend_string *key = ion_symbol_table_to_key(tab); + PTR_CHECK(key); + + zval tmp; + zval *ztabs = zend_read_property(obj->std.ce, &obj->std, ZEND_STRL("symbolTables"), 0, &tmp); + if (ztabs) { + zval *ztab = zend_hash_find(Z_ARRVAL_P(ztabs), key); + if (ztab) { + zend_string_release(key); + RETURN_COPY(ztab); + } + } + + php_error_docref(NULL, E_NOTICE, "Previously unknown ion\\Symbol\\Table encountered: %s", key->val); + + object_init_ex(return_value, ce_Symbol_Table_Shared); + php_ion_symbol_table *o_tab = php_ion_obj(symbol_table, Z_OBJ_P(return_value)); + OBJ_CHECK(o_tab, zend_string_release(key)); + php_ion_symbol_table_ctor(o_tab); + + if (ztabs) { + SEPARATE_ARRAY(ztabs); + ZVAL_ADDREF(return_value); + add_index_zval(ztabs, (uintptr_t) &o_tab->std.gc, return_value); + ZVAL_ADDREF(return_value); + add_assoc_zval_ex(ztabs, key->val, key->len, return_value); + } + zend_string_release(key); +} + +php_ion_decl(catalog, Catalog, php_ion_catalog_dtor(obj)); + +typedef struct php_ion_reader_options_ccn_ctx { + zend_object *obj; + zend_fcall_info fci; + zend_fcall_info_cache fcc; +} php_ion_reader_options_ccn_ctx; + typedef struct php_ion_reader_options { ION_READER_OPTIONS opt; + php_ion_reader_options_ccn_ctx ccn; zend_object *cat, *dec_ctx, *cb, std; } php_ion_reader_options; +static inline void php_ion_reader_options_dtor(php_ion_reader_options *obj) +{ + if (obj->cb) { + zend_fcall_info_args_clear(&obj->ccn.fci, true); + } +} + +php_ion_decl(reader_options, Reader_Options, php_ion_reader_options_dtor(obj)); + +static inline zend_object *php_ion_reader_options_new(void) +{ + zend_object *obj = create_ion_Reader_Options(NULL); + zend_call_known_instance_method_with_0_params(obj->ce->constructor, obj, NULL); + return obj; +} + typedef struct php_ion_reader { ION_READER *reader; ION_TYPE state; @@ -584,14 +1029,10 @@ typedef struct php_ion_reader { ION_STRING buf; } stream; }; - struct { - zend_bool call_magic_unserialize; - zend_string *custom_unserialize; - } php; zend_object *opt, std; } php_ion_reader; -static iERR php_ion_reader_stream_handler(struct _ion_user_stream *user) +static inline iERR php_ion_reader_stream_handler(struct _ion_user_stream *user) { php_ion_reader *reader = (php_ion_reader *) user->handler_state; size_t remaining = 0, spare = reader->stream.buf.length; @@ -617,44 +1058,44 @@ static iERR php_ion_reader_stream_handler(struct _ion_user_stream *user) return IERR_READ_ERROR; } -static iERR on_context_change(void *context, ION_COLLECTION *imports) +static inline iERR on_context_change(void *context, ION_COLLECTION *imports) { + iERR e = IERR_OK; + if (context) { - php_ion_reader *obj = php_ion_obj(reader, context); - (void) obj; + php_ion_reader_options_ccn_ctx *ctx = context; + + zval zobj; + ZVAL_OBJ(&zobj, ctx->obj); + zend_fcall_info_argn(&ctx->fci, 1, &zobj); + if (SUCCESS != zend_fcall_info_call(&ctx->fci, &ctx->fcc, NULL, NULL)) { + e = IERR_INTERNAL_ERROR; + } + zend_fcall_info_args_clear(&ctx->fci, false); } - return IERR_OK; + return e; } -static ION_READER_CONTEXT_CHANGE_NOTIFIER EMPTY_READER_CHANGE_NOTIFIER = { - on_context_change, - NULL -}; - static inline void php_ion_reader_ctor(php_ion_reader *obj) { iERR err; php_ion_reader_options *opt = php_ion_obj(reader_options, obj->opt); - if (opt) { - opt->opt.context_change_notifier.context = obj; + if (opt && opt->opt.context_change_notifier.context) { + php_ion_reader_options_ccn_ctx *ctx = opt->opt.context_change_notifier.context; + ctx->obj = &obj->std; + opt->opt.context_change_notifier.notify = on_context_change; } if (obj->type == STREAM_READER) { PTR_CHECK(obj->stream.ptr); GC_ADDREF(obj->stream.ptr->res); - php_ion_reader_options *opt = php_ion_obj(reader_options, obj->opt); - obj->stream.buf.length = opt ? opt->opt.allocation_page_size : 0x1000; + obj->stream.buf.length = opt && opt->opt.allocation_page_size ? opt->opt.allocation_page_size : 0x10000; obj->stream.buf.value = emalloc(obj->stream.buf.length); err = ion_reader_open_stream(&obj->reader, obj, php_ion_reader_stream_handler, opt ? &opt->opt : NULL); } else { - err = ion_reader_open_buffer(&obj->reader, - (BYTE *) obj->buffer->val, obj->buffer->len, - opt ? &opt->opt : NULL); - } - if (opt) { - opt->opt.context_change_notifier.context = NULL; + err = ion_reader_open_buffer(&obj->reader, (BYTE *) obj->buffer->val, (SIZE) obj->buffer->len, opt ? &opt->opt : NULL); } ION_CHECK(err); @@ -679,11 +1120,22 @@ static inline void php_ion_reader_dtor(php_ion_reader *obj) } } +php_ion_decl(reader, Reader_Reader, php_ion_reader_dtor(obj)); + typedef struct php_ion_writer_options { ION_WRITER_OPTIONS opt; - zend_object *cat, *dec_ctx, *col, std; + zend_object *cat, *dec_ctx, std; } php_ion_writer_options; +php_ion_decl(writer_options, Writer_Options); + +static inline zend_object *php_ion_writer_options_new(void) +{ + zend_object *obj = create_ion_Writer_Options(NULL); + zend_call_known_instance_method_with_0_params(obj->ce->constructor, obj, NULL); + return obj; +} + typedef struct php_ion_writer { ION_WRITER *writer; enum { @@ -700,15 +1152,11 @@ typedef struct php_ion_writer { php_stream *ptr; } stream; }; - struct { - zend_bool call_magic_serialize; - zend_string *custom_serialize; - } php; zend_object *opt, std; } php_ion_writer; -static iERR php_ion_writer_stream_handler(struct _ion_user_stream *user) +static inline iERR php_ion_writer_stream_handler(struct _ion_user_stream *user) { php_ion_writer *writer = (php_ion_writer *) user->handler_state; @@ -785,7 +1233,7 @@ static inline void php_ion_writer_buffer_grow(php_ion_writer *obj) NEW_REF_STR(); } -static iERR php_ion_writer_buffer_handler(struct _ion_user_stream *user) +static inline iERR php_ion_writer_buffer_handler(struct _ion_user_stream *user) { php_ion_writer *writer = (php_ion_writer *) user->handler_state; @@ -802,13 +1250,56 @@ static iERR php_ion_writer_buffer_handler(struct _ion_user_stream *user) return IERR_OK; } +static inline ION_COLLECTION *php_ion_catalog_collection(php_ion_catalog *cat) +{ + /* do not look too close */ + struct { + void *owner; + ION_SYMBOL_TABLE *sys; + ION_COLLECTION collection; + } *cat_ptr = (void *) cat->cat; + return &cat_ptr->collection; +} + +static inline void php_ion_writer_options_init_shared_imports(php_ion_writer_options *opt) +{ + php_ion_catalog *cat = php_ion_obj(catalog, opt->cat); + OBJ_CHECK(cat); + + ION_CHECK(ion_writer_options_initialize_shared_imports(&opt->opt)); + + ION_COLLECTION *col = php_ion_catalog_collection(cat); + if (!ION_COLLECTION_IS_EMPTY(col)) { + // holy, nah, forget it batman... +#ifndef IPCN_pNODE_TO_pDATA +# define IPCN_pNODE_TO_pDATA(x) (&((x)->_data[0])) +#endif + ION_COLLECTION_CURSOR cur; + ION_COLLECTION_OPEN(col, cur); + while (cur) { + ION_SYMBOL_TABLE **ptr; + ION_COLLECTION_NEXT(cur, ptr); + if (*ptr) { + ION_CHECK(ion_writer_options_add_shared_imports_symbol_tables(&opt->opt, ptr, 1)); + } else { + break; + } + } + } +} + static inline void php_ion_writer_ctor(php_ion_writer *obj) { + php_ion_writer_options *opt = NULL; + if (obj->opt) { update_property_obj(&obj->std, ZEND_STRL("options"), obj->opt); + opt = php_ion_obj(writer_options, obj->opt); + if (opt->cat) { + php_ion_writer_options_init_shared_imports(opt); + } } - php_ion_writer_options *opt = php_ion_obj(writer_options, obj->opt); ION_STREAM_HANDLER h; if (obj->type == STREAM_WRITER) { h = php_ion_writer_stream_handler; @@ -818,6 +1309,7 @@ static inline void php_ion_writer_ctor(php_ion_writer *obj) php_ion_writer_buffer_init(obj); } + ION_CHECK(ion_writer_open_stream(&obj->writer, h, obj, opt ? &opt->opt : NULL)); OBJ_CHECK(obj); } @@ -827,6 +1319,12 @@ static inline void php_ion_writer_dtor(php_ion_writer *obj) if (obj->writer) { ion_writer_close(obj->writer); } + if (obj->opt) { + php_ion_writer_options *opt = php_ion_obj(writer_options, obj->opt); + if (opt->cat) { + ion_writer_options_close_shared_imports(&opt->opt); + } + } if (obj->type == STREAM_WRITER) { if (obj->stream.buf.value) { efree(obj->stream.buf.value); @@ -835,64 +1333,121 @@ static inline void php_ion_writer_dtor(php_ion_writer *obj) zend_list_delete(obj->stream.ptr->res); } } else { - smart_str_0(&obj->buffer.str); - zend_string_release(obj->buffer.str.s); + if (obj->buffer.str.s) { + smart_str_0(&obj->buffer.str); + zend_string_release(obj->buffer.str.s); + } zval_ptr_dtor(&obj->buffer.val); } - if (obj->php.custom_serialize) { - zend_string_release(obj->php.custom_serialize); +} + +php_ion_decl(writer, Writer_Writer, php_ion_writer_dtor(obj)); + +typedef struct php_ion_serializer_php { + php_ion_serializer serializer; + zend_object *opt, std; +} php_ion_serializer_php; + +static inline void php_ion_serializer_php_ctor(php_ion_serializer_php *ser_obj) +{ + php_ion_serializer *global_ser = &php_ion_globals.serializer; + ser_obj->serializer.ids = global_ser->ids; + ser_obj->serializer.tmp = global_ser->tmp; + + zend_update_property_bool(ser_obj->std.ce, &ser_obj->std, ZEND_STRL("multiSequence"), + ser_obj->serializer.multi_seq); + zend_update_property_bool(ser_obj->std.ce, &ser_obj->std, ZEND_STRL("callMagicSerialize"), + ser_obj->serializer.call_magic); + if (ser_obj->serializer.call_custom) { + zend_update_property_str(ser_obj->std.ce, &ser_obj->std, ZEND_STRL("callCustomSerialize"), + ser_obj->serializer.call_custom); + ser_obj->serializer.call_custom = zend_string_tolower(ser_obj->serializer.call_custom); + } else { + zend_update_property_null(ser_obj->std.ce, &ser_obj->std, ZEND_STRL("callCustomSerialize")); + } + if (!ser_obj->opt) { + ser_obj->opt = php_ion_writer_options_new(); + } else { + GC_ADDREF(ser_obj->opt); } + ser_obj->serializer.options = &php_ion_obj(writer_options, ser_obj->opt)->opt; + update_property_obj(&ser_obj->std, ZEND_STRL("writerOptions"), ser_obj->opt); + GC_DELREF(ser_obj->opt); } -static inline void php_ion_serialize_zval(php_ion_writer *, zval *); +static inline void php_ion_serializer_php_dtor(php_ion_serializer_php *obj) +{ + if (obj->serializer.call_custom) { + zend_string_release(obj->serializer.call_custom); + } +} + +static inline void php_ion_serialize_zval(php_ion_serializer *, zval *); -static inline void php_ion_serialize_struct(php_ion_writer *obj, zend_array *arr) +static inline void php_ion_serialize_struct(php_ion_serializer *ser, zend_array *arr, bool unmangle_props, bool annotate_props) { - ION_CHECK(ion_writer_start_container(obj->writer, tid_STRUCT)); + ION_CHECK(ion_writer_start_container(ser->writer, tid_STRUCT)); zval *v; zend_ulong h; zend_string *k = NULL; if (arr) ZEND_HASH_FOREACH_KEY_VAL_IND(arr, h, k, v) + char buf[MAX_LENGTH_OF_LONG + 1]; ION_STRING is; if (k) { - ION_CHECK(ion_writer_write_field_name(obj->writer, ion_string_from_zend(&is, k))); + size_t prop_len; + const char *class_name, *prop_name; + if (unmangle_props && (SUCCESS == zend_unmangle_property_name_ex(k, &class_name, &prop_name, &prop_len)) && class_name) { + if (annotate_props) { + ION_CHECK(ion_writer_add_annotation_symbol(ser->writer, &PHP_ION_SYMBOL_PROPERTY)); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, (char *) class_name, prop_name - class_name - 1))); + } + } else { + prop_name = k->val; + prop_len = k->len; + } + ion_string_assign_cstr(&is, (char *) prop_name, (SIZE) prop_len); } else { - char buf[MAX_LENGTH_OF_LONG + 1], *end = buf + sizeof(buf) - 1; + char *end = buf + sizeof(buf) - 1; char *ptr = zend_print_long_to_buf(end, (zend_long) h); - ION_CHECK(ion_writer_write_field_name(obj->writer, ion_string_from_cstr(&is, ptr, end - ptr))); + ion_string_assign_cstr(&is, ptr, (SIZE) (end - ptr)); } - php_ion_serialize_zval(obj, v); + // WATCH OUT: field names need to be copied + ION_STRING fn; + ION_CHECK(ion_string_copy_to_owner(ser->writer, &fn, &is)); + ION_CHECK(ion_writer_write_field_name(ser->writer, &fn)); + + php_ion_serialize_zval(ser, v); ION_CATCH(); ZEND_HASH_FOREACH_END(); - ION_CHECK(ion_writer_finish_container(obj->writer)); + ION_CHECK(ion_writer_finish_container(ser->writer)); } -static inline void php_ion_serialize_list(php_ion_writer *obj, zend_array *arr) +static inline void php_ion_serialize_list(php_ion_serializer *ser, zend_array *arr) { - ION_CHECK(ion_writer_start_container(obj->writer, tid_LIST)); + ION_CHECK(ion_writer_start_container(ser->writer, tid_LIST)); zval *v; ZEND_HASH_FOREACH_VAL_IND(arr, v) - php_ion_serialize_zval(obj, v); + php_ion_serialize_zval(ser, v); ION_CATCH(); ZEND_HASH_FOREACH_END(); - ION_CHECK(ion_writer_finish_container(obj->writer)); + ION_CHECK(ion_writer_finish_container(ser->writer)); } -static inline void php_ion_serialize_array(php_ion_writer *obj, zend_array *arr) +static inline void php_ion_serialize_array(php_ion_serializer *ser, zend_array *arr) { if (zend_array_is_list(arr)) { - php_ion_serialize_list(obj, arr); + php_ion_serialize_list(ser, arr); } else { - php_ion_serialize_struct(obj, arr); + php_ion_serialize_struct(ser, arr, false, false); } } -static inline void php_ion_serialize_object_iface(php_ion_writer *obj, zend_object *zobject) +static inline void php_ion_serialize_object_iface(php_ion_serializer *ser, zend_object *zobject) { uint8_t *buf; size_t len; @@ -901,9 +1456,9 @@ static inline void php_ion_serialize_object_iface(php_ion_writer *obj, zend_obje ZVAL_OBJ(&tmp, zobject); if (SUCCESS == zobject->ce->serialize(&tmp, &buf, &len, NULL)) { ION_STRING is; - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_cstr(&is, ZEND_STRL("S")))); - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_zend(&is, zobject->ce->name))); - ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_cstr(&is, (char *) buf, len))); + ION_CHECK(ion_writer_add_annotation_symbol(ser->writer, &PHP_ION_SYMBOL_SERIALIZEABLE)); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_zend(&is, zobject->ce->name))); + ION_CHECK(ion_writer_write_clob(ser->writer, buf, len)); efree(buf); } else if (!EG(exception)){ zend_throw_exception_ex(spl_ce_UnexpectedValueException, IERR_INTERNAL_ERROR, @@ -911,19 +1466,19 @@ static inline void php_ion_serialize_object_iface(php_ion_writer *obj, zend_obje } } -static inline void php_ion_serialize_object_magic(php_ion_writer *obj, zend_object *zobject, zend_function *fn) +static inline void php_ion_serialize_object_magic(php_ion_serializer *ser, zend_object *zobject, zend_function *fn) { zval rv; ZVAL_NULL(&rv); - zend_call_method_with_0_params(zobject, zobject->ce, fn ? &fn : &zobject->ce->__serialize, "", &rv); + zend_call_known_instance_method_with_0_params(fn ? fn : zobject->ce->__serialize, zobject, &rv); ION_CATCH(); if (IS_ARRAY == Z_TYPE(rv)) { ION_STRING is; - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_cstr(&is, fn ? "C" : "O", 1))); - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_zend(&is, zobject->ce->name))); - php_ion_serialize_zval(obj, &rv); + ION_CHECK(ion_writer_add_annotation_symbol(ser->writer, fn ? &PHP_ION_SYMBOL_CUSTOM_OBJECT : &PHP_ION_SYMBOL_MAGIC_OBJECT)); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_zend(&is, zobject->ce->name))); + php_ion_serialize_zval(ser, &rv); zval_ptr_dtor(&rv); } else { zend_throw_exception_ex(spl_ce_UnexpectedValueException, IERR_INTERNAL_ERROR, @@ -933,43 +1488,32 @@ static inline void php_ion_serialize_object_magic(php_ion_writer *obj, zend_obje } } -static inline zend_string *fq_enum_case(zend_object *zobject) -{ - zval *cn = zend_enum_fetch_case_name(zobject); - zend_string *en = zend_string_alloc(zobject->ce->name->len + Z_STRLEN_P(cn) + strlen("\\"), 0); - memcpy(en->val, zobject->ce->name->val, zobject->ce->name->len); - en->val[zobject->ce->name->len] = '\\'; - memcpy(&en->val[zobject->ce->name->len + 1], Z_STRVAL_P(cn), Z_STRLEN_P(cn)); - en->val[en->len] = 0; - return en; -} - -static inline void php_ion_serialize_object_enum(php_ion_writer *obj, zend_object *zobject) +static inline void php_ion_serialize_object_enum(php_ion_serializer *ser, zend_object *zobject) { ION_STRING is; - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_cstr(&is, ZEND_STRL("E")))); + ION_CHECK(ion_writer_add_annotation_symbol(ser->writer, &PHP_ION_SYMBOL_ENUM)); - zend_string *en = fq_enum_case(zobject); - ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&is, en))); - zend_string_release(en); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_zend(&is, zobject->ce->name))); + zval *z_cname = zend_enum_fetch_case_name(zobject); + ION_CHECK(ion_writer_write_symbol(ser->writer, ion_string_from_zend(&is, Z_STR_P(z_cname)))); } -static inline void php_ion_serialize_object_std(php_ion_writer *obj, zend_object *zobject) +static inline void php_ion_serialize_object_std(php_ion_serializer *ser, zend_object *zobject) { ION_STRING is; if (zobject->ce != zend_standard_class_def) { - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_cstr(&is, ZEND_STRL("c")))); - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_zend(&is, zobject->ce->name))); + ION_CHECK(ion_writer_add_annotation_symbol(ser->writer, &PHP_ION_SYMBOL_CLASS_OBJECT)); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_zend(&is, zobject->ce->name))); } else { - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_cstr(&is, ZEND_STRL("o")))); + ION_CHECK(ion_writer_add_annotation_symbol(ser->writer, &PHP_ION_SYMBOL_OBJECT)); } zval zobj; ZVAL_OBJ(&zobj, zobject); HashTable *props = zend_get_properties_for(&zobj, ZEND_PROP_PURPOSE_SERIALIZE); if (props) { - php_ion_serialize_struct(obj, props); + php_ion_serialize_struct(ser, props, true, true); zend_release_properties(props); } else { zend_throw_exception_ex(spl_ce_UnexpectedValueException, IERR_INTERNAL_ERROR, @@ -978,28 +1522,44 @@ static inline void php_ion_serialize_object_std(php_ion_writer *obj, zend_object } } -static inline bool can_call_magic_serialize(php_ion_writer *obj, zend_class_entry *ce) +static inline void php_ion_serialize_object_lob(php_ion_serializer *ser, zend_object *zobject) { - if (ce->__serialize && obj->php.call_magic_serialize) { - return true; + zval tmp_type, *type = zend_read_property(NULL, zobject, ZEND_STRL("type"), 0, &tmp_type); + zval tmp_value, *value = zend_read_property(NULL, zobject, ZEND_STRL("value"), 0, &tmp_value); + switch (Z_LVAL_P(zend_enum_fetch_case_value(Z_OBJ_P(type)))) { + case tid_BLOB_INT: + ION_CHECK(ion_writer_write_blob(ser->writer, (BYTE *) Z_STRVAL_P(value), Z_STRLEN_P(value))); + break; + case tid_CLOB_INT: + ION_CHECK(ion_writer_write_clob(ser->writer, (BYTE *) Z_STRVAL_P(value), Z_STRLEN_P(value))); + break; + default: + zend_throw_exception_ex(spl_ce_InvalidArgumentException, IERR_INVALID_ARG, + "Unsupported LOB type: ion\\Type::%s", Z_STRVAL_P(zend_enum_fetch_case_name(Z_OBJ_P(type)))); + break; } - return false; } -static inline bool can_call_iface_serialize(php_ion_writer *obj, zend_class_entry *ce) +static inline bool can_call_magic_serialize(php_ion_serializer *ser, zend_class_entry *ce) +{ + return ce->__serialize && ser->call_magic; +} + +static inline bool can_call_iface_serialize(php_ion_serializer *ser, zend_class_entry *ce) { - return !!ce->serialize; + (void) ser; + return !!ce->serialize; // NOLINT } -static inline bool can_call_custom_serialize(php_ion_writer *obj, zend_object *zobject, zend_function **fn) +static inline bool can_call_custom_serialize(php_ion_serializer *ser, zend_object *zobject, zend_function **fn) { - if (obj->php.custom_serialize) { - return !!((*fn = zend_hash_find_ptr(&zobject->ce->function_table, obj->php.custom_serialize))); + if (ser->call_custom) { + return !!(*fn = zend_hash_find_ptr(&zobject->ce->function_table, ser->call_custom)); // NOLINT } return false; } -static inline void php_ion_serialize_object(php_ion_writer *obj, zend_object *zobject) +static inline void php_ion_serialize_object(php_ion_serializer *ser, zend_object *zobject) { zend_function *fn; zend_class_entry *ce = zobject->ce; @@ -1011,348 +1571,561 @@ static inline void php_ion_serialize_object(php_ion_writer *obj, zend_object *zo return; } - if (can_call_magic_serialize(obj, ce)) { - php_ion_serialize_object_magic(obj, zobject, NULL); - } else if (can_call_iface_serialize(obj, ce)) { - php_ion_serialize_object_iface(obj, zobject); - } else if (can_call_custom_serialize(obj, zobject, &fn)) { - php_ion_serialize_object_magic(obj, zobject, fn); + if (can_call_magic_serialize(ser, ce)) { + php_ion_serialize_object_magic(ser, zobject, NULL); + } else if (can_call_iface_serialize(ser, ce)) { + php_ion_serialize_object_iface(ser, zobject); + } else if (can_call_custom_serialize(ser, zobject, &fn)) { + php_ion_serialize_object_magic(ser, zobject, fn); } else if (zobject->ce->ce_flags & ZEND_ACC_ENUM) { - php_ion_serialize_object_enum(obj, zobject); + php_ion_serialize_object_enum(ser, zobject); } else if (ce == ce_Symbol) { - ION_CHECK(ion_writer_write_ion_symbol(obj->writer, &php_ion_obj(symbol, zobject)->sym)); + ION_CHECK(ion_writer_write_ion_symbol(ser->writer, &php_ion_obj(symbol, zobject)->sym)); } else if (ce == ce_Decimal) { - ION_CHECK(ion_writer_write_ion_decimal(obj->writer, &php_ion_obj(decimal, zobject)->dec)); + ION_CHECK(ion_writer_write_ion_decimal(ser->writer, &php_ion_obj(decimal, zobject)->dec)); } else if (ce == ce_Timestamp) { ION_TIMESTAMP its; php_ion_timestamp *pts = php_ion_obj(timestamp, zobject); - php_ion_writer_options *opt = php_ion_obj(writer_options, obj->opt); - decContext *ctx = opt ? opt->opt.decimal_context : NULL; - ION_CHECK(ion_writer_write_timestamp(obj->writer, ion_timestamp_from_php(&its, pts, ctx))); + decContext *ctx = ser->options ? ser->options->decimal_context : NULL; + ION_CHECK(ion_writer_write_timestamp(ser->writer, ion_timestamp_from_php(&its, pts, ctx))); + } else if (ce == ce_LOB) { + php_ion_serialize_object_lob(ser, zobject); } else { - php_ion_serialize_object_std(obj, zobject); + php_ion_serialize_object_std(ser, zobject); + } +} + +static inline bool php_ion_serialize_system_value(php_ion_serializer *ser, zval *zv) +{ + if (1 == php_ion_globals.serializer.level) { + if (Z_TYPE_P(zv) == IS_OBJECT) { + if (Z_OBJCE_P(zv) == ce_Symbol_Table_Shared) { + php_ion_symbol_table *obj = php_ion_obj(symbol_table, Z_OBJ_P(zv)); + ION_CHECK_RETURN(true, ion_symbol_table_unload(obj->tab, ser->writer)); + return true; + } + } } + return false; } -static inline void php_ion_serialize_refcounted(php_ion_writer *obj, zval *zv) +static inline void php_ion_serialize_refcounted(php_ion_serializer *ser, zval *zv) { + if (php_ion_serialize_system_value(ser, zv)) { + return; + } + zend_ulong idx = (zend_ulong) (uintptr_t) Z_COUNTED_P(zv); ION_STRING is; - if (zend_hash_index_exists(&php_ion_globals.serializer.ids, idx)) { - zval *num = zend_hash_index_find(&php_ion_globals.serializer.ids, idx); + if (zend_hash_index_exists(ser->ids, idx)) { + zval *num = zend_hash_index_find(ser->ids, idx); - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_cstr(&is, ZEND_STRL("r")))); - ION_CHECK(ion_writer_write_int64(obj->writer, Z_LVAL_P(num))); + ION_CHECK(ion_writer_add_annotation_symbol(ser->writer, &PHP_ION_SYMBOL_BACKREF)); + ION_CHECK(ion_writer_write_int64(ser->writer, Z_LVAL_P(num))); } else { zval num; - ZVAL_LONG(&num, zend_hash_num_elements(&php_ion_globals.serializer.ids)); - zend_hash_index_add(&php_ion_globals.serializer.ids, idx, &num); + ZVAL_LONG(&num, zend_hash_num_elements(ser->ids)); + zend_hash_index_add(ser->ids, idx, &num); Z_TRY_ADDREF_P(zv); - zend_hash_next_index_insert(&php_ion_globals.serializer.tmp, zv); + zend_hash_next_index_insert(ser->tmp, zv); switch (Z_TYPE_P(zv)) { case IS_STRING: - ION_CHECK(ion_writer_write_string(obj->writer, ion_string_from_zend(&is, Z_STR_P(zv)))); + ION_CHECK(ion_writer_write_string(ser->writer, ion_string_from_zend(&is, Z_STR_P(zv)))); break; case IS_ARRAY: - php_ion_serialize_array(obj, Z_ARRVAL_P(zv)); + php_ion_serialize_array(ser, Z_ARRVAL_P(zv)); break; case IS_OBJECT: - php_ion_serialize_object(obj, Z_OBJ_P(zv)); + php_ion_serialize_object(ser, Z_OBJ_P(zv)); break; case IS_REFERENCE: - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_cstr(&is, ZEND_STRL("R")))); - php_ion_serialize_zval(obj, Z_REFVAL_P(zv)); + ION_CHECK(ion_writer_add_annotation_symbol(ser->writer, &PHP_ION_SYMBOL_REFERENCE)); + php_ion_serialize_zval(ser, Z_REFVAL_P(zv)); break; } } } -static inline void php_ion_serialize_zval(php_ion_writer *obj, zval *zv) +static inline void php_ion_serialize_zval(php_ion_serializer *ser, zval *zv) { - OBJ_CHECK(obj); + OBJ_CHECK(ser); switch (Z_TYPE_P(zv)) { case IS_NULL: - ION_CHECK(ion_writer_write_null(obj->writer)); + ION_CHECK(ion_writer_write_null(ser->writer)); break; case IS_TRUE: - ION_CHECK(ion_writer_write_bool(obj->writer, TRUE)); + ION_CHECK(ion_writer_write_bool(ser->writer, TRUE)); break; case IS_FALSE: - ION_CHECK(ion_writer_write_bool(obj->writer, FALSE)); + ION_CHECK(ion_writer_write_bool(ser->writer, FALSE)); break; case IS_LONG: - ION_CHECK(ion_writer_write_int64(obj->writer, Z_LVAL_P(zv))); + ION_CHECK(ion_writer_write_int64(ser->writer, Z_LVAL_P(zv))); break; case IS_DOUBLE: - ION_CHECK(ion_writer_write_double(obj->writer, Z_DVAL_P(zv))); + ION_CHECK(ion_writer_write_double(ser->writer, Z_DVAL_P(zv))); break; case IS_STRING: case IS_ARRAY: case IS_OBJECT: case IS_REFERENCE: - php_ion_serialize_refcounted(obj, zv); + php_ion_serialize_refcounted(ser, zv); break; default: zend_throw_exception_ex(spl_ce_InvalidArgumentException, IERR_INVALID_ARG, - "Failed to serialize value of type %s", zend_zval_get_legacy_type(zv)->val); + "Failed to serialize value of type %s", zend_zval_type_name(zv)); } } -void php_ion_serialize(php_ion_writer *obj, zval *zv, zval *return_value) +php_ion_decl(serializer_php, Serializer_PHP, php_ion_serializer_php_dtor(obj)); + +static inline void php_ion_serialize_ex(php_ion_serializer *ser, zval *zv) { - zval zwriter; + HashPosition pos; + HashTable *arr = NULL; - if (obj) { - ZVAL_OBJ_COPY(&zwriter, &obj->std); - } else { - object_init_ex(&zwriter, ce_Writer_Buffer_Writer); - obj = php_ion_obj(writer, Z_OBJ(zwriter)); - obj->type = BUFFER_WRITER; - php_ion_writer_ctor(obj); + if (ser->multi_seq) { + if (Z_TYPE_P(zv) != IS_ARRAY || !zend_array_is_list(Z_ARRVAL_P(zv))) { + zend_throw_exception_ex(spl_ce_InvalidArgumentException, IERR_INVALID_ARG, + "Expected a packed, consecutively numerically indexed array as argument to the multi sequence serializer"); + return; + } + + arr = Z_ARRVAL_P(zv); + + zend_hash_internal_pointer_reset_ex(arr, &pos); + zv = zend_hash_get_current_data_ex(arr, &pos); } - php_ion_globals_serializer_step(); + while (zv) { + php_ion_globals_serializer_step(); + php_ion_serialize_zval(ser, zv); + php_ion_globals_serializer_exit(); - /* start off with a global PHP annotation instead of repeating it all over the place */ - ION_STRING is; - ION_CHECK(ion_writer_add_annotation(obj->writer, ion_string_from_cstr(&is, ZEND_STRL("PHP")))); + if (!ser->multi_seq) { + break; + } + zend_hash_move_forward_ex(arr, &pos); + zv = zend_hash_get_current_data_ex(arr, &pos); + } +} - php_ion_serialize_zval(obj, zv); +void php_ion_serialize(php_ion_serializer *ser, zval *zv, zval *return_value) +{ + zend_object *zo_opt = NULL, *zo_ser = NULL; - /* make sure to flush when done, else str.s might not contain everything until the writer is closed */ - ion_writer_flush(obj->writer, NULL); - RETVAL_STR_COPY(obj->buffer.str.s); + if (!ser) { + zo_ser = create_ion_Serializer_PHP(NULL); + php_ion_serializer_php *o_ser = php_ion_obj(serializer_php, zo_ser); + PTR_CHECK(o_ser); + o_ser->serializer.call_magic = true; + php_ion_serializer_php_ctor(o_ser); + ION_CATCH(); + ser = &o_ser->serializer; + } + + zend_object *zo_writer = create_ion_Writer_Writer(ce_Writer_Buffer_Writer); + php_ion_writer *writer = php_ion_obj(writer, zo_writer); + writer->type = BUFFER_WRITER; + + if (ser->options) { + zo_opt = writer->opt = php_ion_writer_options_new(); + php_ion_obj(writer_options, writer->opt)->opt = *ser->options; + } - php_ion_globals_serializer_exit(); + php_ion_writer_ctor(writer); + ser->writer = writer->writer; + ser->buffer = &writer->buffer.str; - zval_ptr_dtor(&zwriter); + if (!EG(exception)) { + php_ion_serialize_ex(ser, zv); + } + + /* make sure to flush when done, else str.s might not contain everything until the writer is closed */ + ion_writer_flush(ser->writer, NULL); + RETVAL_STR_COPY(ser->buffer->s); + + OBJ_RELEASE(zo_writer); + if (zo_opt) { + OBJ_RELEASE(zo_opt); + } + if (zo_ser) { + OBJ_RELEASE(zo_ser); + } } -static inline void php_ion_unserialize_zval(php_ion_reader *obj, zval *return_value, ION_TYPE *typ); +typedef struct php_ion_unserializer_php { + php_ion_unserializer unserializer; + zend_object *opt, std; +} php_ion_unserializer_php; + +static inline void php_ion_unserializer_php_ctor(php_ion_unserializer_php *ser_obj) +{ + php_ion_unserializer *global_ser = &php_ion_globals.unserializer; + ser_obj->unserializer.ids = global_ser->ids; + ser_obj->unserializer.tmp = global_ser->tmp; + ser_obj->unserializer.addref = global_ser->addref; + + zend_update_property_bool(ser_obj->std.ce, &ser_obj->std, ZEND_STRL("multiSequence"), + ser_obj->unserializer.multi_seq); + zend_update_property_bool(ser_obj->std.ce, &ser_obj->std, ZEND_STRL("callMagicUnserialize"), + ser_obj->unserializer.call_magic); + if (ser_obj->unserializer.call_custom) { + zend_update_property_str(ser_obj->std.ce, &ser_obj->std, ZEND_STRL("callCustomUnserialize"), + ser_obj->unserializer.call_custom); + ser_obj->unserializer.call_custom = zend_string_tolower(ser_obj->unserializer.call_custom); + } else { + zend_update_property_null(ser_obj->std.ce, &ser_obj->std, ZEND_STRL("callCustomUnserialize")); + } + if (!ser_obj->opt) { + ser_obj->opt = php_ion_reader_options_new(); + } else { + GC_ADDREF(ser_obj->opt); + } + ser_obj->unserializer.options = &php_ion_obj(reader_options, ser_obj->opt)->opt; + update_property_obj(&ser_obj->std, ZEND_STRL("readerOptions"), ser_obj->opt); + GC_DELREF(ser_obj->opt); +} -static inline bool can_call_magic_unserialize(php_ion_reader *obj, zend_class_entry *ce) +static inline void php_ion_unserializer_php_dtor(php_ion_unserializer_php *obj) { - if (ce->__unserialize && obj->php.call_magic_unserialize) { - return true; + if (obj->unserializer.call_custom) { + zend_string_release(obj->unserializer.call_custom); } - return false; } -static inline bool can_call_iface_unserialize(php_ion_reader *obj, zend_class_entry *ce) +static inline void php_ion_unserialize_zval(php_ion_unserializer *ser, zval *return_value, ION_TYPE *typ); + +static inline bool can_call_magic_unserialize(php_ion_unserializer *ser, zend_class_entry *ce) { - return !!ce->unserialize; + return (ce && ce->__unserialize && ser->call_magic); } -static inline bool can_call_custom_unserialize(php_ion_reader *obj, zend_object *zobject, zend_function **fn) +static inline bool can_call_iface_unserialize(php_ion_unserializer *ser, zend_class_entry *ce) { - if (obj->php.custom_unserialize) { - return !!((*fn = zend_hash_find_ptr(&zobject->ce->function_table, obj->php.custom_unserialize))); + return (ce && ce->unserialize); +} + +static inline bool can_call_custom_unserialize(php_ion_unserializer *ser, zend_object *zobject, zend_function **fn) +{ + if (ser->call_custom) { + return !!(*fn = zend_hash_find_ptr(&zobject->ce->function_table, ser->call_custom)); // NOLINT } return false; } -static inline zval *php_ion_unserialize_class(php_ion_reader *obj, zend_string *class_name, zval *return_value) +static inline zval *php_ion_unserialize_class(php_ion_unserializer *ser, zval *return_value) { - zend_class_entry *ce = zend_lookup_class(class_name); + zend_class_entry *ce = zend_lookup_class(ser->annotations.object_class); if (ce) { object_init_ex(return_value, ce); - return zend_hash_next_index_insert(&php_ion_globals.unserializer.ids, return_value); + return zend_hash_next_index_insert(ser->ids, return_value); } zend_throw_exception_ex(spl_ce_RuntimeException, IERR_IMPORT_NOT_FOUND, - "Could not find class %s", class_name->val); + "Could not find class %s", ser->annotations.object_class->val); return NULL; } -static inline void php_ion_unserialize_object_iface(php_ion_reader *obj, zend_string *class_name, zval *return_value) +static inline void php_ion_unserialize_object_enum(php_ion_unserializer *ser, zval *return_value) { - ZEND_ASSERT(Z_TYPE_P(return_value) == IS_STRING); - zend_string *s = Z_STR_P(return_value); - - zval *backref = php_ion_unserialize_class(obj, class_name, return_value); + zend_string *zs_case = zval_get_string(return_value); ION_CATCH(); - zend_class_entry *ce = Z_OBJCE_P(return_value); - if (can_call_iface_unserialize(obj, ce)) { + zend_class_entry *ce = zend_lookup_class(ser->annotations.object_class); + if (!ce || !(ce->ce_flags & ZEND_ACC_ENUM)) { + zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_TOKEN, + "Not a valid enum: %s", ser->annotations.object_class->val); + return; + } + if (!zend_hash_exists(CE_CONSTANTS_TABLE(ce), zs_case)) { + zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_TOKEN, + "Not a valid enum case: %s::%s", ser->annotations.object_class->val, zs_case->val); + return; + } + RETVAL_OBJ_COPY(zend_enum_get_case(ce, zs_case)); + zend_hash_next_index_insert(ser->ids, return_value); + zend_string_release(zs_case); +} + +static inline void php_ion_unserialize_object_iface(php_ion_unserializer *ser, zval *return_value) +{ + zend_class_entry *ce = zend_lookup_class(ser->annotations.object_class); + if (can_call_iface_unserialize(ser, ce)) { + zend_string *s = zval_get_string(return_value); + ZVAL_NULL(return_value); + zval *backref = zend_hash_next_index_insert(ser->ids, return_value); if (SUCCESS == ce->unserialize(backref, ce, (BYTE *) s->val, s->len, NULL)) { - // remove all this Serializable crap in PHP-9 - zval_ptr_dtor(return_value); - ZVAL_COPY_VALUE(return_value, backref); + RETVAL_ZVAL(backref, 0, 0); } else if (!EG(exception)) { zend_throw_exception_ex(spl_ce_UnexpectedValueException, IERR_INTERNAL_ERROR, "Failed to unserialize class %s", ce->name->val); } + zend_string_release(s); } else { zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_TOKEN, - "Class %s does not implement Serializable", class_name->val); + "Class %s does not implement Serializable", ser->annotations.object_class->val); } +} - zend_string_release(s); +static inline void php_ion_unserialize_field_name(php_ion_unserializer *ser, zend_string **key) +{ + // FIXME: symbol table + ION_STRING name; + ION_CHECK(ion_reader_get_field_name(ser->reader, &name)); + if (!name.length) { + ION_SYMBOL *is_ptr; + ION_CHECK(ion_reader_get_field_name_symbol(ser->reader, &is_ptr)); + if (!ION_SYMBOL_IS_NULL(is_ptr) && is_ptr->value.length) { + name = is_ptr->value; + } else if (is_ptr) { + char buf[MAX_LENGTH_OF_LONG + 1 + 1] = {0}, *end = buf + sizeof(buf) - 1, *ptr; + ptr = zend_print_long_to_buf(end, is_ptr->sid); + *--ptr = '$'; + *key = zend_string_init(ptr, end - ptr, 0); + return; + } + } + *key = zend_string_from_ion(&name); } -static inline void php_ion_unserialize_hash(php_ion_reader *obj, zval *return_value) +static void php_ion_unserialize_props(php_ion_unserializer *ser, zval *return_value) { - zend_hash_next_index_insert(&php_ion_globals.unserializer.ids, return_value); + zend_hash_next_index_insert(ser->ids, return_value); - ION_CHECK(ion_reader_step_in(obj->reader)); + ION_CHECK(ion_reader_step_in(ser->reader)); while (true) { ION_TYPE typ; - ION_CHECK(ion_reader_next(obj->reader, &typ)); + ION_CHECK(ion_reader_next(ser->reader, &typ)); - ION_STRING name; - ION_CHECK(ion_reader_get_field_name(obj->reader, &name)); - zend_string *key = zend_string_from_ion(&name); + if (typ == tid_EOF) { + break; + } + + zend_string *key; + php_ion_unserialize_field_name(ser, &key); + ION_CATCH(); zval zvalue; - php_ion_unserialize_zval(obj, &zvalue, &typ); + php_ion_unserialize_zval(ser, &zvalue, &typ); ION_CATCH(zend_string_release(key)); + zend_class_entry *ce = Z_OBJCE_P(return_value); + if (ser->annotations.object_prop && ser->annotations.property_class->val[0] != '*') { + ce = zend_lookup_class(ser->annotations.property_class); + } + zend_update_property_ex(ce, Z_OBJ_P(return_value), key, &zvalue); + zval_ptr_dtor(&zvalue); + zend_string_release(key); + } + + ION_CHECK(ion_reader_step_out(ser->reader)); +} + +/** + * @link https://amzn.github.io/ion-docs/docs/spec.html#struct + * When two fields in the same struct have the same name [...] Implementations must preserve all such fields, + * i.e., they may not discard fields that have repeated names. However, implementations may reorder fields + * (the binary format identifies structs that are sorted by symbolID), so certain operations may lead to + * nondeterministic behavior. + */ +static inline void php_ion_unserialize_hash(php_ion_unserializer *ser, zval *return_value) +{ + zend_hash_next_index_insert(ser->ids, return_value); + + ION_CHECK(ion_reader_step_in(ser->reader)); + + while (true) { + ION_TYPE typ; + ION_CHECK(ion_reader_next(ser->reader, &typ)); + if (typ == tid_EOF) { - zend_string_release(key); break; } - zend_symtable_update(HASH_OF(return_value), key, &zvalue); + zend_string *key; + php_ion_unserialize_field_name(ser, &key); + ION_CATCH(); + + zval zvalue; + php_ion_unserialize_zval(ser, &zvalue, &typ); + ION_CATCH(zend_string_release(key)); + + // FIXME:: too naive; b0rked if the previous value is an array + if (zend_symtable_exists(HASH_OF(return_value), key)) { + zval tmp, *prev = zend_hash_find(HASH_OF(return_value), key); + if (Z_TYPE_P(prev) != IS_ARRAY) { + array_init(&tmp); + Z_TRY_ADDREF_P(prev); + zend_hash_next_index_insert(Z_ARRVAL(tmp), prev); + prev = zend_hash_update(HASH_OF(return_value), key, &tmp); + } + zend_hash_next_index_insert(Z_ARRVAL_P(prev), &zvalue); + } else { + zend_symtable_update(HASH_OF(return_value), key, &zvalue); + } zend_string_release(key); } - ION_CHECK(ion_reader_step_out(obj->reader)); + ION_CHECK(ion_reader_step_out(ser->reader)); } -static inline void verify_unserializer(php_ion_reader *obj, uint8_t object_type, - zend_string *class_name, zend_object *zobject, zend_function **fn) +static inline void verify_unserializer(php_ion_unserializer *ser, zend_object *zobject, zend_function **fn) { - switch (object_type) { + switch (ser->annotations.object_type) { + case 'c': + *fn = NULL; + break; + case 'C': - if (!can_call_custom_unserialize(obj, zobject, fn)) { + if (!can_call_custom_unserialize(ser, zobject, fn)) { zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_TOKEN, - "Could not find custom serializer method of %s", class_name->val); + "Could not find custom serializer method of %s", ser->annotations.object_class->val); } break; case 'O': - if (!can_call_magic_unserialize(obj, zobject->ce)) { + if (!can_call_magic_unserialize(ser, zobject->ce)) { zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_TOKEN, - "Could not find method %s::__serialize()", class_name->val); + "Could not find method %s::__unserialize()", ser->annotations.object_class->val); } *fn = zobject->ce->__unserialize; break; default: zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_TOKEN, - "Invalid object type %c", object_type); + "Invalid object type %c", ser->annotations.object_type); } } -static inline void php_ion_unserialize_object(php_ion_reader *obj, uint8_t object_type, zend_string *class_name, zval *return_value) + +static inline void php_ion_unserialize_object(php_ion_unserializer *ser, zval *return_value) { // backup possible backref to array returned by magic/custom __serialize() - zval zarr; - ZVAL_COPY_VALUE(&zarr, return_value); - zend_hash_next_index_insert(&php_ion_globals.unserializer.tmp, &zarr); + zval *input = zend_hash_next_index_insert(ser->tmp, return_value); - php_ion_unserialize_class(obj, class_name, return_value); + php_ion_unserialize_class(ser, return_value); ION_CATCH(); - zend_object *zobject = Z_OBJ_P(return_value); zend_function *fn = NULL; - verify_unserializer(obj, object_type, class_name, zobject, &fn); + zend_object *zobject = Z_OBJ_P(return_value); + verify_unserializer(ser, zobject, &fn); ION_CATCH(); - if (Z_TYPE(zarr) != IS_ARRAY) { - ZEND_ASSERT(Z_TYPE(zarr) != IS_OBJECT); - array_init(&zarr); - zend_hash_next_index_insert(&php_ion_globals.unserializer.tmp, &zarr); - php_ion_unserialize_hash(obj, &zarr); - ION_CATCH(); + // plain object + if (!fn) { + php_ion_unserialize_props(ser, return_value); + return; } + // magic object + if (Z_TYPE_P(input) != IS_ARRAY) { + zval_ptr_dtor(input); + array_init(input); + zend_hash_real_init_mixed(Z_ARRVAL_P(input)); + php_ion_unserialize_hash(ser, input); + ION_CATCH(); + } zval rv; ZVAL_NULL(&rv); - zend_call_method_with_1_params(zobject, zobject->ce, &fn, "", &rv, &zarr); + zend_call_method_with_1_params(zobject, zobject->ce, &fn, "", &rv, input); zval_ptr_dtor(&rv); } -static inline void php_ion_unserialize_struct(php_ion_reader *obj, uint8_t object_type, zend_string *class_name, zval *return_value) +static inline void php_ion_unserialize_struct(php_ion_unserializer *ser, zval *return_value) { - if (class_name) { - php_ion_unserialize_object(obj, object_type, class_name, return_value); - } else if (!object_type) { + if (ser->annotations.object_class) { + switch (ser->annotations.object_type) { + case 'S': + php_ion_unserialize_object_iface(ser, return_value); + break; + case 'E': + php_ion_unserialize_object_enum(ser, return_value); + break; + default: + php_ion_unserialize_object(ser, return_value); + } + } else if (!ser->annotations.object_type) { + bool is_shared_symtab = ser->annotations.shared_symtab; array_init(return_value); - php_ion_unserialize_hash(obj, return_value); - } else if (object_type == 'o') { + php_ion_unserialize_hash(ser, return_value); + if (is_shared_symtab) { + zval zobj; + object_init_ex(&zobj, ce_Symbol_Table_Shared); + zend_call_known_function(Z_OBJCE(zobj)->constructor, Z_OBJ(zobj), Z_OBJCE(zobj), NULL, 0, NULL, Z_ARRVAL_P(return_value)); + zval_ptr_dtor(return_value); + RETURN_COPY_VALUE(&zobj); + } + } else if (ser->annotations.object_type == 'o') { object_init(return_value); - php_ion_unserialize_hash(obj, return_value); + php_ion_unserialize_hash(ser, return_value); } else { zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_TOKEN, - "Invalid object type %c", object_type); + "Invalid object annotation %c::", ser->annotations.object_type); } } -static inline void php_ion_unserialize_list(php_ion_reader *obj, zval *return_value) +static inline void php_ion_unserialize_list(php_ion_unserializer *ser, zval *return_value) { - ION_CHECK(ion_reader_step_in(obj->reader)); + ION_CHECK(ion_reader_step_in(ser->reader)); array_init(return_value); - zend_hash_next_index_insert(&php_ion_globals.unserializer.ids, return_value); + zend_hash_next_index_insert(ser->ids, return_value); while (true) { ION_TYPE typ; - ION_CHECK(ion_reader_next(obj->reader, &typ)); - - zval next; - php_ion_unserialize_zval(obj, &next, &typ); - ION_CATCH(); + ION_CHECK(ion_reader_next(ser->reader, &typ)); if (typ == tid_EOF) { break; } + zval next; + php_ion_unserialize_zval(ser, &next, &typ); + ION_CATCH(); + zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &next); } - ION_CHECK(ion_reader_step_out(obj->reader)); + ION_CHECK(ion_reader_step_out(ser->reader)); } -static inline void php_ion_unserialize_lob(php_ion_reader *obj, zval *return_value) +static inline void php_ion_reader_read_lob(ION_READER *reader, zval *return_value) { zend_string *zstr = zend_string_alloc(0x1000, 0); -again: +again: ; SIZE read = 0; - iERR err = ion_reader_read_lob_bytes(obj->reader, (BYTE *) zstr->val, zstr->len, &read); + iERR err = ion_reader_read_lob_bytes(reader, (BYTE *) zstr->val, (SIZE) zstr->len, &read); if (err == IERR_BUFFER_TOO_SMALL) { zstr = zend_string_extend(zstr, zstr->len << 2, 0); goto again; } ION_CHECK(err, zend_string_release(zstr)); if (zstr->len > read) { + zstr->val[read] = 0; zstr = zend_string_truncate(zstr, read, 0); } RETURN_STR(zstr); } -static inline void php_ion_unserialize_timestamp(php_ion_reader *obj, zval *return_value) +static inline void php_ion_reader_read_timestamp(ION_READER *reader, ION_READER_OPTIONS *opt, zval *return_value) { ION_TIMESTAMP ts; - ION_CHECK(ion_reader_read_timestamp(obj->reader, &ts)); - - decContext *ctx = NULL; - if (obj->opt) { - ctx = php_ion_obj(reader_options, obj->opt)->opt.decimal_context; - } + ION_CHECK(ion_reader_read_timestamp(reader, &ts)); object_init_ex(return_value, ce_Timestamp); php_ion_timestamp *ts_obj = php_ion_obj(timestamp, Z_OBJ_P(return_value)); zend_string *fmt = NULL; + decContext *ctx = opt ? opt->decimal_context : NULL; ts_obj->time = php_time_from_ion(&ts, ctx, &fmt); php_ion_timestamp_ctor(ts_obj, ts.precision, fmt, NULL, NULL); zend_string_release(fmt); @@ -1360,11 +2133,11 @@ static inline void php_ion_unserialize_timestamp(php_ion_reader *obj, zval *retu OBJ_CHECK(ts_obj); } -static inline void php_ion_unserialize_int(php_ion_reader *obj, zval *return_value) +static inline void php_ion_reader_read_int(ION_READER *reader, zval *return_value) { ION_INT *num = NULL; - ION_CHECK(ion_int_alloc(obj->reader, &num)); - ION_CHECK(ion_reader_read_ion_int(obj->reader, num)); + ION_CHECK(ion_int_alloc(reader, &num)); + ION_CHECK(ion_reader_read_ion_int(reader, num)); // TODO: SIZEOF_ZEND_LONG == 4 int64_t i64; @@ -1374,13 +2147,13 @@ static inline void php_ion_unserialize_int(php_ion_reader *obj, zval *return_val RETVAL_LONG(i64); goto done; - case IERR_NUMERIC_OVERFLOW: + case IERR_NUMERIC_OVERFLOW: ; SIZE max, len; ION_CHECK(ion_int_char_length(num, &max)); - zend_string *zs = zend_string_alloc(max-1, 0); + zend_string *zs = zend_string_alloc(max, 0); err = ion_int_to_char(num, (BYTE *) zs->val, max, &len); - ZEND_ASSERT(len == zs->len); + zs->val[zs->len = len] = 0; RETVAL_STR(zs); /* fall through */ @@ -1391,174 +2164,224 @@ static inline void php_ion_unserialize_int(php_ion_reader *obj, zval *return_val } } -static inline void php_ion_unserialize_backref(php_ion_reader *obj, zval *return_value) +static inline void php_ion_unserialize_backref(php_ion_unserializer *ser, zval *return_value) { - php_ion_global_unserializer *u = &php_ion_globals.unserializer; - zval *backref = zend_hash_index_find(&u->ids, Z_LVAL_P(return_value)); + zval *backref = zend_hash_index_find(ser->ids, Z_LVAL_P(return_value)); if (backref) { ZVAL_COPY_VALUE(return_value, backref); - zend_hash_next_index_insert(&u->addref, return_value); + zend_hash_next_index_insert(ser->addref, return_value); } else { zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INTERNAL_ERROR, - "Could not find backref %ld", Z_LVAL_P(return_value)); + "Could not find back reference " ZEND_LONG_FMT, Z_LVAL_P(return_value)); } } -static inline void php_ion_unserialize_zval(php_ion_reader *obj, zval *return_value, ION_TYPE *typ) +static inline void php_ion_unserialize_annotations(php_ion_unserializer *ser) { - ION_TYPE typ_tmp; - if (!typ) { - typ = &typ_tmp; - ION_CHECK(ion_reader_next(obj->reader, typ)); - } + memset(&ser->annotations, 0, sizeof(ser->annotations)); - // process any annotations - bool backref = false; - uint8_t object_type = 0; - zend_string *object_class = NULL; int32_t ann_cnt; - ION_CHECK(ion_reader_get_annotation_count(obj->reader, &ann_cnt)); + ION_CHECK(ion_reader_get_annotation_count(ser->reader, &ann_cnt)); for (int32_t i = 0; i < ann_cnt; ++i) { ION_STRING ann_str; - ION_CHECK(ion_reader_get_an_annotation(obj->reader, i, &ann_str)); + ION_CHECK(ion_reader_get_an_annotation(ser->reader, i, &ann_str)); + + if (ann_str.length != 1) { + if (ION_STRING_EQUALS(&ann_str, &ION_SYMBOL_SHARED_SYMBOL_TABLE_STRING)) { + ser->annotations.shared_symtab = true; + } + continue; + } + switch (*ann_str.value) { case 'R': - ZVAL_MAKE_REF(return_value); - ZVAL_DEREF(return_value); - zend_hash_next_index_insert(&php_ion_globals.unserializer.addref, return_value); + if (ser->annotations.makeref) { + zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_SYNTAX, + "Invalid multiple reference annotations"); + return; + } + ser->annotations.makeref = true; break; case 'r': - // ints - backref = true; + if (ser->annotations.backref) { + zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_SYNTAX, + "Invalid multiple back reference annotations"); + return; + } + ser->annotations.backref = true; break; - case 'S': - case 'E': - // strings - object_type = *ann_str.value; + case 'p': + if (ser->annotations.object_prop) { + zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_SYNTAX, + "Invalid multiple object property annotations"); + return; + } + ser->annotations.object_prop = true; + + ION_STRING prop_class; + ION_CHECK(ion_reader_get_an_annotation(ser->reader, ++i, &prop_class)); + ser->annotations.property_class = zend_string_from_ion(&prop_class); + + zval zptmp; + ZVAL_STR(&zptmp, ser->annotations.property_class); + zend_hash_next_index_insert(ser->tmp, &zptmp); break; + case 'E': + case 'S': case 'O': case 'C': case 'o': case 'c': - // structs - ION_STRING class_name; - ION_CHECK(ion_reader_get_an_annotation(obj->reader, ++i, &class_name)); - object_class = zend_string_from_ion(&class_name); - object_type = *ann_str.value; + if (ser->annotations.object_type) { + zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_SYNTAX, + "Invalid multiple object type annotations: %c::%c", + ser->annotations.object_type, *ann_str.value); + return; + } + if ('o' != (ser->annotations.object_type = *ann_str.value)) { + ION_STRING class_name; + ION_CHECK(ion_reader_get_an_annotation(ser->reader, ++i, &class_name)); + ser->annotations.object_class = zend_string_from_ion(&class_name); + + zval zctmp; + ZVAL_STR(&zctmp, ser->annotations.object_class); + zend_hash_next_index_insert(ser->tmp, &zctmp); + } break; } + + // sanity checks + if (ser->annotations.object_type && ser->annotations.object_type != 'o' && !ser->annotations.object_class) { + zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_SYNTAX, + "Invalid object annotation without class name: %c::", ser->annotations.object_type); + return; + } + if (ser->annotations.object_type == 'o' && ser->annotations.object_class) { + zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_SYNTAX, + "Invalid object annotation with class name: o::%s", ser->annotations.object_class->val); + return; + } } +} - BOOL bval; - ION_CHECK(ion_reader_is_null(obj->reader, &bval)); - if (bval) { - goto read_null; +static inline void php_ion_unserialize_zval(php_ion_unserializer *ser, zval *return_value, ION_TYPE *typ) +{ + if (typ) { + memcpy(&ser->type, typ, sizeof(ser->type)); // NOLINT + } else { + typ = &ser->type; + ION_CHECK(ion_reader_next(ser->reader, typ)); + } + + php_ion_unserialize_annotations(ser); + ION_CATCH(); + + if (ser->annotations.makeref) { + ZVAL_MAKE_REF(return_value); + zend_hash_next_index_insert(ser->ids, return_value); + ZVAL_DEREF(return_value); + } + + if (ION_TYPE_INT(*typ) > 0) { + BOOL is_null; + ION_CHECK(ion_reader_is_null(ser->reader, &is_null)); + if (is_null) { + RETURN_NULL(); + } } switch (ION_TYPE_INT(*typ)) { case tid_NULL_INT: -read_null: ; - ION_CHECK(ion_reader_read_null(obj->reader, typ)); + ION_CHECK(ion_reader_read_null(ser->reader, typ)); RETURN_NULL(); - case tid_BOOL_INT: - ION_CHECK(ion_reader_read_bool(obj->reader, &bval)); + case tid_BOOL_INT: ; + BOOL bval; + ION_CHECK(ion_reader_read_bool(ser->reader, &bval)); RETURN_BOOL(bval); case tid_INT_INT: - php_ion_unserialize_int(obj, return_value); - if (backref) { + php_ion_reader_read_int(ser->reader, return_value); + if (ser->annotations.backref) { ION_CATCH(); - php_ion_unserialize_backref(obj, return_value); - switch (object_type) { - case 0: - break; - case 'S': - case 'E': - ION_CATCH(); - goto from_backref_to_string; - case 'c': - case 'C': - case 'o': - case 'O': - ION_CATCH(); - goto from_backref_to_struct; - default: - ZEND_ASSERT(0); + php_ion_unserialize_backref(ser, return_value); + } + if (ser->annotations.object_type) { + if (!ser->annotations.backref) { + zend_throw_exception_ex(spl_ce_RuntimeException, IERR_INVALID_SYNTAX, + "Invalid object type annotation: %c::" ZEND_LONG_FMT, + ser->annotations.object_type, Z_LVAL_P(return_value)); + return; } + goto unserialize_struct; } return; - case tid_FLOAT_INT: + case tid_FLOAT_INT: ; double d; - ION_CHECK(ion_reader_read_double(obj->reader, &d)); + ION_CHECK(ion_reader_read_double(ser->reader, &d)); RETURN_DOUBLE(d); case tid_DECIMAL_INT: object_init_ex(return_value, ce_Decimal); php_ion_decimal *dec = php_ion_obj(decimal, Z_OBJ_P(return_value)); - ION_CHECK(ion_reader_read_ion_decimal(obj->reader, &dec->dec)); + ION_CHECK(ion_reader_read_ion_decimal(ser->reader, &dec->dec)); php_ion_decimal_ctor(dec); - zend_hash_next_index_insert(&php_ion_globals.unserializer.ids, return_value); + zend_hash_next_index_insert(ser->ids, return_value); return; case tid_TIMESTAMP_INT: - php_ion_unserialize_timestamp(obj, return_value); - zend_hash_next_index_insert(&php_ion_globals.unserializer.ids, return_value); + php_ion_reader_read_timestamp(ser->reader, ser->options, return_value); + zend_hash_next_index_insert(ser->ids, return_value); return; - case tid_SYMBOL_INT: + case tid_SYMBOL_INT: ; ION_SYMBOL sym; - ION_CHECK(ion_reader_read_ion_symbol(obj->reader, &sym)); + ION_CHECK(ion_reader_read_ion_symbol(ser->reader, &sym)); php_ion_symbol_zval(&sym, return_value); - zend_hash_next_index_insert(&php_ion_globals.unserializer.ids, return_value); + if (ser->annotations.object_type) { + zend_hash_next_index_insert(ser->tmp, return_value); + goto unserialize_struct; + } + zend_hash_next_index_insert(ser->ids, return_value); return; - case tid_STRING_INT: + case tid_STRING_INT: ; ION_STRING str; - ION_CHECK(ion_reader_read_string(obj->reader, &str)); + ION_CHECK(ion_reader_read_string(ser->reader, &str)); RETVAL_STRINGL((char *) str.value, str.length); - if (object_type) { -from_backref_to_string: ; - zend_hash_next_index_insert(&php_ion_globals.unserializer.tmp, return_value); - switch (object_type) { - case 'S': - php_ion_unserialize_object_iface(obj, object_class, return_value); - return; - case 'E': - // TODO - return; - default: - ZEND_ASSERT(0); - } + if (ser->annotations.object_type) { + zend_hash_next_index_insert(ser->tmp, return_value); + goto unserialize_struct; } - zend_hash_next_index_insert(&php_ion_globals.unserializer.ids, return_value); + zend_hash_next_index_insert(ser->ids, return_value); return; case tid_CLOB_INT: case tid_BLOB_INT: - php_ion_unserialize_lob(obj, return_value); - zend_hash_next_index_insert(&php_ion_globals.unserializer.ids, return_value); + php_ion_reader_read_lob(ser->reader, return_value); + if (ser->annotations.object_type) { + zend_hash_next_index_insert(ser->tmp, return_value); + goto unserialize_struct; + } + zend_hash_next_index_insert(ser->ids, return_value); return; case tid_LIST_INT: case tid_SEXP_INT: // FIXME - php_ion_unserialize_list(obj, return_value); - if (!object_type) { + php_ion_unserialize_list(ser, return_value); + if (!ser->annotations.object_type) { return; } /* fall through */ case tid_STRUCT_INT: -from_backref_to_struct: ; - php_ion_unserialize_struct(obj, object_type, object_class, return_value); - if (object_class) { - zend_string_release(object_class); - } +unserialize_struct: ; + php_ion_unserialize_struct(ser, return_value); return; case tid_none_INT: @@ -1572,23 +2395,84 @@ from_backref_to_struct: ; } } -void php_ion_unserialize(php_ion_reader *obj, zend_string *zstr, zval *return_value) +php_ion_decl(unserializer_php, Unserializer_PHP, php_ion_unserializer_php_dtor(obj)); + +static inline void php_ion_unserialize_ex(php_ion_unserializer *ser, zval *return_value) { - zval zreader; + if (ser->multi_seq) { + array_init(return_value); + } + + do { + zval tmp; + ZVAL_NULL(&tmp); + php_ion_globals_unserializer_step(); + php_ion_unserialize_zval(ser, &tmp, NULL); + php_ion_globals_unserializer_exit(); + ION_CATCH(zval_ptr_dtor(&tmp)); - if (obj) { - ZVAL_OBJ_COPY(&zreader, &obj->std); + if (!ser->multi_seq) { + RETURN_COPY_VALUE(&tmp); + } else if (ser->type != tid_EOF) { + zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp); + } + } while (ser->type != tid_EOF); +} + +void php_ion_unserialize(php_ion_unserializer *ser, zval *zdata, zval *return_value) +{ + zend_object *zo_opt = NULL, *zo_ser = NULL; + + if (!ser) { + zo_ser = create_ion_Unserializer_PHP(NULL); + php_ion_unserializer_php *o_ser = php_ion_obj(unserializer_php, zo_ser); + PTR_CHECK(o_ser); + o_ser->unserializer.call_magic = true; + php_ion_unserializer_php_ctor(o_ser); + ION_CATCH(); + ser = &o_ser->unserializer; + } + + zend_object *zo_reader; + php_ion_reader *reader; + ZVAL_DEREF(zdata); + + if (Z_TYPE_P(zdata) == IS_RESOURCE) { + zo_reader = create_ion_Reader_Reader(ce_Reader_Stream_Reader); + reader = php_ion_obj(reader, zo_reader); + reader->type = STREAM_READER; + php_stream_from_zval_no_verify(reader->stream.ptr, zdata); + } else if (Z_TYPE_P(zdata) <= IS_STRING) { + zo_reader = create_ion_Reader_Reader(ce_Reader_Buffer_Reader); + reader = php_ion_obj(reader, zo_reader); + reader->type = BUFFER_READER; + reader->buffer = zval_get_string(zdata); } else { - object_init_ex(&zreader, ce_Reader_Buffer_Reader); - obj = php_ion_obj(reader, Z_OBJ(zreader)); - obj->type = BUFFER_READER; - obj->buffer = zend_string_copy(zstr); - php_ion_reader_ctor(obj); + zend_throw_exception_ex(spl_ce_InvalidArgumentException, IERR_INVALID_ARG, + "Invalid source to unserialize; expected string or resource"); + if (zo_ser) { + OBJ_RELEASE(zo_ser); + } + return; + } + + if (ser->options) { + zo_opt = reader->opt = php_ion_reader_options_new(); + php_ion_obj(reader_options, reader->opt)->opt = *ser->options; } - php_ion_globals_unserializer_step(); - php_ion_unserialize_zval(obj, return_value, NULL); - php_ion_globals_unserializer_exit(); + php_ion_reader_ctor(reader); + ser->reader = reader->reader; - zval_ptr_dtor(&zreader); + if (!EG(exception)) { + php_ion_unserialize_ex(ser, return_value); + } + + OBJ_RELEASE(zo_reader); + if (zo_opt) { + OBJ_RELEASE(zo_opt); + } + if (zo_ser) { + OBJ_RELEASE(zo_ser); + } }