Drop array pack/unpack functions

Very unlikely to need these, and I think the inconvenience of being made
to use a buffer for this is probably worth the trade of not maintaining
an extra 50 functions. In any case, writing a large array in particular
probably ought to use a reused buffer to avoid unnecessary allocations.

Author: dktapps

classes/Types.cpp

@@ -35,19 +35,11 @@ ZEND_ARG_OBJ_INFO(0, buffer, pmmp\\encoding\\ByteBufferReader, 0)
 ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_unpack_array, 0, 2, IS_ARRAY, 0)
-ZEND_ARG_TYPE_INFO(0, bytes, IS_STRING, 0)
-ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0)
-ZEND_END_ARG_INFO()
-
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_write_array, 0, 2, IS_VOID, 0)
 ZEND_ARG_OBJ_INFO(0, buffer, pmmp\\encoding\\ByteBufferWriter, 0)
 ZEND_ARG_ARRAY_INFO(0, values, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_pack_array, 0, 2, IS_STRING, 0)
-ZEND_ARG_ARRAY_INFO(0, values, 0)
-ZEND_END_ARG_INFO()
 
 #if PHP_VERSION_ID >= 80400
 static const char* read_zend_long_array_doc_comment = "/**\n\t * @return int[]\n\t * @phpstan-return list<int>\n\t * @throws DataDecodeException\n\t */";
@@ -136,21 +128,6 @@ void ZEND_FASTCALL zif_unpackType(INTERNAL_FUNCTION_PARAMETERS) {
 template<typename TValue>
 using readTypeArrayFunc_t = bool (*) (unsigned char* bytes, size_t used, size_t& offset, size_t count, std::vector<TValue>& resultArray);
 
-template<typename TValue, readTypeArrayFunc_t<TValue> readTypeArray, typename TZendValue>
-inline void readTypeArrayCommon(INTERNAL_FUNCTION_PARAMETERS, byte_buffer_reader_t& reader, zend_long zcount) {
-	if (zcount < 1) {
-		zend_value_error("Count must be at least 1");
-		return;
-	}
-	size_t count = static_cast<size_t>(zcount);
-
-	std::vector<TValue> resultArray;
-	auto bytes = reinterpret_cast<unsigned char*>(ZSTR_VAL(reader.buffer));
-	if (readTypeArray(bytes, ZSTR_LEN(reader.buffer), reader.offset, count, resultArray)) {
-		assignZvalArray(return_value, resultArray, std::type_identity<TZendValue>{});
-	}
-}
-
 template<typename TValue, readTypeArrayFunc_t<TValue> readTypeArray, typename TZendValue>
 void ZEND_FASTCALL zif_readTypeArray(INTERNAL_FUNCTION_PARAMETERS) {
 	zval* object_zv;
@@ -164,20 +141,17 @@ void ZEND_FASTCALL zif_readTypeArray(INTERNAL_FUNCTION_PARAMETERS) {
 
 	object = READER_FROM_ZVAL(object_zv);
 
-	readTypeArrayCommon<TValue, readTypeArray, TZendValue>(INTERNAL_FUNCTION_PARAM_PASSTHRU, object->reader, zcount);
-}
-
-template<typename TValue, readTypeArrayFunc_t<TValue> readTypeArray, typename TZendValue>
-void ZEND_FASTCALL zif_unpackTypeArray(INTERNAL_FUNCTION_PARAMETERS) {
-	zend_long zcount;
-	byte_buffer_reader_t reader = { 0 };
-
-	ZEND_PARSE_PARAMETERS_START_EX(ZEND_PARSE_PARAMS_THROW, 2, 2)
-		Z_PARAM_STR(reader.buffer)
-		Z_PARAM_LONG(zcount)
-	ZEND_PARSE_PARAMETERS_END_EX(return);
+	if (zcount < 1) {
+		zend_value_error("Count must be at least 1");
+		return;
+	}
+	size_t count = static_cast<size_t>(zcount);
 
-	readTypeArrayCommon<TValue, readTypeArray, TZendValue>(INTERNAL_FUNCTION_PARAM_PASSTHRU, reader, zcount);
+	std::vector<TValue> resultArray;
+	auto bytes = reinterpret_cast<unsigned char*>(ZSTR_VAL(object->reader.buffer));
+	if (readTypeArray(bytes, ZSTR_LEN(object->reader.buffer), object->reader.offset, count, resultArray)) {
+		assignZvalArray(return_value, resultArray, std::type_identity<TZendValue>{});
+	}
 }
 
 //this must be reimplemented for any new zend types handled, because ZPP macros can't be easily templated
@@ -320,21 +294,6 @@ bool typeHashTableToArray(HashTable* valueArrayHt, std::vector<TValue>& valueArr
 template<typename TValue>
 using writeTypeArrayFunc_t = void (*)(zend_string*& buffer, size_t& offset, std::vector<TValue>& value);
 
-template<typename TValue, writeTypeArrayFunc_t<TValue> writeTypeFunc, typename TZendValue>
-static inline bool writeTypeArrayCommon(INTERNAL_FUNCTION_PARAMETERS, byte_buffer_writer_t& writer, HashTable* valueArrayHt) {
-	std::vector<TValue> valueArray;
-
-	if (!typeHashTableToArray(valueArrayHt, valueArray, std::type_identity<TZendValue>{})) {
-		return false;
-	}
-
-	writeTypeFunc(writer.buffer, writer.offset, valueArray);
-	if (writer.offset > writer.used) {
-		writer.used = writer.offset;
-	}
-	return true;
-}
-
 template<typename TValue, writeTypeArrayFunc_t<TValue> writeTypeFunc, typename TZendValue>
 void ZEND_FASTCALL zif_writeTypeArray(INTERNAL_FUNCTION_PARAMETERS) {
 	byte_buffer_writer_zend_object* object;
@@ -348,27 +307,16 @@ void ZEND_FASTCALL zif_writeTypeArray(INTERNAL_FUNCTION_PARAMETERS) {
 
 	object = WRITER_FROM_ZVAL(objectZv);
 
-	writeTypeArrayCommon<TValue, writeTypeFunc, TZendValue>(INTERNAL_FUNCTION_PARAM_PASSTHRU, object->writer, valueArrayHt);
-}
-
-template<typename TValue, writeTypeArrayFunc_t<TValue> writeTypeFunc, typename TZendValue>
-void ZEND_FASTCALL zif_packTypeArray(INTERNAL_FUNCTION_PARAMETERS) {
-	byte_buffer_writer_t writer = { 0 };
-	HashTable* valueArrayHt;
-
-	ZEND_PARSE_PARAMETERS_START_EX(ZEND_PARSE_PARAMS_THROW, 1, 1)
-		Z_PARAM_ARRAY_HT(valueArrayHt)
-	ZEND_PARSE_PARAMETERS_END();
-
-	writer.buffer = zend_empty_string;
+	std::vector<TValue> valueArray;
 
-	if (!writeTypeArrayCommon<TValue, writeTypeFunc, TZendValue>(INTERNAL_FUNCTION_PARAM_PASSTHRU, writer, valueArrayHt)) {
-		//extracting args from the array may have failed
+	if (!typeHashTableToArray(valueArrayHt, valueArray, std::type_identity<TZendValue>{})) {
 		return;
 	}
 
-	RETVAL_STRINGL(ZSTR_VAL(writer.buffer), writer.used);
-	zend_string_release_ex(writer.buffer, 0);
+	writeTypeFunc(object->writer.buffer, object->writer.offset, valueArray);
+	if (object->writer.offset > object->writer.used) {
+		object->writer.used = object->writer.offset;
+	}
 }
 
 ZEND_NAMED_FUNCTION(pmmp_encoding_private_constructor) {
@@ -424,24 +372,11 @@ ZEND_NAMED_FUNCTION(pmmp_encoding_private_constructor) {
 		arginfo_read_array, \
 		read_##zend_type##_array_doc_comment \
 	) \
-	BC_ZEND_RAW_FENTRY_WITH_DOC_COMMENT( \
-		"unpack" zend_name "Array", \
-		(zif_unpackTypeArray<native_type, read_complex_type, zend_type>), \
-		arginfo_unpack_array, \
-		read_##zend_type##_array_doc_comment \
-	) \
-	\
 	BC_ZEND_RAW_FENTRY_WITH_DOC_COMMENT( \
 		"write" zend_name "Array", \
 		(zif_writeTypeArray<native_type, write_complex_type, zend_type>), \
 		arginfo_write_array, \
 		write_##zend_type##_array_doc_comment \
-	) \
-	BC_ZEND_RAW_FENTRY_WITH_DOC_COMMENT( \
-		"pack" zend_name "Array", \
-		(zif_packTypeArray<native_type, write_complex_type, zend_type>), \
-		arginfo_pack_array, \
-		write_##zend_type##_array_doc_comment \
 	)
 
 #define FIXED_TYPE_ARRAY_ENTRIES(zend_name, native_type, zend_type, byte_order) \