X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=ion_private.h;h=809f8532618933d371cdeab49e131cf9f52c280c;hb=59145a019faf6d4c60cdbbd965c9377e48d59cf8;hp=aa912635d601423918744060228d66638127a2e6;hpb=f6fbc3a7f494cd0fe6156c49e8bf59e15c24bd3c;p=awesomized%2Fext-ion diff --git a/ion_private.h b/ion_private.h index aa91263..809f853 100644 --- a/ion_private.h +++ b/ion_private.h @@ -22,6 +22,7 @@ typedef struct php_ion_serializer { zend_string *call_custom; zend_bool call_magic; + zend_bool multi_seq; uint32_t level; HashTable *ids; @@ -44,6 +45,7 @@ typedef struct php_ion_unserializer { zend_string *call_custom; zend_bool call_magic; + zend_bool multi_seq; uint32_t level; HashTable *ids; @@ -170,6 +172,7 @@ static zend_class_entry *ce_Collection, *ce_Decimal, *ce_Decimal_Context, + *ce_Decimal_Context_Rounding, *ce_LOB, *ce_Reader, *ce_Reader_Options, @@ -257,13 +260,6 @@ static zend_class_entry PTR_CHECK(*((void **)obj)); \ } 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; -} - static inline ION_STRING *ion_string_from_zend(ION_STRING *is, const zend_string *zs) { is->length = zs ? zs->len : 0; @@ -336,6 +332,27 @@ typedef struct php_ion_symbol { 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"), @@ -400,25 +417,33 @@ typedef struct php_ion_decimal_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, + zend_long digits, zend_long emax, zend_long emin, zend_long 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); @@ -428,6 +453,25 @@ typedef struct php_ion_decimal { 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); @@ -435,7 +479,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)); @@ -473,14 +517,14 @@ static inline void php_ion_decimal_ctor(php_ion_decimal *obj) 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 (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); @@ -959,17 +1003,17 @@ static inline void php_ion_serialize_struct(php_ion_serializer *ser, zend_array size_t prop_len; const char *class_name, *prop_name; if (props && (SUCCESS == zend_unmangle_property_name_ex(k, &class_name, &prop_name, &prop_len)) && class_name) { - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, ZEND_STRL("p")))); - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, class_name, prop_name - class_name - 1))); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, ZEND_STRL("p")))); + 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_CHECK(ion_writer_write_field_name(ser->writer, ion_string_from_cstr(&is, prop_name, prop_len))); + ION_CHECK(ion_writer_write_field_name(ser->writer, ion_string_assign_cstr(&is, (char *) prop_name, prop_len))); } else { char buf[MAX_LENGTH_OF_LONG + 1], *end = buf + sizeof(buf) - 1; char *ptr = zend_print_long_to_buf(end, (zend_long) h); - ION_CHECK(ion_writer_write_field_name(ser->writer, ion_string_from_cstr(&is, ptr, end - ptr))); + ION_CHECK(ion_writer_write_field_name(ser->writer, ion_string_assign_cstr(&is, ptr, end - ptr))); } php_ion_serialize_zval(ser, v); @@ -1010,9 +1054,9 @@ static inline void php_ion_serialize_object_iface(php_ion_serializer *ser, zend_ ZVAL_OBJ(&tmp, zobject); if (SUCCESS == zobject->ce->serialize(&tmp, &buf, &len, NULL)) { ION_STRING is; - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, ZEND_STRL("S")))); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, ZEND_STRL("S")))); ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_zend(&is, zobject->ce->name))); - ION_CHECK(ion_writer_write_string(ser->writer, ion_string_from_cstr(&is, (char *) buf, len))); + ION_CHECK(ion_writer_write_string(ser->writer, ion_string_assign_cstr(&is, (char *) buf, len))); efree(buf); } else if (!EG(exception)){ zend_throw_exception_ex(spl_ce_UnexpectedValueException, IERR_INTERNAL_ERROR, @@ -1030,7 +1074,7 @@ static inline void php_ion_serialize_object_magic(php_ion_serializer *ser, zend_ if (IS_ARRAY == Z_TYPE(rv)) { ION_STRING is; - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, fn ? "C" : "O", 1))); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, fn ? "C" : "O", 1))); 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); @@ -1045,7 +1089,7 @@ static inline void php_ion_serialize_object_magic(php_ion_serializer *ser, zend_ static inline void php_ion_serialize_object_enum(php_ion_serializer *ser, zend_object *zobject) { ION_STRING is; - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, ZEND_STRL("E")))); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, ZEND_STRL("E")))); 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); @@ -1057,10 +1101,10 @@ static inline void php_ion_serialize_object_std(php_ion_serializer *ser, zend_ob ION_STRING is; if (zobject->ce != zend_standard_class_def) { - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, ZEND_STRL("c")))); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, ZEND_STRL("c")))); ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_zend(&is, zobject->ce->name))); } else { - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, ZEND_STRL("o")))); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, ZEND_STRL("o")))); } zval zobj; @@ -1156,7 +1200,7 @@ static inline void php_ion_serialize_refcounted(php_ion_serializer *ser, zval *z if (zend_hash_index_exists(ser->ids, idx)) { zval *num = zend_hash_index_find(ser->ids, idx); - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, ZEND_STRL("r")))); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, ZEND_STRL("r")))); ION_CHECK(ion_writer_write_int64(ser->writer, Z_LVAL_P(num))); } else { zval num; @@ -1181,7 +1225,7 @@ static inline void php_ion_serialize_refcounted(php_ion_serializer *ser, zval *z break; case IS_REFERENCE: - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, ZEND_STRL("R")))); + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, ZEND_STRL("R")))); php_ion_serialize_zval(ser, Z_REFVAL_P(zv)); break; } @@ -1222,6 +1266,41 @@ static inline void php_ion_serialize_zval(php_ion_serializer *ser, zval *zv) 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) +{ + HashPosition pos; + HashTable *arr = NULL; + + 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); + } + + while (zv) { + /* start off with a global PHP annotation instead of repeating it all over the place */ + if (0 == php_ion_globals_serializer_step()) { + ION_STRING is; + ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_assign_cstr(&is, ZEND_STRL("PHP")))); + } + php_ion_serialize_zval(ser, zv); + php_ion_globals_serializer_exit(); + + if (!ser->multi_seq) { + break; + } + zend_hash_move_forward_ex(arr, &pos); + zv = zend_hash_get_current_data_ex(arr, &pos); + } +} + void php_ion_serialize(php_ion_serializer *ser, zval *zv, zval *return_value) { zend_object *zo_opt = NULL, *zo_ser = NULL; @@ -1249,14 +1328,9 @@ void php_ion_serialize(php_ion_serializer *ser, zval *zv, zval *return_value) ser->writer = writer->writer; ser->buffer = &writer->buffer.str; - /* start off with a global PHP annotation instead of repeating it all over the place */ - if (0 == php_ion_globals_serializer_step()) { - ION_STRING is; - ION_CHECK(ion_writer_add_annotation(ser->writer, ion_string_from_cstr(&is, ZEND_STRL("PHP"))), - if (zo_ser) OBJ_RELEASE(zo_ser)); + if (!EG(exception)) { + php_ion_serialize_ex(ser, zv); } - php_ion_serialize_zval(ser, zv); - php_ion_globals_serializer_exit(); /* make sure to flush when done, else str.s might not contain everything until the writer is closed */ ion_writer_flush(ser->writer, NULL); @@ -1438,6 +1512,13 @@ static void php_ion_unserialize_props(php_ion_unserializer *ser, zval *return_va 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); @@ -1460,8 +1541,19 @@ static inline void php_ion_unserialize_hash(php_ion_unserializer *ser, zval *ret php_ion_unserialize_zval(ser, &zvalue, &typ); ION_CATCH(zend_string_release(key)); - zend_symtable_update(HASH_OF(return_value), key, &zvalue); - + // 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); } @@ -1630,10 +1722,10 @@ static inline void php_ion_reader_read_int(ION_READER *reader, zval *return_valu 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 */ @@ -1874,6 +1966,28 @@ unserialize_struct: ; 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) +{ + 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 (!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; @@ -1919,9 +2033,9 @@ void php_ion_unserialize(php_ion_unserializer *ser, zval *zdata, zval *return_va php_ion_reader_ctor(reader); ser->reader = reader->reader; - php_ion_globals_unserializer_step(); - php_ion_unserialize_zval(ser, return_value, NULL); - php_ion_globals_unserializer_exit(); + if (!EG(exception)) { + php_ion_unserialize_ex(ser, return_value); + } OBJ_RELEASE(zo_reader); if (zo_opt) {