fx.compression: convert to new assembly build system

CMakeLists.txt

@@ -12,6 +12,7 @@ set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 set(fx_all_assemblies
 	fx.runtime
 	fx.collections
+	fx.compression
 	fx.io)
 
 if (NOT DEFINED fx_assemblies)
@@ -59,4 +60,11 @@ if ("fx.io" IN_LIST fx_assemblies)
 		DEPENDENCIES fx.runtime)
 endif ()
 
+if ("fx.compression" IN_LIST fx_assemblies)
+	add_fx_assembly(
+		NAME fx.compression
+		NAMESPACES fx.compression
+		DEPENDENCIES fx.runtime)
+endif ()
+
 add_executable(dynamic-test test/dynamic-test.c)

assemblies/fx.compression.c

@@ -0,0 +1,7 @@
+#include <fx/macros.h>
+#include <fx/reflection/assembly.h>
+
+FX_ASSEMBLY_BEGIN()
+	FX_ASSEMBLY_NAME("fx.compression");
+	FX_ASSEMBLY_VERSION(1, 0, 0, 0);
+FX_ASSEMBLY_END()

cmake/Templates.cmake

@@ -39,17 +39,8 @@ function(add_fx_assembly)
 	set_target_properties(${assembly_target_name}
 		PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
-	foreach (dep ${arg_DEPENDENCIES})
-		target_link_libraries(${assembly_target_name} ${dep})
-	endforeach (dep)
-
-	foreach (lib ${arg_LIBS})
-		target_link_libraries(${assembly_target_name} ${lib})
-	endforeach (lib)
-
-	foreach (dir ${arg_INCLUDE_DIRS})
-		target_include_directories(${assembly_target_name} PRIVATE ${dir})
-	endforeach (dir)
+	target_link_libraries(${assembly_target_name} ${internal_libs} ${arg_DEPENDENCIES})
+	target_include_directories(${assembly_target_name} PRIVATE ${internal_include_dirs})
 
 	foreach (def ${arg_DEFINES})
 		target_compile_definitions(${assembly_target_name} PRIVATE ${def})
@@ -79,13 +70,13 @@ macro(export_fx_namespace_details ns_name)
 
 	set(namespace_include_paths ${CMAKE_CURRENT_SOURCE_DIR}/include PARENT_SCOPE)
 
-	file(GLOB namespace_sources
+	file(GLOB base_namespace_sources
 		*.c *.h
 		${CMAKE_CURRENT_SOURCE_DIR}/include/${namespace_path}/*.h)
 
 	foreach (dir ${source_dirs})
 		file(GLOB dir_sources ${dir}/*.c ${dir}/*.h)
-		set(namespace_sources ${namespace_sources} ${dir_sources})
+		set(dir_namespace_sources ${dir_namespace_sources} ${dir_sources})
 	endforeach (dir)
 
 	file(GLOB sys_sources
@@ -94,8 +85,13 @@ macro(export_fx_namespace_details ns_name)
 	file(GLOB headers include/${namespace_path}/*.h)
 	set(namespace_sources
 		${namespace_sources}
+		${base_namespace_sources}
+		${dir_namespace_sources}
 		${sys_sources}
 		${headers}
 		PARENT_SCOPE)
+	set(internal_libs ${internal_libs} PARENT_SCOPE)
+	set(internal_include_dirs ${internal_include_dirs} PARENT_SCOPE)
+	set(internal_defines ${internal_defines} PARENT_SCOPE)
 endmacro(export_fx_namespace_details)
 

fx.compression/CMakeLists.txt

@@ -3,17 +3,18 @@ include(../cmake/Templates.cmake)
 find_package(ZSTD)
 
 if (ZSTD_FOUND)
-	set(libs ${libs} ${ZSTD_LIBRARY})
-	set(include_dirs ${include_dirs} ${ZSTD_INCLUDE_DIR})
-	set(function_sources ${function_sources} ${CMAKE_CURRENT_SOURCE_DIR}/function/zstd.c)
-	set(defines ${defines} FX_COMPRESSOR_SUPPORTED_ZSTD)
-	message(STATUS "Enabling ZSTD support in fx-compress")
+	set(internal_libs ${libs} ${ZSTD_LIBRARY})
+	set(internal_include_dirs ${include_dirs} ${ZSTD_INCLUDE_DIR})
+	set(internal_defines ${defines} FX_COMPRESSOR_SUPPORTED_ZSTD)
+	set(namespace_sources ${namespace_sources} ${CMAKE_CURRENT_SOURCE_DIR}/function/zstd.c)
+	message(STATUS "Enabling ZSTD support in fx.compression")
 endif ()
 
-add_fx_module(
-	NAME compress
-	DEPENDENCIES core
-	EXTRA_SOURCES ${function_sources}
-	DEFINES ${defines}
-	LIBS ${libs}
-	INCLUDE_DIRS ${include_dirs})
+#add_fx_module(
+#	NAME compress
+#	DEPENDENCIES core
+#	EXTRA_SOURCES ${function_sources}
+#	DEFINES ${defines}
+#	LIBS ${libs}
+#	INCLUDE_DIRS ${include_dirs})
+export_fx_namespace_details(fx.compression)

fx.compression/compressor.c

@@ -1,15 +1,15 @@
 #include <assert.h>
-#include <fx/compress/compressor.h>
-#include <fx/core/ringbuffer.h>
+#include <fx/compression/compressor.h>
+#include <fx/ringbuffer.h>
 #include <stdlib.h>
 #include <string.h>
 
 #define COMPRESSOR_DISPATCH_STATIC(func, compressor, ...)                      \
 	do {                                                                   \
 		struct compressor_data _compressor;                            \
-		enum fx_status status                                           \
+		enum fx_status status                                          \
 			= compressor_get_data(compressor, &_compressor);       \
-		if (!FX_OK(status)) {                                           \
+		if (!FX_OK(status)) {                                          \
 			return status;                                         \
 		}                                                              \
 		return func(&_compressor, __VA_ARGS__);                        \
@@ -17,9 +17,9 @@
 #define COMPRESSOR_DISPATCH_STATIC_0(func, compressor)                         \
 	do {                                                                   \
 		struct compressor_data _compressor;                            \
-		enum fx_status status                                           \
+		enum fx_status status                                          \
 			= compressor_get_data(compressor, &_compressor);       \
-		if (!FX_OK(status)) {                                           \
+		if (!FX_OK(status)) {                                          \
 			return status;                                         \
 		}                                                              \
 		return func(&_compressor);                                     \
@@ -36,16 +36,21 @@ struct compressor_data {
 /*** PRIVATE FUNCTIONS ********************************************************/
 
 static enum fx_status compressor_get_data(
-	fx_compressor *compressor, struct compressor_data *out)
+	fx_compressor *compressor,
+	struct compressor_data *out)
 {
 	out->c_obj = compressor;
 	return fx_object_get_data(
-		compressor, FX_TYPE_COMPRESSOR, NULL, (void **)&out->c_data,
+		compressor,
+		FX_TYPE_COMPRESSOR,
+		NULL,
+		(void **)&out->c_data,
 		(void **)&out->c_ops);
 }
 
 static enum fx_status compressor_get_mode(
-	struct compressor_data *p, enum fx_compressor_mode *out)
+	struct compressor_data *p,
+	enum fx_compressor_mode *out)
 {
 	if (out) {
 		*out = p->c_data->c_mode;
@@ -55,7 +60,8 @@ static enum fx_status compressor_get_mode(
 }
 
 static enum fx_status compressor_set_mode(
-	struct compressor_data *p, enum fx_compressor_mode mode)
+	struct compressor_data *p,
+	enum fx_compressor_mode mode)
 {
 	if (!p->c_ops->c_set_mode) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -65,7 +71,9 @@ static enum fx_status compressor_set_mode(
 }
 
 static enum fx_status compressor_set_buffer(
-	struct compressor_data *p, fx_ringbuffer *inbuf, fx_ringbuffer *outbuf)
+	struct compressor_data *p,
+	fx_ringbuffer *inbuf,
+	fx_ringbuffer *outbuf)
 {
 	p->c_data->c_in = inbuf;
 	p->c_data->c_out = outbuf;
@@ -154,14 +162,18 @@ static bool compressor_eof(const struct compressor_data *p)
 /*** PUBLIC FUNCTIONS *********************************************************/
 
 enum fx_status fx_compressor_get_buffer_size(
-	fx_type type, fx_compressor_mode mode, size_t *inbuf_size, size_t *outbuf_size)
+	fx_type type,
+	fx_compressor_mode mode,
+	size_t *inbuf_size,
+	size_t *outbuf_size)
 {
 	fx_class *c = fx_class_get(type);
 	if (!c) {
 		return FX_ERR_INVALID_ARGUMENT;
 	}
 
-	fx_compressor_class *ops = fx_class_get_interface(c, FX_TYPE_COMPRESSOR);
+	fx_compressor_class *ops
+		= fx_class_get_interface(c, FX_TYPE_COMPRESSOR);
 	if (!ops) {
 		return FX_ERR_INVALID_ARGUMENT;
 	}
@@ -174,22 +186,32 @@ enum fx_status fx_compressor_get_buffer_size(
 }
 
 enum fx_status fx_compressor_get_mode(
-	const fx_compressor *compressor, enum fx_compressor_mode *out)
+	const fx_compressor *compressor,
+	enum fx_compressor_mode *out)
 {
 	COMPRESSOR_DISPATCH_STATIC(
-		compressor_get_mode, (fx_compressor *)compressor, out);
+		compressor_get_mode,
+		(fx_compressor *)compressor,
+		out);
 }
 
 enum fx_status fx_compressor_set_mode(
-	fx_compressor *compressor, enum fx_compressor_mode mode)
+	fx_compressor *compressor,
+	enum fx_compressor_mode mode)
 {
 	COMPRESSOR_DISPATCH_STATIC(compressor_set_mode, compressor, mode);
 }
 
 enum fx_status fx_compressor_set_buffer(
-	fx_compressor *compressor, fx_ringbuffer *inbuf, fx_ringbuffer *outbuf)
+	fx_compressor *compressor,
+	fx_ringbuffer *inbuf,
+	fx_ringbuffer *outbuf)
 {
-	COMPRESSOR_DISPATCH_STATIC(compressor_set_buffer, compressor, inbuf, outbuf);
+	COMPRESSOR_DISPATCH_STATIC(
+		compressor_set_buffer,
+		compressor,
+		inbuf,
+		outbuf);
 }
 
 enum fx_status fx_compressor_step(fx_compressor *compressor)
@@ -209,7 +231,9 @@ enum fx_status fx_compressor_reset(fx_compressor *compressor)
 
 bool fx_compressor_eof(const fx_compressor *compressor)
 {
-	COMPRESSOR_DISPATCH_STATIC_0(compressor_eof, (fx_compressor *)compressor);
+	COMPRESSOR_DISPATCH_STATIC_0(
+		compressor_eof,
+		(fx_compressor *)compressor);
 }
 
 /*** VIRTUAL FUNCTIONS ********************************************************/

fx.compression/cstream.c

@@ -1,5 +1,5 @@
-#include <fx/compress/compressor.h>
-#include <fx/compress/cstream.h>
+#include <fx/compression/compressor.h>
+#include <fx/compression/cstream.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -17,8 +17,8 @@ struct fx_cstream_p {
 	 *
 	 * the input buffer holds data that will be provided to the
 	 * (de)compression function. in compression mode, this data is provided
-	 * by the code using the cstream (via fx_cstream_write). in decompression
-	 * mode, this data is read from s_endpoint.
+	 * by the code using the cstream (via fx_cstream_write). in
+	 * decompression mode, this data is read from s_endpoint.
 	 *
 	 * the output buffer holds data produced by the (de)compression
 	 * function. in compression mode, this data will be written to
@@ -27,7 +27,8 @@ struct fx_cstream_p {
 	 *
 	 * heavy usage of cstream's compressed sections facility can result
 	 * in the input buffer holding uncompressed data while the stream is in
-	 * decompression mode. this is handled by the uncompressed read code path.
+	 * decompression mode. this is handled by the uncompressed read code
+	 * path.
 	 */
 	fx_ringbuffer *s_in, *s_out;
 	fx_compressor_mode s_mode;
@@ -78,13 +79,23 @@ struct fx_cstream_p {
 /*** PRIVATE FUNCTIONS ********************************************************/
 
 static enum fx_status read_cursor(
-	struct fx_cstream_p *stream, void *buf, size_t count, size_t *out_nr_read)
+	struct fx_cstream_p *stream,
+	void *buf,
+	size_t count,
+	size_t *out_nr_read)
 {
-	return fx_stream_read_bytes(stream->s_endpoint, buf, count, out_nr_read);
+	return fx_stream_read_bytes(
+		stream->s_endpoint,
+		buf,
+		count,
+		out_nr_read);
 }
 
 static enum fx_status read_uncompressed(
-	struct fx_cstream_p *stream, void *buf, size_t count, size_t *out_nr_read)
+	struct fx_cstream_p *stream,
+	void *buf,
+	size_t count,
+	size_t *out_nr_read)
 {
 	size_t remaining = count;
 	unsigned char *dest = buf;
@@ -101,7 +112,9 @@ static enum fx_status read_uncompressed(
 		const void *data;
 		size_t available;
 		status = fx_ringbuffer_open_read_buffer(
-			stream->s_in, &data, &available);
+			stream->s_in,
+			&data,
+			&available);
 		if (!FX_OK(status)) {
 			break;
 		}
@@ -128,7 +141,10 @@ static enum fx_status read_uncompressed(
 	}
 
 	status = fx_stream_read_bytes(
-		stream->s_endpoint, dest, remaining, &nr_read_from_endpoint);
+		stream->s_endpoint,
+		dest,
+		remaining,
+		&nr_read_from_endpoint);
 	stream->s_tx_bytes_uncompressed += nr_read_from_endpoint;
 	stream->s_tx_bytes += nr_read_from_endpoint;
 
@@ -150,14 +166,19 @@ static enum fx_status refill_input_buffer(struct fx_cstream_p *stream)
 		void *data;
 		size_t capacity;
 		status = fx_ringbuffer_open_write_buffer(
-			stream->s_in, &data, &capacity);
+			stream->s_in,
+			&data,
+			&capacity);
 		if (!FX_OK(status)) {
 			break;
 		}
 
 		size_t r = 0;
 		status = fx_stream_read_bytes(
-			stream->s_endpoint, data, capacity, &r);
+			stream->s_endpoint,
+			data,
+			capacity,
+			&r);
 
 		fx_ringbuffer_close_write_buffer(stream->s_in, &data, r);
 		nr_read += r;
@@ -196,9 +217,11 @@ static enum fx_status refill_output_buffer(struct fx_cstream_p *stream)
 		return status;
 	}
 
-	size_t bytes_before = fx_ringbuffer_available_data_remaining(stream->s_in);
+	size_t bytes_before
+		= fx_ringbuffer_available_data_remaining(stream->s_in);
 	status = fx_compressor_step(stream->s_compressor);
-	size_t bytes_after = fx_ringbuffer_available_data_remaining(stream->s_in);
+	size_t bytes_after
+		= fx_ringbuffer_available_data_remaining(stream->s_in);
 
 	stream->s_tx_bytes_compressed += (bytes_before - bytes_after);
 	stream->s_tx_bytes += (bytes_before - bytes_after);
@@ -207,7 +230,10 @@ static enum fx_status refill_output_buffer(struct fx_cstream_p *stream)
 }
 
 static enum fx_status cstream_read(
-	struct fx_cstream_p *stream, void *buf, size_t count, size_t *out_nr_read)
+	struct fx_cstream_p *stream,
+	void *buf,
+	size_t count,
+	size_t *out_nr_read)
 {
 	if (stream->s_mode != FX_COMPRESSOR_MODE_DECOMPRESS) {
 		return FX_ERR_BAD_STATE;
@@ -238,7 +264,9 @@ static enum fx_status cstream_read(
 		const void *data;
 		size_t available;
 		status = fx_ringbuffer_open_read_buffer(
-			stream->s_out, &data, &available);
+			stream->s_out,
+			&data,
+			&available);
 		if (!FX_OK(status)) {
 			break;
 		}
@@ -267,13 +295,23 @@ static enum fx_status cstream_read(
 }
 
 static enum fx_status write_cursor(
-	struct fx_cstream_p *stream, const void *buf, size_t count, size_t *nr_written)
+	struct fx_cstream_p *stream,
+	const void *buf,
+	size_t count,
+	size_t *nr_written)
 {
-	return fx_stream_write_bytes(stream->s_endpoint, buf, count, nr_written);
+	return fx_stream_write_bytes(
+		stream->s_endpoint,
+		buf,
+		count,
+		nr_written);
 }
 
 static enum fx_status write_uncompressed(
-	struct fx_cstream_p *stream, const void *buf, size_t count, size_t *nr_written)
+	struct fx_cstream_p *stream,
+	const void *buf,
+	size_t count,
+	size_t *nr_written)
 {
 	size_t w = 0;
 	enum fx_status status
@@ -307,14 +345,19 @@ static enum fx_status flush_output_buffer(struct fx_cstream_p *stream)
 		const void *data;
 		size_t capacity;
 		status = fx_ringbuffer_open_read_buffer(
-			stream->s_out, &data, &capacity);
+			stream->s_out,
+			&data,
+			&capacity);
 		if (!FX_OK(status)) {
 			break;
 		}
 
 		size_t w = 0;
 		status = fx_stream_write_bytes(
-			stream->s_endpoint, data, capacity, &w);
+			stream->s_endpoint,
+			data,
+			capacity,
+			&w);
 
 		fx_ringbuffer_close_read_buffer(stream->s_out, &data, w);
 		nr_written += w;
@@ -338,7 +381,9 @@ static enum fx_status flush_output_buffer(struct fx_cstream_p *stream)
 }
 
 static enum fx_status cstream_write(
-	struct fx_cstream_p *stream, const void *buf, size_t count,
+	struct fx_cstream_p *stream,
+	const void *buf,
+	size_t count,
 	size_t *out_nr_written)
 {
 	if (stream->s_mode != FX_COMPRESSOR_MODE_COMPRESS) {
@@ -374,7 +419,9 @@ static enum fx_status cstream_write(
 		void *data;
 		size_t available;
 		status = fx_ringbuffer_open_write_buffer(
-			stream->s_in, &data, &available);
+			stream->s_in,
+			&data,
+			&available);
 		if (!FX_OK(status)) {
 			break;
 		}
@@ -403,7 +450,9 @@ static enum fx_status cstream_write(
 }
 
 static enum fx_status skip_uncompressed(
-	struct fx_cstream_p *stream, size_t count, size_t *out_nr_skipped)
+	struct fx_cstream_p *stream,
+	size_t count,
+	size_t *out_nr_skipped)
 {
 	size_t remaining = count;
 	size_t nr_read_from_buf = 0;
@@ -419,7 +468,9 @@ static enum fx_status skip_uncompressed(
 		const void *data;
 		size_t available;
 		status = fx_ringbuffer_open_read_buffer(
-			stream->s_in, &data, &available);
+			stream->s_in,
+			&data,
+			&available);
 		if (!FX_OK(status)) {
 			break;
 		}
@@ -447,7 +498,10 @@ static enum fx_status skip_uncompressed(
 
 	size_t cursor = fx_stream_cursor(stream->s_endpoint);
 
-	status = fx_stream_seek(stream->s_endpoint, remaining, FX_STREAM_SEEK_CURRENT);
+	status = fx_stream_seek(
+		stream->s_endpoint,
+		remaining,
+		FX_STREAM_SEEK_CURRENT);
 	nr_read_from_endpoint = fx_stream_cursor(stream->s_endpoint) - cursor;
 	stream->s_tx_bytes_uncompressed += nr_read_from_endpoint;
 	stream->s_tx_bytes += nr_read_from_endpoint;
@@ -460,7 +514,9 @@ static enum fx_status skip_uncompressed(
 }
 
 static enum fx_status cstream_skip(
-	struct fx_cstream_p *stream, size_t count, size_t *out_nr_skipped)
+	struct fx_cstream_p *stream,
+	size_t count,
+	size_t *out_nr_skipped)
 {
 	if (stream->s_mode != FX_COMPRESSOR_MODE_DECOMPRESS) {
 		return FX_ERR_BAD_STATE;
@@ -499,7 +555,9 @@ static enum fx_status cstream_skip(
 		const void *data;
 		size_t available;
 		status = fx_ringbuffer_open_read_buffer(
-			stream->s_out, &data, &available);
+			stream->s_out,
+			&data,
+			&available);
 		if (!FX_OK(status)) {
 			break;
 		}
@@ -554,7 +612,8 @@ static enum fx_status cstream_reset(struct fx_cstream_p *stream)
 }
 
 static enum fx_status cstream_begin_compressed_section(
-	struct fx_cstream_p *stream, size_t *tx_uncompressed_bytes)
+	struct fx_cstream_p *stream,
+	size_t *tx_uncompressed_bytes)
 {
 	if (stream->s_flags & CSTREAM_CURSOR_MOVED) {
 		return FX_ERR_BAD_STATE;
@@ -578,7 +637,8 @@ static enum fx_status cstream_begin_compressed_section(
 }
 
 static enum fx_status cstream_end_compressed_section(
-	struct fx_cstream_p *stream, size_t *tx_compressed_bytes,
+	struct fx_cstream_p *stream,
+	size_t *tx_compressed_bytes,
 	size_t *tx_uncompressed_bytes)
 {
 	if (stream->s_flags & CSTREAM_CURSOR_MOVED) {
@@ -646,28 +706,33 @@ static bool cstream_in_compressed_section(const struct fx_cstream_p *stream)
 	return stream->s_compression_depth > 0;
 }
 
-static enum fx_status cstream_tx_bytes(const struct fx_cstream_p *stream, size_t *out)
+static enum fx_status cstream_tx_bytes(
+	const struct fx_cstream_p *stream,
+	size_t *out)
 {
 	*out = stream->s_tx_bytes;
 	return FX_SUCCESS;
 }
 
 static enum fx_status cstream_tx_bytes_compressed(
-	const struct fx_cstream_p *stream, size_t *out)
+	const struct fx_cstream_p *stream,
+	size_t *out)
 {
 	*out = stream->s_tx_bytes_compressed;
 	return FX_SUCCESS;
 }
 
 static enum fx_status cstream_tx_bytes_uncompressed(
-	const struct fx_cstream_p *stream, size_t *out)
+	const struct fx_cstream_p *stream,
+	size_t *out)
 {
 	*out = stream->s_tx_bytes_uncompressed;
 	return FX_SUCCESS;
 }
 
 static enum fx_status cstream_set_cursor_position(
-	struct fx_cstream_p *stream, size_t pos)
+	struct fx_cstream_p *stream,
+	size_t pos)
 {
 	if (stream->s_compression_depth > 0) {
 		return FX_ERR_BAD_STATE;
@@ -691,14 +756,17 @@ static enum fx_status cstream_set_cursor_position(
 	return FX_SUCCESS;
 }
 
-static enum fx_status cstream_restore_cursor_position(struct fx_cstream_p *stream)
+static enum fx_status cstream_restore_cursor_position(
+	struct fx_cstream_p *stream)
 {
 	if (!(stream->s_flags & CSTREAM_CURSOR_MOVED)) {
 		return FX_ERR_BAD_STATE;
 	}
 
 	enum fx_status status = fx_stream_seek(
-		stream->s_endpoint, stream->s_cursor, FX_STREAM_SEEK_START);
+		stream->s_endpoint,
+		stream->s_cursor,
+		FX_STREAM_SEEK_START);
 	stream->s_cursor = 0;
 
 	if (!FX_OK(status)) {
@@ -713,12 +781,17 @@ static enum fx_status cstream_restore_cursor_position(struct fx_cstream_p *strea
 /*** PUBLIC FUNCTIONS *********************************************************/
 
 enum fx_status fx_cstream_open(
-	fx_stream *endpoint, fx_type compressor_type, fx_compressor_mode mode,
+	fx_stream *endpoint,
+	fx_type compressor_type,
+	fx_compressor_mode mode,
 	fx_cstream **out)
 {
 	size_t inbuf_size = 0, outbuf_size = 0;
 	enum fx_status status = fx_compressor_get_buffer_size(
-		compressor_type, mode, &inbuf_size, &outbuf_size);
+		compressor_type,
+		mode,
+		&inbuf_size,
+		&outbuf_size);
 	if (!FX_OK(status)) {
 		return status;
 	}
@@ -735,7 +808,7 @@ enum fx_status fx_cstream_open(
 	p->s_endpoint = endpoint;
 
 	cfg->s_mode = (mode == FX_COMPRESSOR_MODE_COMPRESS) ? FX_STREAM_WRITE
-	                                                   : FX_STREAM_READ;
+	                                                    : FX_STREAM_READ;
 
 	p->s_in = fx_ringbuffer_create(inbuf_size + 1);
 	if (!FX_OK(status)) {
@@ -764,23 +837,46 @@ enum fx_status fx_cstream_open(
 }
 
 enum fx_status fx_cstream_read(
-	fx_cstream *stream, void *buf, size_t count, size_t *out_nr_read)
+	fx_cstream *stream,
+	void *buf,
+	size_t count,
+	size_t *out_nr_read)
 {
 	FX_CLASS_DISPATCH_STATIC(
-		FX_TYPE_CSTREAM, cstream_read, stream, buf, count, out_nr_read);
+		FX_TYPE_CSTREAM,
+		cstream_read,
+		stream,
+		buf,
+		count,
+		out_nr_read);
 }
 
 enum fx_status fx_cstream_write(
-	fx_cstream *stream, const void *buf, size_t count, size_t *out_nr_written)
+	fx_cstream *stream,
+	const void *buf,
+	size_t count,
+	size_t *out_nr_written)
 {
 	FX_CLASS_DISPATCH_STATIC(
-		FX_TYPE_CSTREAM, cstream_write, stream, buf, count, out_nr_written);
+		FX_TYPE_CSTREAM,
+		cstream_write,
+		stream,
+		buf,
+		count,
+		out_nr_written);
 }
 
-enum fx_status fx_cstream_skip(fx_cstream *stream, size_t count, size_t *out_nr_skipped)
+enum fx_status fx_cstream_skip(
+	fx_cstream *stream,
+	size_t count,
+	size_t *out_nr_skipped)
 {
 	FX_CLASS_DISPATCH_STATIC(
-		FX_TYPE_CSTREAM, cstream_skip, stream, count, out_nr_skipped);
+		FX_TYPE_CSTREAM,
+		cstream_skip,
+		stream,
+		count,
+		out_nr_skipped);
 }
 
 enum fx_status fx_cstream_reset(fx_cstream *stream)
@@ -789,54 +885,83 @@ enum fx_status fx_cstream_reset(fx_cstream *stream)
 }
 
 enum fx_status fx_cstream_begin_compressed_section(
-	fx_cstream *stream, size_t *tx_uncompressed_bytes)
+	fx_cstream *stream,
+	size_t *tx_uncompressed_bytes)
 {
 	FX_CLASS_DISPATCH_STATIC(
-		FX_TYPE_CSTREAM, cstream_begin_compressed_section, stream,
+		FX_TYPE_CSTREAM,
+		cstream_begin_compressed_section,
+		stream,
 		tx_uncompressed_bytes);
 }
 
 enum fx_status fx_cstream_end_compressed_section(
-	fx_cstream *stream, size_t *tx_compressed_bytes, size_t *tx_uncompressed_bytes)
+	fx_cstream *stream,
+	size_t *tx_compressed_bytes,
+	size_t *tx_uncompressed_bytes)
 {
 	FX_CLASS_DISPATCH_STATIC(
-		FX_TYPE_CSTREAM, cstream_end_compressed_section, stream,
-		tx_compressed_bytes, tx_uncompressed_bytes);
+		FX_TYPE_CSTREAM,
+		cstream_end_compressed_section,
+		stream,
+		tx_compressed_bytes,
+		tx_uncompressed_bytes);
 }
 
 bool fx_cstream_in_compressed_section(const fx_cstream *stream)
 {
 	FX_CLASS_DISPATCH_STATIC_0(
-		FX_TYPE_CSTREAM, cstream_in_compressed_section, stream);
+		FX_TYPE_CSTREAM,
+		cstream_in_compressed_section,
+		stream);
 }
 
 enum fx_status fx_cstream_tx_bytes(const fx_cstream *stream, size_t *out)
 {
-	FX_CLASS_DISPATCH_STATIC(FX_TYPE_CSTREAM, cstream_tx_bytes, stream, out);
+	FX_CLASS_DISPATCH_STATIC(
+		FX_TYPE_CSTREAM,
+		cstream_tx_bytes,
+		stream,
+		out);
 }
 
-enum fx_status fx_cstream_tx_bytes_compressed(const fx_cstream *stream, size_t *out)
+enum fx_status fx_cstream_tx_bytes_compressed(
+	const fx_cstream *stream,
+	size_t *out)
 {
 	FX_CLASS_DISPATCH_STATIC(
-		FX_TYPE_CSTREAM, cstream_tx_bytes_compressed, stream, out);
+		FX_TYPE_CSTREAM,
+		cstream_tx_bytes_compressed,
+		stream,
+		out);
 }
 
-enum fx_status fx_cstream_tx_bytes_uncompressed(const fx_cstream *stream, size_t *out)
+enum fx_status fx_cstream_tx_bytes_uncompressed(
+	const fx_cstream *stream,
+	size_t *out)
 {
 	FX_CLASS_DISPATCH_STATIC(
-		FX_TYPE_CSTREAM, cstream_tx_bytes_uncompressed, stream, out);
+		FX_TYPE_CSTREAM,
+		cstream_tx_bytes_uncompressed,
+		stream,
+		out);
 }
 
 enum fx_status fx_cstream_set_cursor_position(fx_cstream *stream, size_t pos)
 {
 	FX_CLASS_DISPATCH_STATIC(
-		FX_TYPE_CSTREAM, cstream_set_cursor_position, stream, pos);
+		FX_TYPE_CSTREAM,
+		cstream_set_cursor_position,
+		stream,
+		pos);
 }
 
 enum fx_status fx_cstream_restore_cursor_position(fx_cstream *stream)
 {
 	FX_CLASS_DISPATCH_STATIC_0(
-		FX_TYPE_CSTREAM, cstream_restore_cursor_position, stream);
+		FX_TYPE_CSTREAM,
+		cstream_restore_cursor_position,
+		stream);
 }
 
 /*** VIRTUAL FUNCTIONS ********************************************************/

fx.compression/function/zstd.c

@@ -1,5 +1,5 @@
-#include <fx/compress/zstd.h>
-#include <fx/core/ringbuffer.h>
+#include <fx/compression/zstd.h>
+#include <fx/ringbuffer.h>
 #include <zstd.h>
 
 /*** PRIVATE DATA *************************************************************/
@@ -14,7 +14,9 @@ struct fx_zstd_compressor_p {
 /*** PUBLIC FUNCTIONS *********************************************************/
 
 fx_status fx_zstd_compressor_get_buffer_size(
-	fx_compressor_mode mode, size_t *inbuf_size, size_t *outbuf_size)
+	fx_compressor_mode mode,
+	size_t *inbuf_size,
+	size_t *outbuf_size)
 {
 	switch (mode) {
 	case FX_COMPRESSOR_MODE_COMPRESS:
@@ -40,7 +42,8 @@ static void zstd_compressor_init(fx_object *obj, void *priv)
 
 static void zstd_compressor_fini(fx_object *obj, void *priv)
 {
-	fx_compressor_data *c = fx_object_get_protected(obj, FX_TYPE_COMPRESSOR);
+	fx_compressor_data *c
+		= fx_object_get_protected(obj, FX_TYPE_COMPRESSOR);
 	struct fx_zstd_compressor_p *ctx = priv;
 	switch (c->c_mode) {
 	case FX_COMPRESSOR_MODE_COMPRESS:
@@ -109,13 +112,18 @@ static enum fx_status compress(fx_compressor *compressor)
 		const void *in_buf = NULL;
 		void *out_buf = NULL;
 
-		status = fx_ringbuffer_open_read_buffer(in, &in_buf, &in_available);
+		status = fx_ringbuffer_open_read_buffer(
+			in,
+			&in_buf,
+			&in_available);
 		if (!FX_OK(status)) {
 			break;
 		}
 
 		status = fx_ringbuffer_open_write_buffer(
-			out, &out_buf, &out_capacity);
+			out,
+			&out_buf,
+			&out_capacity);
 		if (!FX_OK(status)) {
 			fx_ringbuffer_close_read_buffer(in, &in_buf, 0);
 			break;
@@ -135,7 +143,10 @@ static enum fx_status compress(fx_compressor *compressor)
 
 		do {
 			size_t ret = ZSTD_compressStream2(
-				ctx->zstd_c, &z_out, &z_in, ZSTD_e_continue);
+				ctx->zstd_c,
+				&z_out,
+				&z_in,
+				ZSTD_e_continue);
 			if (ZSTD_isError(ret)) {
 				status = FX_ERR_COMPRESSION_FAILURE;
 				break;
@@ -178,7 +189,9 @@ static enum fx_status compress_end(fx_compressor *compressor)
 		void *out_buf = NULL;
 		size_t out_capacity = 0;
 		status = fx_ringbuffer_open_write_buffer(
-			out, &out_buf, &out_capacity);
+			out,
+			&out_buf,
+			&out_capacity);
 		if (!FX_OK(status)) {
 			break;
 		}
@@ -192,7 +205,10 @@ static enum fx_status compress_end(fx_compressor *compressor)
 
 		do {
 			size_t ret = ZSTD_compressStream2(
-				ctx->zstd_c, &z_out, &z_in, ZSTD_e_end);
+				ctx->zstd_c,
+				&z_out,
+				&z_in,
+				ZSTD_e_end);
 			if (ZSTD_isError(ret)) {
 				status = FX_ERR_COMPRESSION_FAILURE;
 				finished = true;
@@ -240,13 +256,18 @@ static enum fx_status decompress(fx_compressor *compressor)
 		const void *in_buf = NULL;
 		void *out_buf = NULL;
 
-		status = fx_ringbuffer_open_read_buffer(in, &in_buf, &in_available);
+		status = fx_ringbuffer_open_read_buffer(
+			in,
+			&in_buf,
+			&in_available);
 		if (!FX_OK(status)) {
 			break;
 		}
 
 		status = fx_ringbuffer_open_write_buffer(
-			out, &out_buf, &out_capacity);
+			out,
+			&out_buf,
+			&out_capacity);
 		if (!FX_OK(status)) {
 			fx_ringbuffer_close_read_buffer(in, &in_buf, 0);
 			break;
@@ -266,7 +287,9 @@ static enum fx_status decompress(fx_compressor *compressor)
 
 		do {
 			size_t ret = ZSTD_decompressStream(
-				ctx->zstd_d, &z_out, &z_in);
+				ctx->zstd_d,
+				&z_out,
+				&z_in);
 			if (ZSTD_isError(ret)) {
 				status = FX_ERR_COMPRESSION_FAILURE;
 				break;
@@ -292,7 +315,9 @@ static enum fx_status decompress(fx_compressor *compressor)
 	return status;
 }
 
-static enum fx_status set_mode(fx_compressor *compressor, fx_compressor_mode mode)
+static enum fx_status set_mode(
+	fx_compressor *compressor,
+	fx_compressor_mode mode)
 {
 	struct fx_zstd_compressor_p *ctx
 		= fx_object_get_private(compressor, FX_TYPE_ZSTD_COMPRESSOR);

fx.compression/include/fx/compression/compressor.h

@@ -1,10 +1,10 @@
 #ifndef FX_COMPRESS_COMPRESSOR_H_
 #define FX_COMPRESS_COMPRESSOR_H_
 
-#include <fx/core/macros.h>
-#include <fx/core/misc.h>
-#include <fx/core/ringbuffer.h>
-#include <fx/core/status.h>
+#include <fx/macros.h>
+#include <fx/misc.h>
+#include <fx/ringbuffer.h>
+#include <fx/status.h>
 #include <stdbool.h>
 
 FX_DECLS_BEGIN;
@@ -48,15 +48,21 @@ FX_API fx_status fx_compressor_create(
 #endif
 
 FX_API fx_status fx_compressor_get_buffer_size(
-	fx_type type, fx_compressor_mode mode, size_t *inbuf_size,
+	fx_type type,
+	fx_compressor_mode mode,
+	size_t *inbuf_size,
 	size_t *outbuf_size);
 
 FX_API fx_status fx_compressor_get_mode(
-	const fx_compressor *compressor, fx_compressor_mode *out);
+	const fx_compressor *compressor,
+	fx_compressor_mode *out);
 FX_API fx_status fx_compressor_set_mode(
-	fx_compressor *compressor, fx_compressor_mode mode);
+	fx_compressor *compressor,
+	fx_compressor_mode mode);
 FX_API fx_status fx_compressor_set_buffer(
-	fx_compressor *compressor, fx_ringbuffer *inbuf, fx_ringbuffer *outbuf);
+	fx_compressor *compressor,
+	fx_ringbuffer *inbuf,
+	fx_ringbuffer *outbuf);
 FX_API fx_status fx_compressor_step(fx_compressor *compressor);
 FX_API fx_status fx_compressor_end(fx_compressor *compressor);
 FX_API fx_status fx_compressor_reset(fx_compressor *compressor);

fx.compression/include/fx/compression/cstream.h

@@ -1,8 +1,8 @@
 #ifndef FX_COMPRESS_CSTREAM_H_
 #define FX_COMPRESS_CSTREAM_H_
 
-#include <fx/core/macros.h>
-#include <fx/core/stream.h>
+#include <fx/macros.h>
+#include <fx/stream.h>
 #include <stdbool.h>
 
 FX_DECLS_BEGIN;
@@ -19,28 +19,37 @@ FX_TYPE_CLASS_DECLARATION_END(fx_cstream)
 FX_API fx_type fx_cstream_get_type(void);
 
 FX_API fx_status fx_cstream_open(
-	fx_stream *endpoint, fx_type compressor_type, enum fx_compressor_mode mode,
+	fx_stream *endpoint,
+	fx_type compressor_type,
+	enum fx_compressor_mode mode,
 	fx_cstream **out);
 
-FX_API fx_status fx_cstream_read(
-	fx_cstream *stream, void *buf, size_t count, size_t *nr_read);
+FX_API fx_status
+fx_cstream_read(fx_cstream *stream, void *buf, size_t count, size_t *nr_read);
 FX_API fx_status fx_cstream_write(
-	fx_cstream *stream, const void *buf, size_t count, size_t *nr_written);
-FX_API fx_status fx_cstream_skip(
-	fx_cstream *stream, size_t count, size_t *nr_skipped);
+	fx_cstream *stream,
+	const void *buf,
+	size_t count,
+	size_t *nr_written);
+FX_API fx_status
+fx_cstream_skip(fx_cstream *stream, size_t count, size_t *nr_skipped);
 FX_API fx_status fx_cstream_reset(fx_cstream *stream);
 
 FX_API fx_status fx_cstream_begin_compressed_section(
-	fx_cstream *stream, size_t *tx_uncompressed_bytes);
+	fx_cstream *stream,
+	size_t *tx_uncompressed_bytes);
 FX_API fx_status fx_cstream_end_compressed_section(
-	fx_cstream *stream, size_t *tx_compressed_bytes,
+	fx_cstream *stream,
+	size_t *tx_compressed_bytes,
 	size_t *tx_uncompressed_bytes);
 FX_API bool fx_cstream_in_compressed_section(const fx_cstream *stream);
 FX_API fx_status fx_cstream_tx_bytes(const fx_cstream *stream, size_t *out);
 FX_API fx_status fx_cstream_tx_bytes_compressed(
-	const fx_cstream *stream, size_t *out);
+	const fx_cstream *stream,
+	size_t *out);
 FX_API fx_status fx_cstream_tx_bytes_uncompressed(
-	const fx_cstream *stream, size_t *out);
+	const fx_cstream *stream,
+	size_t *out);
 
 FX_API fx_status fx_cstream_set_cursor_position(fx_cstream *stream, size_t pos);
 FX_API fx_status fx_cstream_restore_cursor_position(fx_cstream *stream);

fx.compression/include/fx/compression/zstd.h

@@ -1,10 +1,10 @@
 #ifndef FX_COMPRESS_ZSTD_H_
 #define FX_COMPRESS_ZSTD_H_
 
-#include <fx/compress/compressor.h>
-#include <fx/core/macros.h>
-#include <fx/core/misc.h>
-#include <fx/core/status.h>
+#include <fx/compression/compressor.h>
+#include <fx/macros.h>
+#include <fx/misc.h>
+#include <fx/status.h>
 #include <stdbool.h>
 
 FX_DECLS_BEGIN;
@@ -19,7 +19,9 @@ FX_TYPE_CLASS_DECLARATION_END(fx_compressor)
 FX_API fx_type fx_zstd_compressor_get_type(void);
 
 FX_API fx_status fx_zstd_compressor_get_buffer_size(
-	fx_compressor_mode mode, size_t *inbuf_size, size_t *outbuf_size);
+	fx_compressor_mode mode,
+	size_t *inbuf_size,
+	size_t *outbuf_size);
 
 FX_TYPE_DEFAULT_CONSTRUCTOR(fx_zstd_compressor, FX_TYPE_ZSTD_COMPRESSOR);