From ef61a701d0a41dcdef035799fe7d8731be1aaa60 Mon Sep 17 00:00:00 2001 From: Timm Friebe Date: Sun, 27 Apr 2025 11:03:13 +0200 Subject: [PATCH 1/5] Add incremental zstd_(un)compress_init() and zstd_(un)compress_add() --- README.md | 97 +++++++++++++- tests/inc.phpt | 27 ++++ tests/inc_comp.phpt | 45 +++++++ tests/inc_decomp.phpt | 39 ++++++ tests/inc_ns.phpt | 27 ++++ zstd.c | 295 +++++++++++++++++++++++++++++++++++++----- zstd.stub.php | 16 +++ 7 files changed, 514 insertions(+), 32 deletions(-) create mode 100755 tests/inc.phpt create mode 100755 tests/inc_comp.phpt create mode 100755 tests/inc_decomp.phpt create mode 100755 tests/inc_ns.phpt diff --git a/README.md b/README.md index 92c91ae..1be2c04 100644 --- a/README.md +++ b/README.md @@ -104,6 +104,11 @@ LIBZSTD\_VERSION\_STRING | libzstd version string * zstd\_uncompress — Zstandard decompression * zstd\_compress\_dict — Zstandard compression using a digested dictionary * zstd\_uncompress\_dict — Zstandard decompression using a digested dictionary +* zstd\_compress_\init — Initialize an incremental compress context +* zstd\_compress\_add — Incrementally compress data +* zstd\_uncompress_\init — Initialize an incremental uncompress context +* zstd\_uncompress\_add — Incrementally uncompress data + ### zstd\_compress — Zstandard compression @@ -209,6 +214,88 @@ Zstandard decompression using a digested dictionary. Returns the decompressed data or FALSE if an error occurred. +### zstd\_compress\_init — Initialize an incremental compress context + +#### Description + +resource **zstd\_compress\_init** ( [ int _$level_ = ZSTD_COMPRESS_LEVEL_DEFAULT ] ) + +Initialize an incremental compress context + +#### Parameters + +* _level_ + + The higher the level, the slower the compression. (Defaults to `ZSTD_COMPRESS_LEVEL_DEFAULT`) + +#### Return Values + +Returns a zstd context instance on success, or FALSE on failure + + +### zstd\_compress\_add — Incrementally compress data + +#### Description + +string **zstd\_compress\_add** ( ZstdContext _$context_, string _$data_ [, bool _$end_ = false ] ) + +Incrementally compress data + +#### Parameters + +* _context_ + + A context created with `zstd_compress_init()`. + +* _data_ + + A chunk of data to compress. + +* _end_ + + Set to true to terminate with the last chunk of data. + +#### Return Values + +Returns a chunk of compressed data, or FALSE on failure. + + +### zstd\_uncompress\_init — Initialize an incremental uncompress context + +#### Description + +resource **zstd\_uncompress\_init** ( void ) + +Initialize an incremental uncompress context + +#### Return Values + +Returns a zstd context instance success, or FALSE on failure + + +### zstd\_uncompress\_add — Incrementally uncompress data + +#### Description + +string **zstd\_uncompress\_add** ( ZstdContext _$context_, string _$data_ ) + +Incrementally uncompress data + +#### Parameters + +* _context_ + + A context created with `zstd_uncompress_init()`. + +* _data_ + + A chunk of compressed data. + +#### Return Values + +Returns a chunk of uncompressed data, or FALSE on failure. + + ## Namespace ``` @@ -218,10 +305,16 @@ function compress( $data [, $level = 3 ] ) function uncompress( $data ) function compress_dict ( $data, $dict ) function uncompress_dict ( $data, $dict ) +function compress_init ( [ $level = 3 ] ) +function compress_add ( $context, $data [, $end = false ] ) +function uncompress_init () +function uncompress_add ( $context, $data ) + ``` -`zstd_compress`, `zstd_uncompress`, `zstd_compress_dict` and -`zstd_uncompress_dict` function alias. +`zstd_compress`, `zstd_uncompress`, `zstd_compress_dict`, +`zstd_uncompress_dict`, `zstd_compress_init`, `zstd_compress_add`, +`zstd_uncompress_init` and `zstd_uncompress_add` function alias. ## Streams diff --git a/tests/inc.phpt b/tests/inc.phpt new file mode 100755 index 0000000..ddd329f --- /dev/null +++ b/tests/inc.phpt @@ -0,0 +1,27 @@ +--TEST-- +Incremental compression and decompression +--FILE-- + +===Done=== +--EXPECTF-- +Hello, World! +Hello, World! +===Done=== diff --git a/tests/inc_comp.phpt b/tests/inc_comp.phpt new file mode 100755 index 0000000..237d255 --- /dev/null +++ b/tests/inc_comp.phpt @@ -0,0 +1,45 @@ +--TEST-- +Incremental compression +--FILE-- + +===Done=== +--EXPECTF-- +int(128) +object(ZstdContext)#%d (0) { +} +int(%d) +bool(true) +bool(true) +int(512) +object(ZstdContext)#%d (0) { +} +int(%d) +bool(true) +bool(true) +int(1024) +object(ZstdContext)#%d (0) { +} +int(%d) +bool(true) +bool(true) +===Done=== diff --git a/tests/inc_decomp.phpt b/tests/inc_decomp.phpt new file mode 100755 index 0000000..0639f47 --- /dev/null +++ b/tests/inc_decomp.phpt @@ -0,0 +1,39 @@ +--TEST-- +Incremental decompression +--FILE-- + +===Done=== +--EXPECTF-- +int(128) +object(ZstdContext)#%d (0) { +} +bool(true) +int(512) +object(ZstdContext)#%d (0) { +} +bool(true) +int(1024) +object(ZstdContext)#%d (0) { +} +bool(true) +===Done=== diff --git a/tests/inc_ns.phpt b/tests/inc_ns.phpt new file mode 100755 index 0000000..746d520 --- /dev/null +++ b/tests/inc_ns.phpt @@ -0,0 +1,27 @@ +--TEST-- +Incremental compression and decompression (namespaces) +--FILE-- + +===Done=== +--EXPECTF-- +Hello, World! +Hello, World! +===Done=== diff --git a/zstd.c b/zstd.c index 4b1ba25..c33607c 100644 --- a/zstd.c +++ b/zstd.c @@ -35,6 +35,7 @@ #include #include #include +#include #endif #include "php_zstd.h" @@ -58,12 +59,87 @@ #define zend_string_efree(string) zend_string_free(string) #endif +zend_class_entry *zstd_context_ptr; +static const zend_function_entry zstd_context_methods[] = { + ZEND_FE_END +}; + +struct _php_zstd_context { + ZSTD_CCtx* cctx; + ZSTD_DCtx* dctx; + ZSTD_CDict *cdict; + ZSTD_inBuffer input; + ZSTD_outBuffer output; +}; + +typedef struct { + php_zstd_context *ctx; + zend_object zo; +} zstd_context_object; + +static inline zstd_context_object *zstd_context_object_from_obj(zend_object *obj) { + return (zstd_context_object*)((char*)(obj) - XtOffsetOf(zstd_context_object, zo)); +} + +#define Z_ZSTD_CONTEXT_P(zv) zstd_context_object_from_obj(Z_OBJ_P((zv))) + +static zend_object_handlers zstd_context_object_handlers; + +static php_zstd_context* php_zstd_output_handler_context_init(void) +{ + php_zstd_context *ctx + = (php_zstd_context *) ecalloc(1, sizeof(php_zstd_context)); + ctx->cctx = NULL; + ctx->dctx = NULL; + return ctx; +} + +static void php_zstd_output_handler_context_free(php_zstd_context *ctx) +{ + if (ctx->cctx) { + ZSTD_freeCCtx(ctx->cctx); + ctx->cctx = NULL; + } + if (ctx->dctx) { + ZSTD_freeDCtx(ctx->dctx); + ctx->dctx = NULL; + } + if (ctx->cdict) { + ZSTD_freeCDict(ctx->cdict); + ctx->cdict = NULL; + } + if (ctx->output.dst) { + efree(ctx->output.dst); + ctx->output.dst = NULL; + } +} + +static zend_object *zstd_context_objects_new(zend_class_entry *class_type) +{ + zstd_context_object *intern = zend_object_alloc(sizeof(zstd_context_object), class_type); + + zend_object_std_init(&intern->zo, class_type); + object_properties_init(&intern->zo, class_type); + return &intern->zo; +} + +static void zstd_context_free_objects_storage(zend_object *object) +{ + zstd_context_object *intern = zstd_context_object_from_obj(object); + if (intern->ctx) { + php_zstd_output_handler_context_free(intern->ctx); + efree(intern->ctx); + } + zend_object_std_dtor(&intern->zo); +} + #define ZSTD_WARNING(...) \ php_error_docref(NULL, E_WARNING, __VA_ARGS__) #define ZSTD_IS_ERROR(result) \ UNEXPECTED(ZSTD_isError(result)) +/* One-shot functions */ ZEND_BEGIN_ARG_INFO_EX(arginfo_zstd_compress, 0, 0, 1) ZEND_ARG_INFO(0, data) ZEND_ARG_INFO(0, level) @@ -84,6 +160,25 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_zstd_uncompress_dict, 0, 0, 2) ZEND_ARG_INFO(0, dictBuffer) ZEND_END_ARG_INFO() +/* Incremental functions */ +ZEND_BEGIN_ARG_INFO_EX(arginfo_zstd_compress_init, 0, 0, 0) + ZEND_ARG_INFO(0, level) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_zstd_compress_add, 0, 0, 2) + ZEND_ARG_INFO(0, context) + ZEND_ARG_INFO(0, data) + ZEND_ARG_INFO(0, end) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_zstd_uncompress_init, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_zstd_uncompress_add, 0, 0, 2) + ZEND_ARG_INFO(0, context) + ZEND_ARG_INFO(0, data) +ZEND_END_ARG_INFO() + #if PHP_VERSION_ID >= 80000 #if PHP_VERSION_ID >= 80100 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_ob_zstd_handler, 0, 2, MAY_BE_STRING|MAY_BE_FALSE) @@ -393,6 +488,150 @@ ZEND_FUNCTION(zstd_uncompress_dict) RETVAL_NEW_STR(output); } +ZEND_FUNCTION(zstd_compress_init) +{ + zend_long level = DEFAULT_COMPRESS_LEVEL; + + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_LONG(level) + ZEND_PARSE_PARAMETERS_END(); + + if (!zstd_check_compress_level(level)) { + RETURN_FALSE; + } + + php_zstd_context *ctx = php_zstd_output_handler_context_init(); + + ctx->cctx = ZSTD_createCCtx(); + if (ctx->cctx == NULL) { + efree(ctx); + ZSTD_WARNING("ZSTD_createCCtx() error"); + RETURN_FALSE; + } + ctx->cdict = NULL; + + ZSTD_CCtx_reset(ctx->cctx, ZSTD_reset_session_only); + ZSTD_CCtx_setParameter(ctx->cctx, ZSTD_c_compressionLevel, level); + + ctx->output.size = ZSTD_CStreamOutSize(); + ctx->output.dst = emalloc(ctx->output.size); + ctx->output.pos = 0; + + object_init_ex(return_value, zstd_context_ptr); + Z_ZSTD_CONTEXT_P(return_value)->ctx = ctx; +} + +ZEND_FUNCTION(zstd_compress_add) +{ + zend_object *context; + php_zstd_context *ctx; + char *in_buf; + size_t in_size; + zend_bool end = 0; + smart_string out = {0}; + + ZEND_PARSE_PARAMETERS_START(2, 3) + Z_PARAM_OBJ_OF_CLASS(context, zstd_context_ptr) + Z_PARAM_STRING(in_buf, in_size) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(end) + ZEND_PARSE_PARAMETERS_END(); + + ctx = zstd_context_object_from_obj(context)->ctx; + if (ctx == NULL || ctx->cctx == NULL) { + php_error_docref(NULL, E_WARNING, + "ZStandard incremental compress resource failed"); + RETURN_FALSE; + } + + ZSTD_inBuffer in = { in_buf, in_size, 0 }; + size_t res; + + do { + ctx->output.pos = 0; + res = ZSTD_compressStream2(ctx->cctx, &ctx->output, + &in, end ? ZSTD_e_end : ZSTD_e_flush); + if (ZSTD_isError(res)) { + php_error_docref(NULL, E_WARNING, + "libzstd error %s\n", ZSTD_getErrorName(res)); + smart_string_free(&out); + RETURN_FALSE; + } + smart_string_appendl(&out, ctx->output.dst, ctx->output.pos); + } while (res > 0); + + RETVAL_STRINGL(out.c, out.len); + smart_string_free(&out); +} + +ZEND_FUNCTION(zstd_uncompress_init) +{ + php_zstd_context *ctx = php_zstd_output_handler_context_init(); + + ctx->dctx = ZSTD_createDCtx(); + if (ctx->dctx == NULL) { + efree(ctx); + ZSTD_WARNING("ZSTD_createDCtx() error"); + RETURN_FALSE; + } + ctx->cdict = NULL; + + ZSTD_DCtx_reset(ctx->dctx, ZSTD_reset_session_only); + + ctx->output.size = ZSTD_DStreamOutSize(); + ctx->output.dst = emalloc(ctx->output.size); + ctx->output.pos = 0; + + object_init_ex(return_value, zstd_context_ptr); + Z_ZSTD_CONTEXT_P(return_value)->ctx = ctx; +} + +ZEND_FUNCTION(zstd_uncompress_add) +{ + zend_object *context; + php_zstd_context *ctx; + char *in_buf; + size_t in_size; + smart_string out = {0}; + + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_OBJ_OF_CLASS(context, zstd_context_ptr) + Z_PARAM_STRING(in_buf, in_size) + ZEND_PARSE_PARAMETERS_END(); + + ctx = zstd_context_object_from_obj(context)->ctx; + if (ctx == NULL || ctx->dctx == NULL) { + php_error_docref(NULL, E_WARNING, + "ZStandard incremental uncompress resource failed"); + RETURN_FALSE; + } + + ZSTD_inBuffer in = { in_buf, in_size, 0 }; + size_t res = 1; + const size_t grow = ZSTD_DStreamOutSize(); + + while (in.pos < in.size && res > 0) { + if (ctx->output.pos == ctx->output.size) { + ctx->output.size += grow; + ctx->output.dst = erealloc(ctx->output.dst, ctx->output.size); + } + + ctx->output.pos = 0; + res = ZSTD_decompressStream(ctx->dctx, &ctx->output, &in); + if (ZSTD_isError(res)) { + php_error_docref(NULL, E_WARNING, + "libzstd error %s\n", ZSTD_getErrorName(res)); + smart_string_free(&out); + RETURN_FALSE; + } + + smart_string_appendl(&out, ctx->output.dst, ctx->output.pos); + } + + RETVAL_STRINGL(out.c, out.len); + smart_string_free(&out); +} typedef struct _php_zstd_stream_data { char *bufin, *bufout; @@ -835,13 +1074,6 @@ static int APC_UNSERIALIZER_NAME(zstd)(APC_UNSERIALIZER_ARGS) #if PHP_VERSION_ID >= 80000 #define PHP_ZSTD_OUTPUT_HANDLER_NAME "zstd output compression" -struct _php_zstd_context { - ZSTD_CCtx* cctx; - ZSTD_CDict *cdict; - ZSTD_inBuffer input; - ZSTD_outBuffer output; -}; - static int php_zstd_output_encoding(void) { zval *enc; @@ -866,13 +1098,6 @@ static int php_zstd_output_encoding(void) return PHP_ZSTD_G(compression_coding); } -static php_zstd_context* php_zstd_output_handler_context_init(void) -{ - php_zstd_context *ctx - = (php_zstd_context *) ecalloc(1, sizeof(php_zstd_context)); - return ctx; -} - static void php_zstd_output_handler_load_dict(php_zstd_context *ctx, int level) { @@ -944,22 +1169,6 @@ static zend_result php_zstd_output_handler_context_start(php_zstd_context *ctx) return SUCCESS; } -static void php_zstd_output_handler_context_free(php_zstd_context *ctx) -{ - if (ctx->cctx) { - ZSTD_freeCCtx(ctx->cctx); - ctx->cctx = NULL; - } - if (ctx->cdict) { - ZSTD_freeCDict(ctx->cdict); - ctx->cdict = NULL; - } - if (ctx->output.dst) { - efree(ctx->output.dst); - ctx->output.dst = NULL; - } -} - static void php_zstd_output_handler_context_dtor(void *opaq) { php_zstd_context *ctx = (php_zstd_context *) opaq; @@ -1300,6 +1509,18 @@ ZEND_MINIT_FUNCTION(zstd) php_register_url_stream_wrapper(STREAM_NAME, &php_stream_zstd_wrapper); + zend_class_entry ce; + INIT_CLASS_ENTRY(ce, "ZstdContext", zstd_context_methods); + zstd_context_ptr = zend_register_internal_class_ex(&ce, NULL); + + memcpy(&zstd_context_object_handlers, &std_object_handlers, sizeof(zend_object_handlers)); + zstd_context_object_handlers.offset = XtOffsetOf(zstd_context_object, zo); + zstd_context_object_handlers.free_obj = zstd_context_free_objects_storage; + zstd_context_object_handlers.clone_obj = NULL; + + zstd_context_ptr->create_object = zstd_context_objects_new; + zstd_context_ptr->default_object_handlers = &zstd_context_object_handlers; + #if defined(HAVE_APCU_SUPPORT) apc_register_serializer("zstd", APC_SERIALIZER_NAME(zstd), @@ -1397,6 +1618,11 @@ static zend_function_entry zstd_functions[] = { ZEND_FALIAS(zstd_decompress_usingcdict, zstd_uncompress_dict, arginfo_zstd_uncompress_dict) + ZEND_FE(zstd_compress_init, arginfo_zstd_compress_init) + ZEND_FE(zstd_compress_add, arginfo_zstd_compress_add) + ZEND_FE(zstd_uncompress_init, arginfo_zstd_uncompress_init) + ZEND_FE(zstd_uncompress_add, arginfo_zstd_uncompress_add) + ZEND_NS_FALIAS(PHP_ZSTD_NS, compress, zstd_compress, arginfo_zstd_compress) ZEND_NS_FALIAS(PHP_ZSTD_NS, uncompress, @@ -1416,6 +1642,15 @@ static zend_function_entry zstd_functions[] = { ZEND_NS_FALIAS(PHP_ZSTD_NS, decompress_usingcdict, zstd_uncompress_dict, arginfo_zstd_uncompress_dict) + ZEND_NS_FALIAS(PHP_ZSTD_NS, compress_init, + zstd_compress_init, arginfo_zstd_compress_init) + ZEND_NS_FALIAS(PHP_ZSTD_NS, compress_add, + zstd_compress_add, arginfo_zstd_compress_add) + ZEND_NS_FALIAS(PHP_ZSTD_NS, uncompress_init, + zstd_uncompress_init, arginfo_zstd_uncompress_init) + ZEND_NS_FALIAS(PHP_ZSTD_NS, uncompress_add, + zstd_uncompress_add, arginfo_zstd_uncompress_add) + #if PHP_VERSION_ID >= 80000 ZEND_FE(ob_zstd_handler, arginfo_ob_zstd_handler) #endif diff --git a/zstd.stub.php b/zstd.stub.php index 9169c6f..efe25b2 100644 --- a/zstd.stub.php +++ b/zstd.stub.php @@ -10,6 +10,14 @@ function zstd_compress_dict(string $data, string $dict, int $level = DEFAULT_COM function zstd_uncompress_dict(string $data, string $dict): string|false {} + function zstd_compress_init(int $level= 3): ZstdContext|false {} + + function zstd_compress_add(ZstdContext $context, string $data, bool $end = false): string|false {} + + function zstd_uncompress_init(): ZstdContext|false {} + + function zstd_uncompress_add(ZstdContext $context, string $data): string|false {} + } namespace Zstd { @@ -22,4 +30,12 @@ function compress_dict(string $data, string $dict, int $level = 3): string|false function uncompress_dict(string $data, string $dict): string|false {} + function compress_init(int $level= 3): ZstdContext|false {} + + function compress_add(ZstdContext $context, string $data, bool $end = false): string|false {} + + function uncompress_init(): ZstdContext|false {} + + function uncompress_add(ZstdContext $context, string $data): string|false {} + } From 901c5875dea1bbef541cb788ec6c2b13db166328 Mon Sep 17 00:00:00 2001 From: Timm Friebe Date: Sun, 27 Apr 2025 11:05:49 +0200 Subject: [PATCH 2/5] Add ZstdContext class stub --- zstd.stub.php | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/zstd.stub.php b/zstd.stub.php index efe25b2..3b8c157 100644 --- a/zstd.stub.php +++ b/zstd.stub.php @@ -2,6 +2,8 @@ namespace { + class ZstdContext {} + function zstd_compress(string $data, int $level = 3): string|false {} function zstd_uncompress(string $data): string|false {} @@ -22,6 +24,8 @@ function zstd_uncompress_add(ZstdContext $context, string $data): string|false { namespace Zstd { + class ZstdContext {} + function compress(string $data, int $level = 3): string|false {} function uncompress(string $data): string|false {} From ce0145f368c022f935a32cd18159206b85ff0caa Mon Sep 17 00:00:00 2001 From: Timm Friebe Date: Sun, 27 Apr 2025 11:14:53 +0200 Subject: [PATCH 3/5] Fix wording --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 1be2c04..ce0efa5 100644 --- a/README.md +++ b/README.md @@ -104,9 +104,9 @@ LIBZSTD\_VERSION\_STRING | libzstd version string * zstd\_uncompress — Zstandard decompression * zstd\_compress\_dict — Zstandard compression using a digested dictionary * zstd\_uncompress\_dict — Zstandard decompression using a digested dictionary -* zstd\_compress_\init — Initialize an incremental compress context +* zstd\_compress\_init — Initialize an incremental compress context * zstd\_compress\_add — Incrementally compress data -* zstd\_uncompress_\init — Initialize an incremental uncompress context +* zstd\_uncompress\_init — Initialize an incremental uncompress context * zstd\_uncompress\_add — Incrementally uncompress data @@ -270,7 +270,7 @@ Initialize an incremental uncompress context #### Return Values -Returns a zstd context instance success, or FALSE on failure +Returns a zstd context instance on success, or FALSE on failure ### zstd\_uncompress\_add — Incrementally uncompress data @@ -314,7 +314,7 @@ function uncompress_add ( $context, $data ) `zstd_compress`, `zstd_uncompress`, `zstd_compress_dict`, `zstd_uncompress_dict`, `zstd_compress_init`, `zstd_compress_add`, -`zstd_uncompress_init` and `zstd_uncompress_add` function alias. +`zstd_uncompress_init` and `zstd_uncompress_add` function aliases. ## Streams From 473b548fba9bd495fd54cea21738b17011a17010 Mon Sep 17 00:00:00 2001 From: Timm Friebe Date: Sun, 27 Apr 2025 11:14:59 +0200 Subject: [PATCH 4/5] Add php_zstd_context alias --- zstd.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/zstd.c b/zstd.c index c33607c..420c185 100644 --- a/zstd.c +++ b/zstd.c @@ -64,13 +64,13 @@ static const zend_function_entry zstd_context_methods[] = { ZEND_FE_END }; -struct _php_zstd_context { +typedef struct _php_zstd_context { ZSTD_CCtx* cctx; ZSTD_DCtx* dctx; ZSTD_CDict *cdict; ZSTD_inBuffer input; ZSTD_outBuffer output; -}; +} php_zstd_context; typedef struct { php_zstd_context *ctx; From cef80f085f5ed346c64144950464759046b771e0 Mon Sep 17 00:00:00 2001 From: Timm Friebe Date: Sun, 27 Apr 2025 11:17:13 +0200 Subject: [PATCH 5/5] ZstdContext only exists in global namespace --- zstd.stub.php | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/zstd.stub.php b/zstd.stub.php index 3b8c157..d911ab9 100644 --- a/zstd.stub.php +++ b/zstd.stub.php @@ -2,7 +2,7 @@ namespace { - class ZstdContext {} + final class ZstdContext {} function zstd_compress(string $data, int $level = 3): string|false {} @@ -12,7 +12,7 @@ function zstd_compress_dict(string $data, string $dict, int $level = DEFAULT_COM function zstd_uncompress_dict(string $data, string $dict): string|false {} - function zstd_compress_init(int $level= 3): ZstdContext|false {} + function zstd_compress_init(int $level = 3): ZstdContext|false {} function zstd_compress_add(ZstdContext $context, string $data, bool $end = false): string|false {} @@ -24,8 +24,6 @@ function zstd_uncompress_add(ZstdContext $context, string $data): string|false { namespace Zstd { - class ZstdContext {} - function compress(string $data, int $level = 3): string|false {} function uncompress(string $data): string|false {} @@ -34,12 +32,12 @@ function compress_dict(string $data, string $dict, int $level = 3): string|false function uncompress_dict(string $data, string $dict): string|false {} - function compress_init(int $level= 3): ZstdContext|false {} + function compress_init(int $level = 3): \ZstdContext|false {} - function compress_add(ZstdContext $context, string $data, bool $end = false): string|false {} + function compress_add(\ZstdContext $context, string $data, bool $end = false): string|false {} - function uncompress_init(): ZstdContext|false {} + function uncompress_init(): \ZstdContext|false {} - function uncompress_add(ZstdContext $context, string $data): string|false {} + function uncompress_add(\ZstdContext $context, string $data): string|false {} }