From 6ccb5835ff55d85156be91473c598eca9d6cb9a6 Mon Sep 17 00:00:00 2001
From: Elias Fleckenstein <eliasfleckenstein@web.de>
Date: Wed, 4 Nov 2020 16:57:41 +0100
Subject: Revert "Make Lint Happy"

This reverts commit ad148587dcf5244c2d2011dba339786c765c54c4.
---
 src/serialization.cpp | 180 +++++++++++++++++++++++++++-----------------------
 1 file changed, 99 insertions(+), 81 deletions(-)

(limited to 'src/serialization.cpp')

diff --git a/src/serialization.cpp b/src/serialization.cpp
index 64d5cefcc..310604f54 100644
--- a/src/serialization.cpp
+++ b/src/serialization.cpp
@@ -26,29 +26,29 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 /* report a zlib or i/o error */
 void zerr(int ret)
 {
-	dstream << "zerr: ";
-	switch (ret) {
-	case Z_ERRNO:
-		if (ferror(stdin))
-			dstream << "error reading stdin" << std::endl;
-		if (ferror(stdout))
-			dstream << "error writing stdout" << std::endl;
-		break;
-	case Z_STREAM_ERROR:
-		dstream << "invalid compression level" << std::endl;
-		break;
-	case Z_DATA_ERROR:
-		dstream << "invalid or incomplete deflate data" << std::endl;
-		break;
-	case Z_MEM_ERROR:
-		dstream << "out of memory" << std::endl;
-		break;
-	case Z_VERSION_ERROR:
-		dstream << "zlib version mismatch!" << std::endl;
+    dstream<<"zerr: ";
+    switch (ret) {
+    case Z_ERRNO:
+        if (ferror(stdin))
+            dstream<<"error reading stdin"<<std::endl;
+        if (ferror(stdout))
+            dstream<<"error writing stdout"<<std::endl;
+        break;
+    case Z_STREAM_ERROR:
+        dstream<<"invalid compression level"<<std::endl;
+        break;
+    case Z_DATA_ERROR:
+        dstream<<"invalid or incomplete deflate data"<<std::endl;
+        break;
+    case Z_MEM_ERROR:
+        dstream<<"out of memory"<<std::endl;
+        break;
+    case Z_VERSION_ERROR:
+        dstream<<"zlib version mismatch!"<<std::endl;
 		break;
 	default:
-		dstream << "return value = " << ret << std::endl;
-	}
+		dstream<<"return value = "<<ret<<std::endl;
+    }
 }
 
 void compressZlib(const u8 *data, size_t data_size, std::ostream &os, int level)
@@ -64,28 +64,30 @@ void compressZlib(const u8 *data, size_t data_size, std::ostream &os, int level)
 	z.opaque = Z_NULL;
 
 	ret = deflateInit(&z, level);
-	if (ret != Z_OK)
+	if(ret != Z_OK)
 		throw SerializationError("compressZlib: deflateInit failed");
 
 	// Point zlib to our input buffer
-	z.next_in = (Bytef *)&data[0];
+	z.next_in = (Bytef*)&data[0];
 	z.avail_in = data_size;
 	// And get all output
-	for (;;) {
-		z.next_out = (Bytef *)output_buffer;
+	for(;;)
+	{
+		z.next_out = (Bytef*)output_buffer;
 		z.avail_out = bufsize;
 
 		status = deflate(&z, Z_FINISH);
-		if (status == Z_NEED_DICT || status == Z_DATA_ERROR ||
-				status == Z_MEM_ERROR) {
+		if(status == Z_NEED_DICT || status == Z_DATA_ERROR
+				|| status == Z_MEM_ERROR)
+		{
 			zerr(status);
 			throw SerializationError("compressZlib: deflate failed");
 		}
 		int count = bufsize - z.avail_out;
-		if (count)
+		if(count)
 			os.write(output_buffer, count);
 		// This determines zlib has given all output
-		if (status == Z_STREAM_END)
+		if(status == Z_STREAM_END)
 			break;
 	}
 
@@ -94,7 +96,7 @@ void compressZlib(const u8 *data, size_t data_size, std::ostream &os, int level)
 
 void compressZlib(const std::string &data, std::ostream &os, int level)
 {
-	compressZlib((u8 *)data.c_str(), data.size(), os, level);
+	compressZlib((u8*)data.c_str(), data.size(), os, level);
 }
 
 void decompressZlib(std::istream &is, std::ostream &os, size_t limit)
@@ -114,16 +116,17 @@ void decompressZlib(std::istream &is, std::ostream &os, size_t limit)
 	z.opaque = Z_NULL;
 
 	ret = inflateInit(&z);
-	if (ret != Z_OK)
+	if(ret != Z_OK)
 		throw SerializationError("dcompressZlib: inflateInit failed");
 
 	z.avail_in = 0;
 
-	// dstream<<"initial fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
+	//dstream<<"initial fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
 
-	for (;;) {
+	for(;;)
+	{
 		int output_size = bufsize;
-		z.next_out = (Bytef *)output_buffer;
+		z.next_out = (Bytef*)output_buffer;
 		z.avail_out = output_size;
 
 		if (limit) {
@@ -137,50 +140,53 @@ void decompressZlib(std::istream &is, std::ostream &os, size_t limit)
 			}
 		}
 
-		if (z.avail_in == 0) {
-			z.next_in = (Bytef *)input_buffer;
+		if(z.avail_in == 0)
+		{
+			z.next_in = (Bytef*)input_buffer;
 			is.read(input_buffer, bufsize);
 			input_buffer_len = is.gcount();
 			z.avail_in = input_buffer_len;
-			// dstream<<"read fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
+			//dstream<<"read fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
 		}
-		if (z.avail_in == 0) {
-			// dstream<<"z.avail_in == 0"<<std::endl;
+		if(z.avail_in == 0)
+		{
+			//dstream<<"z.avail_in == 0"<<std::endl;
 			break;
 		}
 
-		// dstream<<"1 z.avail_in="<<z.avail_in<<std::endl;
+		//dstream<<"1 z.avail_in="<<z.avail_in<<std::endl;
 		status = inflate(&z, Z_NO_FLUSH);
-		// dstream<<"2 z.avail_in="<<z.avail_in<<std::endl;
+		//dstream<<"2 z.avail_in="<<z.avail_in<<std::endl;
 		bytes_read += is.gcount() - z.avail_in;
-		// dstream<<"bytes_read="<<bytes_read<<std::endl;
+		//dstream<<"bytes_read="<<bytes_read<<std::endl;
 
-		if (status == Z_NEED_DICT || status == Z_DATA_ERROR ||
-				status == Z_MEM_ERROR) {
+		if(status == Z_NEED_DICT || status == Z_DATA_ERROR
+				|| status == Z_MEM_ERROR)
+		{
 			zerr(status);
 			throw SerializationError("decompressZlib: inflate failed");
 		}
 		int count = output_size - z.avail_out;
-		// dstream<<"count="<<count<<std::endl;
-		if (count)
+		//dstream<<"count="<<count<<std::endl;
+		if(count)
 			os.write(output_buffer, count);
 		bytes_written += count;
-		if (status == Z_STREAM_END) {
-			// dstream<<"Z_STREAM_END"<<std::endl;
+		if(status == Z_STREAM_END)
+		{
+			//dstream<<"Z_STREAM_END"<<std::endl;
 
-			// dstream<<"z.avail_in="<<z.avail_in<<std::endl;
-			// dstream<<"fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
+			//dstream<<"z.avail_in="<<z.avail_in<<std::endl;
+			//dstream<<"fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
 			// Unget all the data that inflate didn't take
 			is.clear(); // Just in case EOF is set
-			for (u32 i = 0; i < z.avail_in; i++) {
+			for(u32 i=0; i < z.avail_in; i++)
+			{
 				is.unget();
-				if (is.fail() || is.bad()) {
-					dstream << "unget #" << i << " failed"
-						<< std::endl;
-					dstream << "fail=" << is.fail()
-						<< " bad=" << is.bad() << std::endl;
-					throw SerializationError(
-							"decompressZlib: unget failed");
+				if(is.fail() || is.bad())
+				{
+					dstream<<"unget #"<<i<<" failed"<<std::endl;
+					dstream<<"fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
+					throw SerializationError("decompressZlib: unget failed");
 				}
 			}
 
@@ -193,42 +199,51 @@ void decompressZlib(std::istream &is, std::ostream &os, size_t limit)
 
 void compress(const SharedBuffer<u8> &data, std::ostream &os, u8 version)
 {
-	if (version >= 11) {
-		compressZlib(*data, data.getSize(), os);
+	if(version >= 11)
+	{
+		compressZlib(*data ,data.getSize(), os);
 		return;
 	}
 
-	if (data.getSize() == 0)
+	if(data.getSize() == 0)
 		return;
 
 	// Write length (u32)
 
 	u8 tmp[4];
 	writeU32(tmp, data.getSize());
-	os.write((char *)tmp, 4);
+	os.write((char*)tmp, 4);
 
 	// We will be writing 8-bit pairs of more_count and byte
 	u8 more_count = 0;
 	u8 current_byte = data[0];
-	for (u32 i = 1; i < data.getSize(); i++) {
-		if (data[i] != current_byte || more_count == 255) {
+	for(u32 i=1; i<data.getSize(); i++)
+	{
+		if(
+			data[i] != current_byte
+			|| more_count == 255
+		)
+		{
 			// write count and byte
-			os.write((char *)&more_count, 1);
-			os.write((char *)&current_byte, 1);
+			os.write((char*)&more_count, 1);
+			os.write((char*)&current_byte, 1);
 			more_count = 0;
 			current_byte = data[i];
-		} else {
+		}
+		else
+		{
 			more_count++;
 		}
 	}
 	// write count and byte
-	os.write((char *)&more_count, 1);
-	os.write((char *)&current_byte, 1);
+	os.write((char*)&more_count, 1);
+	os.write((char*)&current_byte, 1);
 }
 
 void decompress(std::istream &is, std::ostream &os, u8 version)
 {
-	if (version >= 11) {
+	if(version >= 11)
+	{
 		decompressZlib(is, os);
 		return;
 	}
@@ -236,28 +251,31 @@ void decompress(std::istream &is, std::ostream &os, u8 version)
 	// Read length (u32)
 
 	u8 tmp[4];
-	is.read((char *)tmp, 4);
+	is.read((char*)tmp, 4);
 	u32 len = readU32(tmp);
 
 	// We will be reading 8-bit pairs of more_count and byte
 	u32 count = 0;
-	for (;;) {
-		u8 more_count = 0;
-		u8 byte = 0;
+	for(;;)
+	{
+		u8 more_count=0;
+		u8 byte=0;
 
-		is.read((char *)&more_count, 1);
+		is.read((char*)&more_count, 1);
 
-		is.read((char *)&byte, 1);
+		is.read((char*)&byte, 1);
 
-		if (is.eof())
+		if(is.eof())
 			throw SerializationError("decompress: stream ended halfway");
 
-		for (s32 i = 0; i < (u16)more_count + 1; i++)
-			os.write((char *)&byte, 1);
+		for(s32 i=0; i<(u16)more_count+1; i++)
+			os.write((char*)&byte, 1);
 
-		count += (u16)more_count + 1;
+		count += (u16)more_count+1;
 
-		if (count == len)
+		if(count == len)
 			break;
 	}
 }
+
+
-- 
cgit v1.2.3