core: stream: formatting tweaks

core/stream.c

@@ -6,16 +6,16 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define READ_MAGIC(p)       (*(uint64_t *)p)
+#define READ_MAGIC(p)        (*(uint64_t *)p)
-#define IS_BSTR(p)          (READ_MAGIC(p) == FX_BSTR_MAGIC)
+#define IS_BSTR(p)           (READ_MAGIC(p) == FX_BSTR_MAGIC)
 
 #define FX_TYPE_STDIO_STREAM (fx_stdio_stream_get_type())
 
 #define STREAM_DISPATCH_VIRTUAL(func, stream, ...)                             \
 	do {                                                                   \
 		struct stream_data _stream;                                    \
-		enum fx_status status = stream_get_data(stream, &_stream);      \
+		enum fx_status status = stream_get_data(stream, &_stream);     \
-		if (!FX_OK(status)) {                                           \
+		if (!FX_OK(status)) {                                          \
 			return status;                                         \
 		}                                                              \
 		return func(&_stream, __VA_ARGS__);                            \
@@ -23,8 +23,8 @@
 #define STREAM_DISPATCH_VIRTUAL_0(func, stream)                                \
 	do {                                                                   \
 		struct stream_data _stream;                                    \
-		enum fx_status status = stream_get_data(stream, &_stream);      \
+		enum fx_status status = stream_get_data(stream, &_stream);     \
-		if (!FX_OK(status)) {                                           \
+		if (!FX_OK(status)) {                                          \
 			return status;                                         \
 		}                                                              \
 		return func(&_stream);                                         \
@@ -84,12 +84,17 @@ static enum fx_status stdio_write(fx_stream *, const void *, size_t, size_t *);
 static enum fx_status stdio_seek(fx_stream *, long long, fx_stream_seek_origin);
 static enum fx_status stdio_tell(const fx_stream *, size_t *);
 
-static enum fx_status stream_get_data(const fx_stream *strp, struct stream_data *out)
+static enum fx_status stream_get_data(
+	const fx_stream *strp,
+	struct stream_data *out)
 {
 	out->s_obj = (fx_stream *)strp;
 	return fx_object_get_data(
-		strp, FX_TYPE_STREAM, (void **)&out->s_private,
+		strp,
-		(void **)&out->s_cfg, (void **)&out->s_ops);
+		FX_TYPE_STREAM,
+		(void **)&out->s_private,
+		(void **)&out->s_cfg,
+		(void **)&out->s_ops);
 }
 
 static int current_indent(struct stream_data *stream)
@@ -117,7 +122,9 @@ static size_t stream_cursor(const struct stream_data *stream)
 }
 
 static enum fx_status stream_seek(
-	struct stream_data *stream, long long offset, fx_stream_seek_origin origin)
+	struct stream_data *stream,
+	long long offset,
+	fx_stream_seek_origin origin)
 {
 	if (!stream || !stream->s_ops || !stream->s_ops->s_seek) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -236,7 +243,8 @@ static enum fx_status __write_char(struct stream_data *stream, fx_wchar c)
 		}
 	}
 
-	status = stream->s_ops->s_write(stream->s_obj, (unsigned char *)s, len, &w);
+	status = stream->s_ops
+	                 ->s_write(stream->s_obj, (unsigned char *)s, len, &w);
 
 	if (!FX_OK(status)) {
 		return status;
@@ -289,7 +297,10 @@ static enum fx_status stream_write_char(struct stream_data *stream, fx_wchar c)
 }
 
 static enum fx_status stream_read_bytes(
-	struct stream_data *stream, void *buf, size_t count, size_t *nr_read)
+	struct stream_data *stream,
+	void *buf,
+	size_t count,
+	size_t *nr_read)
 {
 	if (!(stream->s_cfg->s_mode & FX_STREAM_READ)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -304,7 +315,10 @@ static enum fx_status stream_read_bytes(
 	return stream->s_ops->s_read(stream->s_obj, buf, count, nr_read);
 }
 
-static enum fx_status stream_read_line(struct stream_data *stream, char *s, size_t max)
+static enum fx_status stream_read_line(
+	struct stream_data *stream,
+	char *s,
+	size_t max)
 {
 	if (!(stream->s_cfg->s_mode & FX_STREAM_READ)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -337,7 +351,8 @@ static enum fx_status stream_read_line(struct stream_data *stream, char *s, size
 }
 
 static enum fx_status stream_read_line_s(
-	struct stream_data *src, struct stream_data *dest)
+	struct stream_data *src,
+	struct stream_data *dest)
 {
 	if (!(src->s_cfg->s_mode & FX_STREAM_READ)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -374,7 +389,8 @@ static enum fx_status stream_read_line_s(
 }
 
 static enum fx_status stream_read_line_to_bstr(
-	struct stream_data *src, struct fx_bstr *dest)
+	struct stream_data *src,
+	struct fx_bstr *dest)
 {
 	if (!(src->s_cfg->s_mode & FX_STREAM_READ)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -407,7 +423,10 @@ static enum fx_status stream_read_line_to_bstr(
 }
 
 static enum fx_status stream_write_bytes(
-	struct stream_data *stream, const void *buf, size_t count, size_t *nr_written)
+	struct stream_data *stream,
+	const void *buf,
+	size_t count,
+	size_t *nr_written)
 {
 	if (!(stream->s_cfg->s_mode & FX_STREAM_WRITE)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -423,7 +442,10 @@ static enum fx_status stream_write_bytes(
 }
 
 static enum fx_status stream_read_all_bytes(
-	struct stream_data *stream, void *p, size_t max, size_t *out_nr_read)
+	struct stream_data *stream,
+	void *p,
+	size_t max,
+	size_t *out_nr_read)
 {
 	if (!(stream->s_cfg->s_mode & FX_STREAM_READ)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -452,8 +474,10 @@ static enum fx_status stream_read_all_bytes(
 }
 
 static enum fx_status stream_read_all_bytes_s(
-	struct stream_data *src, struct stream_data *dest,
+	struct stream_data *src,
-	struct fx_stream_buffer_p *buffer, size_t *out_nr_read)
+	struct stream_data *dest,
+	struct fx_stream_buffer_p *buffer,
+	size_t *out_nr_read)
 {
 	if (!(src->s_cfg->s_mode & FX_STREAM_READ)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -482,7 +506,10 @@ static enum fx_status stream_read_all_bytes_s(
 	while (1) {
 		size_t r = 0, w = 0;
 		status = stream_read_bytes(
-			src, buffer->p_buf, buffer->p_buf_len, &r);
+			src,
+			buffer->p_buf,
+			buffer->p_buf_len,
+			&r);
 		if (status != FX_SUCCESS) {
 			break;
 		}
@@ -507,8 +534,10 @@ static enum fx_status stream_read_all_bytes_s(
 }
 
 static enum fx_status stream_read_all_bytes_to_bstr_s(
-	struct stream_data *src, struct fx_bstr *dest,
+	struct stream_data *src,
-	struct fx_stream_buffer_p *buffer, size_t *out_nr_read)
+	struct fx_bstr *dest,
+	struct fx_stream_buffer_p *buffer,
+	size_t *out_nr_read)
 {
 	if (!(src->s_cfg->s_mode & FX_STREAM_READ)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -533,7 +562,10 @@ static enum fx_status stream_read_all_bytes_to_bstr_s(
 	while (1) {
 		size_t r = 0, w = 0;
 		status = stream_read_bytes(
-			src, buffer->p_buf, buffer->p_buf_len, &r);
+			src,
+			buffer->p_buf,
+			buffer->p_buf_len,
+			&r);
 		if (status != FX_SUCCESS) {
 			break;
 		}
@@ -557,8 +589,10 @@ static enum fx_status stream_read_all_bytes_to_bstr_s(
 	return status;
 }
 
-static enum fx_status stream_write_string(
+static enum fx_status stream_write_cstr(
-	struct stream_data *stream, const char *s, size_t *nr_written)
+	struct stream_data *stream,
+	const char *s,
+	size_t *nr_written)
 {
 	size_t i;
 	enum fx_status status = FX_SUCCESS;
@@ -610,7 +644,8 @@ static enum fx_status stream_push_indent(struct stream_data *stream, int indent)
 		stream->s_private->s_istack_ptr = 0;
 	}
 
-	if (stream->s_private->s_istack_ptr + 1 >= stream->s_private->s_istack_size) {
+	if (stream->s_private->s_istack_ptr + 1
+	    >= stream->s_private->s_istack_size) {
 		int *buf = realloc(
 			stream->s_private->s_istack,
 			(stream->s_private->s_istack_size + 4) * sizeof(int));
@@ -735,20 +770,31 @@ enum fx_status fx_stream_reserve(fx_stream *stream, size_t len)
 	}
 
 	FX_CLASS_DISPATCH_VIRTUAL(
-		fx_stream, FX_TYPE_STREAM, FX_ERR_NOT_SUPPORTED, s_reserve, stream,
+		fx_stream,
+		FX_TYPE_STREAM,
+		FX_ERR_NOT_SUPPORTED,
+		s_reserve,
+		stream,
 		len);
 }
 
 enum fx_status fx_stream_seek(
-	fx_stream *stream, long long offset, fx_stream_seek_origin origin)
+	fx_stream *stream,
+	long long offset,
+	fx_stream_seek_origin origin)
 {
 	if (IS_BSTR(stream)) {
 		return FX_ERR_NOT_SUPPORTED;
 	}
 
 	FX_CLASS_DISPATCH_VIRTUAL(
-		fx_stream, FX_TYPE_STREAM, FX_ERR_NOT_SUPPORTED, s_seek, stream,
+		fx_stream,
-		offset, origin);
+		FX_TYPE_STREAM,
+		FX_ERR_NOT_SUPPORTED,
+		s_seek,
+		stream,
+		offset,
+		origin);
 }
 
 size_t fx_stream_cursor(const fx_stream *stream)
@@ -788,7 +834,10 @@ enum fx_status fx_stream_read_char(fx_stream *strp, int *c)
 }
 
 enum fx_status fx_stream_read_bytes(
-	fx_stream *strp, void *buf, size_t count, size_t *nr_read)
+	fx_stream *strp,
+	void *buf,
+	size_t count,
+	size_t *nr_read)
 {
 	if (IS_BSTR(strp)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -833,17 +882,28 @@ enum fx_status fx_stream_read_line_s(fx_stream *src, fx_stream *dest)
 }
 
 enum fx_status fx_stream_read_all_bytes(
-	fx_stream *stream, void *p, size_t max, size_t *out_nr_read)
+	fx_stream *stream,
+	void *p,
+	size_t max,
+	size_t *out_nr_read)
 {
 	if (IS_BSTR(stream)) {
 		return FX_ERR_NOT_SUPPORTED;
 	}
 
-	STREAM_DISPATCH_VIRTUAL(stream_read_all_bytes, stream, p, max, out_nr_read);
+	STREAM_DISPATCH_VIRTUAL(
+		stream_read_all_bytes,
+		stream,
+		p,
+		max,
+		out_nr_read);
 }
 
 enum fx_status fx_stream_read_all_bytes_s(
-	fx_stream *src, fx_stream *dest, fx_stream_buffer *buffer, size_t *out_nr_read)
+	fx_stream *src,
+	fx_stream *dest,
+	fx_stream_buffer *buffer,
+	size_t *out_nr_read)
 {
 	if (IS_BSTR(src)) {
 		return FX_ERR_NOT_SUPPORTED;
@@ -865,7 +925,10 @@ enum fx_status fx_stream_read_all_bytes_s(
 
 	if (IS_BSTR(dest)) {
 		return stream_read_all_bytes_to_bstr_s(
-			&src_p, (fx_bstr *)dest, buffer_p, out_nr_read);
+			&src_p,
+			(fx_bstr *)dest,
+			buffer_p,
+			out_nr_read);
 	}
 
 	status = stream_get_data(dest, &dest_p);
@@ -885,34 +948,54 @@ enum fx_status fx_stream_write_char(fx_stream *stream, fx_wchar c)
 	STREAM_DISPATCH_VIRTUAL(stream_write_char, stream, c);
 }
 
-enum fx_status fx_stream_write_string(
+enum fx_status fx_stream_write_cstr(
-	fx_stream *stream, const char *s, size_t *nr_written)
+	fx_stream *stream,
+	const char *s,
+	size_t *nr_written)
 {
 	if (IS_BSTR(stream)) {
 		return fx_bstr_write_cstr((fx_bstr *)stream, s, nr_written);
 	}
 
-	STREAM_DISPATCH_VIRTUAL(stream_write_string, stream, s, nr_written);
+	STREAM_DISPATCH_VIRTUAL(stream_write_cstr, stream, s, nr_written);
 }
 
 enum fx_status fx_stream_write_bytes(
-	fx_stream *stream, const void *buf, size_t count, size_t *nr_written)
+	fx_stream *stream,
+	const void *buf,
+	size_t count,
+	size_t *nr_written)
 {
 	if (IS_BSTR(stream)) {
-		return fx_bstr_write_chars((fx_bstr *)stream, buf, count, nr_written);
+		return fx_bstr_write_chars(
+			(fx_bstr *)stream,
+			buf,
+			count,
+			nr_written);
 	}
 
-	STREAM_DISPATCH_VIRTUAL(stream_write_bytes, stream, buf, count, nr_written);
+	STREAM_DISPATCH_VIRTUAL(
+		stream_write_bytes,
+		stream,
+		buf,
+		count,
+		nr_written);
 }
 
 enum fx_status fx_stream_write_fmt(
-	fx_stream *stream, size_t *nr_written, const char *format, ...)
+	fx_stream *stream,
+	size_t *nr_written,
+	const char *format,
+	...)
 {
 	if (IS_BSTR(stream)) {
 		va_list arg;
 		va_start(arg, format);
 		fx_status w = fx_bstr_write_vfmt(
-			(fx_bstr *)stream, nr_written, format, arg);
+			(fx_bstr *)stream,
+			nr_written,
+			format,
+			arg);
 		va_end(arg);
 
 		return w;
@@ -934,10 +1017,17 @@ enum fx_status fx_stream_write_fmt(
 }
 
 enum fx_status fx_stream_write_vfmt(
-	fx_stream *stream, size_t *nr_written, const char *format, va_list arg)
+	fx_stream *stream,
+	size_t *nr_written,
+	const char *format,
+	va_list arg)
 {
 	if (IS_BSTR(stream)) {
-		return fx_bstr_write_vfmt((fx_bstr *)stream, nr_written, format, arg);
+		return fx_bstr_write_vfmt(
+			(fx_bstr *)stream,
+			nr_written,
+			format,
+			arg);
 	}
 
 	struct stream_data p;
@@ -997,7 +1087,10 @@ static void stdio_stream_fini(fx_object *obj, void *priv)
 }
 
 static enum fx_status stdio_read(
-	fx_stream *stream, void *out, size_t max, size_t *nr_read)
+	fx_stream *stream,
+	void *out,
+	size_t max,
+	size_t *nr_read)
 {
 	struct fx_stdio_stream_p *p
 		= fx_object_get_private(stream, FX_TYPE_STDIO_STREAM);
@@ -1015,7 +1108,10 @@ static enum fx_status stdio_read(
 }
 
 static enum fx_status stdio_write(
-	fx_stream *stream, const void *data, size_t count, size_t *nr_written)
+	fx_stream *stream,
+	const void *data,
+	size_t count,
+	size_t *nr_written)
 {
 	struct fx_stdio_stream_p *p
 		= fx_object_get_private(stream, FX_TYPE_STDIO_STREAM);
@@ -1032,7 +1128,9 @@ static enum fx_status stdio_write(
 }
 
 static enum fx_status stdio_seek(
-	fx_stream *stream, long long offset, fx_stream_seek_origin origin)
+	fx_stream *stream,
+	long long offset,
+	fx_stream_seek_origin origin)
 {
 	struct fx_stdio_stream_p *p
 		= fx_object_get_private(stream, FX_TYPE_STDIO_STREAM);