Refactoring: Fix compilation warnings

Author: rhash

hash_check.c

@@ -298,7 +298,7 @@ enum HashNameMatchModes {
  *                   allowed.
  * @return id of hash function if found, zero otherwise
  */
-static unsigned bsd_hash_name_to_id(const char* name, unsigned length, enum HashNameMatchModes match_mode)
+static unsigned bsd_hash_name_to_id(const char* name, size_t length, enum HashNameMatchModes match_mode)
 {
 #define code2mask_size (19 * 2)
 	static unsigned code2mask[code2mask_size] = {
@@ -522,7 +522,7 @@ static int match_hash_tokens(struct hash_token* token, const char* format, unsig
 				buf[len] = toupper(begin[len]);
 			}
 			buf[len] = '\0';
-			token->expected_hash_id = bsd_hash_name_to_id(buf, len, ExactMatch);
+			token->expected_hash_id = bsd_hash_name_to_id(buf, (size_t)len, ExactMatch);
 			if (!token->expected_hash_id)
 				return ResFailed;
 			token->hash_type = FmtAll;
@@ -1048,7 +1048,7 @@ unsigned get_crc32(struct rhash_context* ctx)
 static int do_hash_sums_match(struct hash_parser* parser, struct rhash_context* ctx)
 {
 	uint64_t hash_mask = parser->hash_mask;
-	unsigned unverified_mask;
+	uint64_t unverified_mask;
 	unsigned printed;
 	char hex[132], base32[104], base64[88];
 	int j;
@@ -1067,7 +1067,7 @@ static int do_hash_sums_match(struct hash_parser* parser, struct rhash_context*
 	if (parser->hashes_num == 0)
 		return !HP_FAILED(parser->bit_flags);
 
-	unverified_mask = (1 << parser->hashes_num) - 1;
+	unverified_mask = ((uint64_t)1 << parser->hashes_num) - 1;
 
 	while(hash_mask && unverified_mask) {
 		uint64_t bit64 = hash_mask & -hash_mask;
@@ -1084,7 +1084,7 @@ static int do_hash_sums_match(struct hash_parser* parser, struct rhash_context*
 			int comparision_mode;
 
 			/* skip already verified message digests and message digests of different size */
-			if (!(unverified_mask & (1 << j)) || !(hv->hash_mask & bit64))
+			if (!(unverified_mask & ((uint64_t)1 << j)) || !(hv->hash_mask & bit64))
 				continue;
 			comparision_mode = 0;
 			bit_length = rhash_get_digest_size(hash_id) * 8;
@@ -1127,7 +1127,7 @@ static int do_hash_sums_match(struct hash_parser* parser, struct rhash_context*
 			if (!is_hash_string_equal(calculated_hash, expected_hash, hv->length, comparision_mode))
 				continue;
 
-			unverified_mask &= ~(1 << j); /* mark the j-th message digest as verified */
+			unverified_mask &= ~((uint64_t)1 << j); /* mark the j-th message digest as verified */
 			parser->found_hash_ids |= bit64;
 
 			/* end the loop if all message digests were successfully verified */

hash_print.c

@@ -497,8 +497,11 @@ static int print_time64(FILE* out, uint64_t time64, int sfv_format)
 
 static int is_gost94(unsigned hash_id)
 {
-	static unsigned gost94_id = hash_id_to_extended(RHASH_GOST94);
-	static unsigned gost94_cryptopro_id = hash_id_to_extended(RHASH_GOST94_CRYPTOPRO);
+	static unsigned gost94_id = 0, gost94_cryptopro_id = 0;
+	if (!gost94_id) {
+		gost94_id = hash_id_to_extended(RHASH_GOST94);
+		gost94_cryptopro_id = hash_id_to_extended(RHASH_GOST94_CRYPTOPRO);
+	}
 	return (hash_id == gost94_id || hash_id == gost94_cryptopro_id);
 }
 
@@ -687,6 +690,7 @@ void init_hash_info_table(void)
 			*(short_opt++) : 0);
 
 		info->name = rhash_get_name(hash_id);
+		RSH_REQUIRE(info->name != NULL, "rhash_get_name(0x%08x) failed\n", hash_id);
 		assert(strlen(info->name) < 19);
 		p = info->name;
 		d = info->short_name;
@@ -736,7 +740,7 @@ void init_hash_info_table(void)
 			}
 		} else
 			info->bsd_name = info->name;
-		assert(info->bsd_name);
+		RSH_REQUIRE(info->bsd_name, "No BSD name for hash id 0x%08x\n", hash_id);
 		++info;
 	}
 	assert((info - hash_info_table) == RHASH_HASH_COUNT);

librhash/algorithms.c

@@ -223,7 +223,12 @@ const unsigned* rhash_get_all_hash_ids(unsigned all_id, size_t* count)
 		EXTENDED_HASH_ID(24), EXTENDED_HASH_ID(25), EXTENDED_HASH_ID(26), EXTENDED_HASH_ID(27),
 		EXTENDED_HASH_ID(28), EXTENDED_HASH_ID(29), EXTENDED_HASH_ID(30), EXTENDED_HASH_ID(31)
 	};
+#if defined(rhash_popcount)
 	static const unsigned count_low = rhash_popcount(RHASH_LOW_HASHES_MASK);
+#else
+	RHASH_ASSERT(RHASH_LOW_HASHES_MASK == 0x7fffffff);
+	static const unsigned count_low = 31; /* popcount(RHASH_LOW_HASHES_MASK) */
+#endif
 	RHASH_ASSERT(RHASH_COUNTOF(all_ids) == RHASH_HASH_COUNT);
 	*count = (all_id == RHASH_ALL_HASHES ? RHASH_HASH_COUNT : count_low);
 	return all_ids;

librhash/blake3.c

@@ -178,7 +178,7 @@ static void process_block(struct blake3_ctx *ctx, const uint32_t msg[static 16])
 		cur_hash += words_per_stack_entry;
 		memcpy(cur_hash, blake3_IV, sizeof(blake3_IV));
 	}
-	ctx->stack_depth = (cur_hash - ctx->stack) / words_per_stack_entry;
+	ctx->stack_depth = (uint32_t)((cur_hash - ctx->stack) / words_per_stack_entry);
 }
 
 /**

librhash/byte_order.c

@@ -278,7 +278,7 @@ static uint64_t get_cpuid_features(void)
 int has_cpu_feature(unsigned feature_bit)
 {
 	static uint64_t features;
-	const uint64_t feature = ((uint64_t)1) << feature_bit;
+	const uint64_t feature = I64(1) << feature_bit;
 	if (!features)
 		features = (get_cpuid_features() | 1);
 	return !!(features & feature);

librhash/gost12.c

@@ -619,7 +619,7 @@ static const uint64_t zero_512[8] = { 0,0,0,0,0,0,0,0 };
  * @param ctx context to initialize
  * @param hash_size the size of the digest in bytes
  */
-static RHASH_INLINE void rhash_gost12_init(gost12_ctx* ctx, size_t hash_size)
+static RHASH_INLINE void rhash_gost12_init(gost12_ctx* ctx, unsigned hash_size)
 {
 	memset(ctx, 0, sizeof(gost12_ctx));
 	if (hash_size != gost12_512_hash_size)
@@ -808,7 +808,7 @@ void rhash_gost12_update(gost12_ctx* ctx, const unsigned char* msg, size_t size)
 		size_t rest = gost12_block_size - ctx->index;
 
 		le64_copy(ctx->message, ctx->index, msg, (size < rest ? size : rest));
-		ctx->index += size;
+		ctx->index += (unsigned)size;
 		if (size < rest)
 			return;
 
@@ -837,7 +837,7 @@ void rhash_gost12_update(gost12_ctx* ctx, const unsigned char* msg, size_t size)
 	}
 	if (size)
 	{
-		ctx->index = size;
+		ctx->index = (unsigned)size;
 		le64_copy(ctx->message, 0, msg, size); /* save leftovers */
 	}
 }

librhash/rhash.c

@@ -37,6 +37,10 @@
 #include <stddef.h>
 #include <string.h>
 
+#if defined(_WIN32)
+# include <io.h>
+#endif
+
 #define STATE_ACTIVE  0xb01dbabe
 #define STATE_STOPPED 0xdeadbeef
 #define STATE_DELETED 0xdecea5ed
@@ -106,7 +110,7 @@ static rhash_context_ext* rhash_alloc_multi(size_t count, const unsigned hash_id
 		}
 		assert(IS_EXTENDED_HASH_ID(info->info->hash_id));
 		assert(IS_VALID_EXTENDED_HASH_ID(info->info->hash_id));
-		hash_bitmask |= 1 << GET_EXTENDED_HASH_ID_INDEX(info->info->hash_id);
+		hash_bitmask |= I64(1) << GET_EXTENDED_HASH_ID_INDEX(info->info->hash_id);
 
 		/* align context sizes and sum up */
 		ctx_size_sum += GET_CTX_ALIGNED(info->context_size);
@@ -122,7 +126,7 @@ static rhash_context_ext* rhash_alloc_multi(size_t count, const unsigned hash_id
 	rctx->rc.hash_mask = hash_bitmask;
 	rctx->flags = RCTX_AUTO_FINAL; /* turn on auto-final by default */
 	rctx->state = STATE_ACTIVE;
-	rctx->hash_vector_size = count;
+	rctx->hash_vector_size = (unsigned)count;
 
 	/* calculate aligned pointer >= (&rctx->vector[count]) */
 	phash_ctx = (char*)rctx + header_size;
@@ -402,7 +406,7 @@ RHASH_API rhash rhash_import(const void* in, size_t size)
 			item_size = rhash_import_alg(hash_ids[i], dst_context, src_item, left_size);
 			imported_size += item_size;
 			if (!item_size || size < imported_size) {
-				ectx->hash_vector_size = i + 1; /* clean only initialized contextes */
+				ectx->hash_vector_size = (unsigned)i + 1; /* clean only initialized contextes */
 				rhash_free(&ectx->rc);
 				return import_error_einval();
 			}
@@ -411,7 +415,7 @@ RHASH_API rhash rhash_import(const void* in, size_t size)
 			item_size = hash_info->context_size;
 			imported_size += item_size;
 			if (size < imported_size) {
-				ectx->hash_vector_size = i + 1;
+				ectx->hash_vector_size = (unsigned)i + 1;
 				rhash_free(&ectx->rc);
 				return import_error_einval();
 			}
@@ -528,6 +532,14 @@ struct file_update_context {
 	size_t buffer_size;    /* Size of the data buffer */
 };
 
+#if defined(_WIN32)
+/* For Windows define ssize_t, which is Posix, but not in standard C */
+# define ssize_t intptr_t
+# define READ_SIZE_TYPE unsigned
+#else
+# define READ_SIZE_TYPE size_t
+#endif
+
 /**
  * Read data from a C file stream into the context buffer using fread().
  *
@@ -555,7 +567,7 @@ static ssize_t read_file_fd_impl(struct file_update_context *fctx, size_t data_s
 static ssize_t read_int_fd_impl(struct file_update_context *fctx, size_t data_size)
 {
 	assert(data_size <= fctx->buffer_size);
-	return read(fctx->int_fd, fctx->buffer, data_size);
+	return read(fctx->int_fd, fctx->buffer, (READ_SIZE_TYPE)data_size);
 }
 
 /**
@@ -723,13 +735,13 @@ RHASH_API int rhash_get_hash_length(unsigned hash_id)
 RHASH_API const char* rhash_get_name(unsigned hash_id)
 {
 	const rhash_info* info = rhash_info_by_id(hash_id);
-	return (info ? info->name : 0);
+	return (info ? info->name : NULL);
 }
 
 RHASH_API const char* rhash_get_magnet_name(unsigned hash_id)
 {
 	const rhash_info* info = rhash_info_by_id(hash_id);
-	return (info ? info->magnet_name : 0);
+	return (info ? info->magnet_name : NULL);
 }
 
 static size_t rhash_get_magnet_url_size(const char* filepath,

librhash/sha_ni.c

@@ -397,7 +397,7 @@ static void rhash_sha256_ni_process_block(unsigned* state, const uint8_t* block,
         MSG1 = _mm_sha256msg1_epu32(MSG1, MSG2);
 
         /* Rounds 28-31 */
-        MSG = _mm_add_epi32(MSG3, _mm_set_epi64x(0x1429296706CA6351ULL,  0xD5A79147C6E00BF3ULL));
+        MSG = _mm_add_epi32(MSG3, _mm_set_epi64x(0x1429296706CA6351ULL, 0xD5A79147C6E00BF3ULL));
         STATE1 = _mm_sha256rnds2_epu32(STATE1, STATE0, MSG);
         TMP = _mm_alignr_epi8(MSG3, MSG2, 4);
         MSG0 = _mm_add_epi32(MSG0, TMP);

output.c

@@ -38,13 +38,15 @@ struct percents_output_info_t* percents_output = NULL;
  */
 static int count_printed_size(const char* format, const char* path, unsigned output_flags)
 {
-	size_t format_length = 0;
+	size_t format_length = 0, total_length;
 	if (format) {
 		assert(strstr(format, "%s") != NULL);
 		format_length = (IS_UTF8() ? count_utf8_symbols(format) : strlen(format)) - 2;
 	}
 	assert(path != NULL);
-	return format_length + (IS_UTF8() || (output_flags & OutForceUtf8) ? count_utf8_symbols(path) : strlen(path));
+	total_length = format_length + (IS_UTF8() || (output_flags & OutForceUtf8) ?
+		count_utf8_symbols(path) : strlen(path));
+	return (int)total_length;
 }
 
 /**
@@ -123,7 +125,7 @@ static int fprint_escaped(FILE* out, const char* str, unsigned output_flags)
 		pos = 0;
 	}
 	if ((output_flags & OutCountSymbols) != 0)
-		return escaped + count_printed_size(NULL, str, output_flags);
+		return (int)escaped + count_printed_size(NULL, str, output_flags);
 	return 0;
 }
 
@@ -397,8 +399,9 @@ static int print_verbose_hash_check_error(struct file_info* info)
 			struct hash_value* hv = &info->hp->hashes[i];
 			char* expected_hash = info->hp->line_begin + hv->offset;
 			uint64_t hid = hv->hash_mask;
+			uint32_t hash_id;
 			int pflags;
-			if ((info->hp->wrong_hashes & (1 << i)) == 0)
+			if ((info->hp->wrong_hashes & ((uint64_t)1 << i)) == 0)
 				continue;
 
 			assert(hid != 0);
@@ -414,13 +417,14 @@ static int print_verbose_hash_check_error(struct file_info* info)
 			}
 			assert(hid != 0 && (hid & (hid - 1)) == 0); /* single bit only */
 			reported |= hid;
+			hash_id = bit64_to_hash_id(hid);
 
-			pflags = (hv->length == (rhash_get_digest_size(hid) * 2) ?
+			pflags = (hv->length == (rhash_get_digest_size(hash_id) * 2) ?
 				(RHPR_HEX | RHPR_UPPERCASE) : (RHPR_BASE32 | RHPR_UPPERCASE));
-			rhash_print(actual, info->rctx, hid, pflags);
+			rhash_print(actual, info->rctx, hash_id, pflags);
 			/* TRANSLATORS: print a message like "CRC32 is ABC12345 should be BCA54321" */
 			if (rsh_fprintf(rhash_data.out, _(", %s is %s should be %s"),
-					rhash_get_name(hid), actual, expected_hash) < 0)
+					rhash_get_name(hash_id), actual, expected_hash) < 0)
 				return -1;
 		}
 	}