cmph: Remove C99ism and other fixes

...So that it will compile on non-C99 compilers.  The changes are mainly
moving the variable declarations to the start of the resecptive blocks.

Also, replace the use of buflen in chd.c as it might not be defined for all
platforms, instead using packed_cr_size as it seems to represent the value
that is to be printed/displayed by the debugging output.

https://bugzilla.gnome.org/show_bug.cgi?id=681820

11 files changed, 252 insertions, 152 deletions

diff --git a/girepository/cmph/bdz.c b/girepository/cmph/bdz.c
index a385b152..81cd7151 100755
--- a/girepository/cmph/bdz.c
+++ b/girepository/cmph/bdz.c
@@ -489,6 +489,10 @@ int bdz_dump(cmph_t *mphf, FILE *fd)
 	cmph_uint32 buflen;
 	register size_t nbytes;
 	bdz_data_t *data = (bdz_data_t *)mphf->data;
+	cmph_uint32 sizeg;
+#ifdef DEBUG
+	cmph_uint32 i;
+#endif
 	__cmph_dump(mphf, fd);
 
 	hash_state_dump(data->hl, &buf, &buflen);
@@ -501,7 +505,7 @@ int bdz_dump(cmph_t *mphf, FILE *fd)
 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
 	nbytes = fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);
 	
-	cmph_uint32 sizeg = (cmph_uint32)ceil(data->n/4.0);
+	sizeg = (cmph_uint32)ceil(data->n/4.0);
 	nbytes = fwrite(data->g, sizeof(cmph_uint8)*sizeg, (size_t)1, fd);
 
 	nbytes = fwrite(&(data->k), sizeof(cmph_uint32), (size_t)1, fd);
@@ -509,12 +513,11 @@ int bdz_dump(cmph_t *mphf, FILE *fd)
 	nbytes = fwrite(&(data->ranktablesize), sizeof(cmph_uint32), (size_t)1, fd);
 
 	nbytes = fwrite(data->ranktable, sizeof(cmph_uint32)*(data->ranktablesize), (size_t)1, fd);
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
 	#ifdef DEBUG
-	cmph_uint32 i;
 	fprintf(stderr, "G: ");
 	for (i = 0; i < data->n; ++i) fprintf(stderr, "%u ", GETVALUE(data->g, i));
 	fprintf(stderr, "\n");
@@ -528,6 +531,9 @@ void bdz_load(FILE *f, cmph_t *mphf)
 	cmph_uint32 buflen, sizeg;
 	register size_t nbytes;
 	bdz_data_t *bdz = (bdz_data_t *)malloc(sizeof(bdz_data_t));
+#ifdef DEBUG
+	cmph_uint32  i = 0;
+#endif
 
 	DEBUGP("Loading bdz mphf\n");
 	mphf->data = bdz;
@@ -554,13 +560,13 @@ void bdz_load(FILE *f, cmph_t *mphf)
 
 	bdz->ranktable = (cmph_uint32 *)calloc((size_t)bdz->ranktablesize, sizeof(cmph_uint32));
 	nbytes = fread(bdz->ranktable, sizeof(cmph_uint32)*(bdz->ranktablesize), (size_t)1, f);
-        if (nbytes == 0 && ferror(f)) {
+	if (nbytes == 0 && ferror(f)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return;
         }
 
 	#ifdef DEBUG
-	cmph_uint32  i = 0;
+	i = 0;
 	fprintf(stderr, "G: ");
 	for (i = 0; i < bdz->n; ++i) fprintf(stderr, "%u ", GETVALUE(bdz->g,i));
 	fprintf(stderr, "\n");
@@ -639,6 +645,7 @@ void bdz_pack(cmph_t *mphf, void *packed_mphf)
 {
 	bdz_data_t *data = (bdz_data_t *)mphf->data;
 	cmph_uint8 * ptr = packed_mphf;
+	cmph_uint32 sizeg;
 
 	// packing hl type
 	CMPH_HASH hl_type = hash_get_type(data->hl);
@@ -665,7 +672,7 @@ void bdz_pack(cmph_t *mphf, void *packed_mphf)
 	*ptr++ = data->b;
 
 	// packing g
-	cmph_uint32 sizeg = (cmph_uint32)ceil(data->n/4.0);
+	sizeg = (cmph_uint32)ceil(data->n/4.0);
 	memcpy(ptr, data->g,  sizeof(cmph_uint8)*sizeg);
 }
 
diff --git a/girepository/cmph/bdz_ph.c b/girepository/cmph/bdz_ph.c
index 2e986071..2095f116 100755
--- a/girepository/cmph/bdz_ph.c
+++ b/girepository/cmph/bdz_ph.c
@@ -452,6 +452,10 @@ int bdz_ph_dump(cmph_t *mphf, FILE *fd)
 	cmph_uint32 sizeg = 0;
 	register size_t nbytes;
 	bdz_ph_data_t *data = (bdz_ph_data_t *)mphf->data;
+#ifdef DEBUG
+	cmph_uint32 i;
+#endif
+
 	__cmph_dump(mphf, fd);
 
 	hash_state_dump(data->hl, &buf, &buflen);
@@ -466,12 +470,11 @@ int bdz_ph_dump(cmph_t *mphf, FILE *fd)
 	sizeg = (cmph_uint32)ceil(data->n/5.0);	
 	nbytes = fwrite(data->g, sizeof(cmph_uint8)*sizeg, (size_t)1, fd);
 
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
 	#ifdef DEBUG
-	cmph_uint32 i;
 	fprintf(stderr, "G: ");
 	for (i = 0; i < data->n; ++i) fprintf(stderr, "%u ", GETVALUE(data->g, i));
 	fprintf(stderr, "\n");
@@ -506,7 +509,7 @@ void bdz_ph_load(FILE *f, cmph_t *mphf)
 	bdz_ph->g = (cmph_uint8 *)calloc((size_t)sizeg, sizeof(cmph_uint8));
 	nbytes = fread(bdz_ph->g, sizeg*sizeof(cmph_uint8), (size_t)1, f);
 
-        if (nbytes == 0 && ferror(f)) {
+	if (nbytes == 0 && ferror(f)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
         }
 	return;
@@ -556,6 +559,7 @@ void bdz_ph_pack(cmph_t *mphf, void *packed_mphf)
 {
 	bdz_ph_data_t *data = (bdz_ph_data_t *)mphf->data;
 	cmph_uint8 * ptr = packed_mphf;
+	cmph_uint32 sizeg;
 
 	// packing hl type
 	CMPH_HASH hl_type = hash_get_type(data->hl);
@@ -571,7 +575,7 @@ void bdz_ph_pack(cmph_t *mphf, void *packed_mphf)
 	ptr += sizeof(data->r);
 
 	// packing g
-	cmph_uint32 sizeg = (cmph_uint32)ceil(data->n/5.0);
+	sizeg = (cmph_uint32)ceil(data->n/5.0);
 	memcpy(ptr, data->g,  sizeof(cmph_uint8)*sizeg);
 }
 
diff --git a/girepository/cmph/bmz.c b/girepository/cmph/bmz.c
index 9c6cea00..9573825a 100644
--- a/girepository/cmph/bmz.c
+++ b/girepository/cmph/bmz.c
@@ -450,6 +450,10 @@ int bmz_dump(cmph_t *mphf, FILE *fd)
 	cmph_uint32 two = 2; //number of hash functions
 	bmz_data_t *data = (bmz_data_t *)mphf->data;
 	register size_t nbytes;
+#ifdef DEBUG
+	cmph_uint32 i;
+#endif
+
 	__cmph_dump(mphf, fd);
 
 	nbytes = fwrite(&two, sizeof(cmph_uint32), (size_t)1, fd);
@@ -470,12 +474,11 @@ int bmz_dump(cmph_t *mphf, FILE *fd)
 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
 	
 	nbytes = fwrite(data->g, sizeof(cmph_uint32)*(data->n), (size_t)1, fd);
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
 	#ifdef DEBUG
-	cmph_uint32 i;
 	fprintf(stderr, "G: ");
 	for (i = 0; i < data->n; ++i) fprintf(stderr, "%u ", data->g[i]);
 	fprintf(stderr, "\n");
@@ -515,10 +518,11 @@ void bmz_load(FILE *f, cmph_t *mphf)
 
 	bmz->g = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*bmz->n);
 	nbytes = fread(bmz->g, bmz->n*sizeof(cmph_uint32), (size_t)1, f);
-        if (nbytes == 0 && ferror(f)) {
+	if (nbytes == 0 && ferror(f)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return;
         }
+
 	#ifdef DEBUG
 	fprintf(stderr, "G: ");
 	for (i = 0; i < bmz->n; ++i) fprintf(stderr, "%u ", bmz->g[i]);
@@ -559,6 +563,7 @@ void bmz_pack(cmph_t *mphf, void *packed_mphf)
 
 	bmz_data_t *data = (bmz_data_t *)mphf->data;
 	cmph_uint8 * ptr = packed_mphf;
+	CMPH_HASH h2_type;
 
 	// packing h1 type
 	CMPH_HASH h1_type = hash_get_type(data->hashes[0]);
@@ -570,7 +575,7 @@ void bmz_pack(cmph_t *mphf, void *packed_mphf)
 	ptr += hash_state_packed_size(h1_type);
 
 	// packing h2 type
-	CMPH_HASH h2_type = hash_get_type(data->hashes[1]);
+	h2_type = hash_get_type(data->hashes[1]);
 	*((cmph_uint32 *) ptr) = h2_type;
 	ptr += sizeof(cmph_uint32);
 
@@ -612,18 +617,22 @@ cmph_uint32 bmz_search_packed(void *packed_mphf, const char *key, cmph_uint32 ke
 {
 	register cmph_uint8 *h1_ptr = packed_mphf;
 	register CMPH_HASH h1_type  = *((cmph_uint32 *)h1_ptr);
+	register cmph_uint8 *h2_ptr;
+	register CMPH_HASH h2_type;
+	register cmph_uint32 *g_ptr, n, h1, h2;
+
 	h1_ptr += 4;
 
-	register cmph_uint8 *h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
-	register CMPH_HASH h2_type  = *((cmph_uint32 *)h2_ptr);
+	h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
+	h2_type  = *((cmph_uint32 *)h2_ptr);
 	h2_ptr += 4;
 	
-	register cmph_uint32 *g_ptr = (cmph_uint32 *)(h2_ptr + hash_state_packed_size(h2_type));
+	g_ptr = (cmph_uint32 *)(h2_ptr + hash_state_packed_size(h2_type));
 	
-	register cmph_uint32 n = *g_ptr++;  
+	n = *g_ptr++;
 	
-	register cmph_uint32 h1 = hash_packed(h1_ptr, h1_type, key, keylen) % n; 
-	register cmph_uint32 h2 = hash_packed(h2_ptr, h2_type, key, keylen) % n; 
+	h1 = hash_packed(h1_ptr, h1_type, key, keylen) % n;
+	h2 = hash_packed(h2_ptr, h2_type, key, keylen) % n;
 	if (h1 == h2 && ++h2 > n) h2 = 0;
 	return (g_ptr[h1] + g_ptr[h2]);	
 }
diff --git a/girepository/cmph/bmz8.c b/girepository/cmph/bmz8.c
index 206c48c4..15853c00 100644
--- a/girepository/cmph/bmz8.c
+++ b/girepository/cmph/bmz8.c
@@ -483,7 +483,7 @@ int bmz8_dump(cmph_t *mphf, FILE *fd)
 	nbytes = fwrite(&(data->m), sizeof(cmph_uint8), (size_t)1, fd);
 	
 	nbytes = fwrite(data->g, sizeof(cmph_uint8)*(data->n), (size_t)1, fd);
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
@@ -528,10 +528,11 @@ void bmz8_load(FILE *f, cmph_t *mphf)
 
 	bmz8->g = (cmph_uint8 *)malloc(sizeof(cmph_uint8)*bmz8->n);
 	nbytes = fread(bmz8->g, bmz8->n*sizeof(cmph_uint8), (size_t)1, f);
-        if (nbytes == 0 && ferror(f)) {
+	if (nbytes == 0 && ferror(f)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return;
         }
+
 	#ifdef DEBUG
 	fprintf(stderr, "G: ");
 	for (i = 0; i < bmz8->n; ++i) fprintf(stderr, "%u ", bmz8->g[i]);
@@ -571,6 +572,7 @@ void bmz8_pack(cmph_t *mphf, void *packed_mphf)
 {
 	bmz8_data_t *data = (bmz8_data_t *)mphf->data;
 	cmph_uint8 * ptr = packed_mphf;
+	CMPH_HASH h2_type;
 
 	// packing h1 type
 	CMPH_HASH h1_type = hash_get_type(data->hashes[0]);
@@ -582,7 +584,7 @@ void bmz8_pack(cmph_t *mphf, void *packed_mphf)
 	ptr += hash_state_packed_size(h1_type);
 
 	// packing h2 type
-	CMPH_HASH h2_type = hash_get_type(data->hashes[1]);
+	h2_type = hash_get_type(data->hashes[1]);
 	*((cmph_uint32 *) ptr) = h2_type;
 	ptr += sizeof(cmph_uint32);
 
@@ -623,18 +625,22 @@ cmph_uint8 bmz8_search_packed(void *packed_mphf, const char *key, cmph_uint32 ke
 {
 	register cmph_uint8 *h1_ptr = packed_mphf;
 	register CMPH_HASH h1_type  = *((cmph_uint32 *)h1_ptr);
+	register cmph_uint8 *h2_ptr;
+	register CMPH_HASH h2_type;
+	register cmph_uint8 *g_ptr, n, h1, h2;
+
 	h1_ptr += 4;
 
-	register cmph_uint8 *h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
-	register CMPH_HASH h2_type  = *((cmph_uint32 *)h2_ptr);
+	h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
+	h2_type  = *((cmph_uint32 *)h2_ptr);
 	h2_ptr += 4;
 	
-	register cmph_uint8 *g_ptr = h2_ptr + hash_state_packed_size(h2_type);
+	g_ptr = h2_ptr + hash_state_packed_size(h2_type);
 	
-	register cmph_uint8 n = *g_ptr++;  
+	n = *g_ptr++;
 	
-	register cmph_uint8 h1 = (cmph_uint8)(hash_packed(h1_ptr, h1_type, key, keylen) % n); 
-	register cmph_uint8 h2 = (cmph_uint8)(hash_packed(h2_ptr, h2_type, key, keylen) % n); 
+	h1 = (cmph_uint8)(hash_packed(h1_ptr, h1_type, key, keylen) % n);
+	h2 = (cmph_uint8)(hash_packed(h2_ptr, h2_type, key, keylen) % n);
 	DEBUGP("key: %s h1: %u h2: %u\n", key, h1, h2);
 	if (h1 == h2 && ++h2 > n) h2 = 0;
 	return (cmph_uint8)(g_ptr[h1] + g_ptr[h2]);	
diff --git a/girepository/cmph/brz.c b/girepository/cmph/brz.c
index f0c91c4b..d1079c22 100755
--- a/girepository/cmph/brz.c
+++ b/girepository/cmph/brz.c
@@ -128,9 +128,10 @@ cmph_t *brz_new(cmph_config_t *mph, double c)
 	brz_data_t *brzf = NULL;
 	cmph_uint32 i;
 	cmph_uint32 iterations = 20;
+	brz_config_data_t *brz;
 
 	DEBUGP("c: %f\n", c);
-	brz_config_data_t *brz = (brz_config_data_t *)mph->data;
+	brz = (brz_config_data_t *)mph->data;
 	switch(brz->algo) // validating restrictions over parameter c.
 	{
 		case CMPH_BMZ8:
@@ -252,13 +253,14 @@ static int brz_gen_mphf(cmph_config_t *mph)
 		/* Buffers management */
 		if (memory_usage + keylen + sizeof(keylen) > brz->memory_availability) // flush buffers 
 		{
+			cmph_uint32 value, sum, keylen1;
 			if(mph->verbosity)
 			{
 				fprintf(stderr, "Flushing  %u\n", nkeys_in_buffer);
 			}
-			cmph_uint32 value = buckets_size[0];
-			cmph_uint32 sum = 0;
-			cmph_uint32 keylen1 = 0;
+			value = buckets_size[0];
+			sum = 0;
+			keylen1 = 0;
 			buckets_size[0]   = 0;
 			for(i = 1; i < brz->k; i++)
 			{
@@ -312,14 +314,16 @@ static int brz_gen_mphf(cmph_config_t *mph)
 		mph->key_source->dispose(mph->key_source->data, key, keylen);
 	}
 	if (memory_usage != 0) // flush buffers 
-	{ 
+	{
+		cmph_uint32 value;
+		cmph_uint32 sum, keylen1;
 		if(mph->verbosity)
 		{
 			fprintf(stderr, "Flushing  %u\n", nkeys_in_buffer);
 		}
-		cmph_uint32 value = buckets_size[0];
-		cmph_uint32 sum = 0;
-		cmph_uint32 keylen1 = 0;
+		value = buckets_size[0];
+		sum = 0;
+		keylen1 = 0;
 		buckets_size[0]   = 0;
 		for(i = 1; i < brz->k; i++)
 		{
@@ -371,7 +375,7 @@ static int brz_gen_mphf(cmph_config_t *mph)
 	nbytes = fwrite(&(brz->algo), sizeof(brz->algo), (size_t)1, brz->mphf_fd);
 	nbytes = fwrite(&(brz->k), sizeof(cmph_uint32), (size_t)1, brz->mphf_fd); // number of MPHFs
 	nbytes = fwrite(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, brz->mphf_fd);
-        if (nbytes == 0 && ferror(brz->mphf_fd)) {
+  if (nbytes == 0 && ferror(brz->mphf_fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
@@ -579,7 +583,7 @@ int brz_dump(cmph_t *mphf, FILE *fd)
 	// Dumping m and the vector offset.
 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);	
 	nbytes = fwrite(data->offset, sizeof(cmph_uint32)*(data->k), (size_t)1, fd);
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
@@ -648,24 +652,27 @@ void brz_load(FILE *f, cmph_t *mphf)
 	nbytes = fread(&(brz->m), sizeof(cmph_uint32), (size_t)1, f);
 	brz->offset = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*brz->k);
 	nbytes = fread(brz->offset, sizeof(cmph_uint32)*(brz->k), (size_t)1, f);
-        if (nbytes == 0 && ferror(f)) {
+	if (nbytes == 0 && ferror(f)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
         }
+
 	return;
 }
 
 static cmph_uint32 brz_bmz8_search(brz_data_t *brz, const char *key, cmph_uint32 keylen, cmph_uint32 * fingerprint)
 {
 	register cmph_uint32 h0;
+	register cmph_uint32 m, n, h1, h2;
+	register cmph_uint8 mphf_bucket;
 
 	hash_vector(brz->h0, key, keylen, fingerprint);
 	h0 = fingerprint[2] % brz->k;
 
-	register cmph_uint32 m = brz->size[h0];
-	register cmph_uint32 n = (cmph_uint32)ceil(brz->c * m);
-	register cmph_uint32 h1 = hash(brz->h1[h0], key, keylen) % n;
-	register cmph_uint32 h2 = hash(brz->h2[h0], key, keylen) % n;
-	register cmph_uint8 mphf_bucket;
+	m = brz->size[h0];
+	n = (cmph_uint32)ceil(brz->c * m);
+	h1 = hash(brz->h1[h0], key, keylen) % n;
+	h2 = hash(brz->h2[h0], key, keylen) % n;
+	mphf_bucket;
 	
 	if (h1 == h2 && ++h2 >= n) h2 = 0;
 	mphf_bucket = (cmph_uint8)(brz->g[h0][h1] + brz->g[h0][h2]); 
@@ -678,17 +685,20 @@ static cmph_uint32 brz_bmz8_search(brz_data_t *brz, const char *key, cmph_uint32
 static cmph_uint32 brz_fch_search(brz_data_t *brz, const char *key, cmph_uint32 keylen, cmph_uint32 * fingerprint)
 {
 	register cmph_uint32 h0;
+	register cmph_uint32 m, b, h1, h2;
+	register double p1, p2;
+	register cmph_uint8 mphf_bucket;
 
 	hash_vector(brz->h0, key, keylen, fingerprint);
 	h0 = fingerprint[2] % brz->k;
 
-	register cmph_uint32 m = brz->size[h0];
-	register cmph_uint32 b = fch_calc_b(brz->c, m);
-	register double p1 = fch_calc_p1(m);
-	register double p2 = fch_calc_p2(b);
-	register cmph_uint32 h1 = hash(brz->h1[h0], key, keylen) % m;
-	register cmph_uint32 h2 = hash(brz->h2[h0], key, keylen) % m;
-	register cmph_uint8 mphf_bucket = 0;
+	m = brz->size[h0];
+	b = fch_calc_b(brz->c, m);
+	p1 = fch_calc_p1(m);
+	p2 = fch_calc_p2(b);
+	h1 = hash(brz->h1[h0], key, keylen) % m;
+	h2 = hash(brz->h2[h0], key, keylen) % m;
+	mphf_bucket = 0;
 	h1 = mixh10h11h12(b, p1, p2, h1);
 	mphf_bucket = (cmph_uint8)((h2 + brz->g[h0][h1]) % m);
 	return (mphf_bucket + brz->offset[h0]);
@@ -741,13 +751,20 @@ void brz_pack(cmph_t *mphf, void *packed_mphf)
 	brz_data_t *data = (brz_data_t *)mphf->data;
 	cmph_uint8 * ptr = packed_mphf;
 	cmph_uint32 i,n;
+	CMPH_HASH h0_type, h1_type, h2_type;
+#if defined (__ia64) || defined (__x86_64__)
+	cmph_uint64 * g_is_ptr;
+#else
+	cmph_uint32 * g_is_ptr;
+#endif
+	cmph_uint8 * g_i;
 	
 	// packing internal algo type
 	memcpy(ptr, &(data->algo), sizeof(data->algo));
 	ptr += sizeof(data->algo);
 
 	// packing h0 type
-	CMPH_HASH h0_type = hash_get_type(data->h0); 
+	h0_type = hash_get_type(data->h0);
 	memcpy(ptr, &h0_type, sizeof(h0_type));
 	ptr += sizeof(h0_type);
 
@@ -764,12 +781,12 @@ void brz_pack(cmph_t *mphf, void *packed_mphf)
 	ptr += sizeof(data->c);
 
 	// packing h1 type
-	CMPH_HASH h1_type = hash_get_type(data->h1[0]); 
+	h1_type = hash_get_type(data->h1[0]);
 	memcpy(ptr, &h1_type, sizeof(h1_type));
 	ptr += sizeof(h1_type);
 
 	// packing h2 type
-	CMPH_HASH h2_type = hash_get_type(data->h2[0]); 
+	h2_type = hash_get_type(data->h2[0]);
 	memcpy(ptr, &h2_type, sizeof(h2_type));
 	ptr += sizeof(h2_type);
 
@@ -782,12 +799,12 @@ void brz_pack(cmph_t *mphf, void *packed_mphf)
 	ptr += sizeof(cmph_uint32)*data->k;
 	
 	#if defined (__ia64) || defined (__x86_64__)
-		cmph_uint64 * g_is_ptr = (cmph_uint64 *)ptr;
+		g_is_ptr = (cmph_uint64 *)ptr;
 	#else
-		cmph_uint32 * g_is_ptr = (cmph_uint32 *)ptr;
+		g_is_ptr = (cmph_uint32 *)ptr;
 	#endif
 	
-	cmph_uint8 * g_i = (cmph_uint8 *) (g_is_ptr + data->k);
+	g_i = (cmph_uint8 *) (g_is_ptr + data->k);
 	
 	for(i = 0; i < data->k; i++)
 	{
@@ -835,6 +852,7 @@ cmph_uint32 brz_packed_size(cmph_t *mphf)
 	CMPH_HASH h0_type = hash_get_type(data->h0); 
 	CMPH_HASH h1_type = hash_get_type(data->h1[0]); 
 	CMPH_HASH h2_type = hash_get_type(data->h2[0]);
+	cmph_uint32 n;
 	size = (cmph_uint32)(2*sizeof(CMPH_ALGO) + 3*sizeof(CMPH_HASH) + hash_state_packed_size(h0_type) + sizeof(cmph_uint32) + 
 			sizeof(double) + sizeof(cmph_uint8)*data->k + sizeof(cmph_uint32)*data->k);
 	// pointers to g_is
@@ -847,7 +865,7 @@ cmph_uint32 brz_packed_size(cmph_t *mphf)
 	size += hash_state_packed_size(h1_type) * data->k;
 	size += hash_state_packed_size(h2_type) * data->k;
 	
-	cmph_uint32 n = 0;
+	n = 0;
 	for(i = 0; i < data->k; i++)
 	{
    		switch(data->algo)
@@ -871,47 +889,57 @@ static cmph_uint32 brz_bmz8_search_packed(cmph_uint32 *packed_mphf, const char *
 {
 	register CMPH_HASH h0_type = *packed_mphf++;
 	register cmph_uint32 *h0_ptr = packed_mphf;
+	register cmph_uint32 k, h0, m, n, h1, h2;
+	register cmph_uint32 *offset;
+	register double c;
+	register CMPH_HASH h1_type, h2_type;
+	register cmph_uint8 * size;
+#if defined (__ia64) || defined (__x86_64__)
+	register cmph_uint64 * g_is_ptr;
+#else
+	register cmph_uint32 * g_is_ptr;
+#endif
+	register cmph_uint8 *h1_ptr, *h2_ptr, *g;
+	register cmph_uint8 mphf_bucket;
+
 	packed_mphf = (cmph_uint32 *)(((cmph_uint8 *)packed_mphf) + hash_state_packed_size(h0_type)); 
 	
-	register cmph_uint32 k = *packed_mphf++;
+	k = *packed_mphf++;
 
-	register double c = (double)(*((cmph_uint64*)packed_mphf));
+	c = (double)(*((cmph_uint64*)packed_mphf));
 	packed_mphf += 2;
 
-	register CMPH_HASH h1_type = *packed_mphf++; 
+	h1_type = *packed_mphf++;
 	
-	register CMPH_HASH h2_type = *packed_mphf++; 
+	h2_type = *packed_mphf++;
 
-	register cmph_uint8 * size = (cmph_uint8 *) packed_mphf;
+	size = (cmph_uint8 *) packed_mphf;
 	packed_mphf = (cmph_uint32 *)(size + k);  
 	
-	register cmph_uint32 * offset = packed_mphf;
+	offset = packed_mphf;
 	packed_mphf += k;
 
-	register cmph_uint32 h0;
 	
 	hash_vector_packed(h0_ptr, h0_type, key, keylen, fingerprint);
 	h0 = fingerprint[2] % k;
 	
-	register cmph_uint32 m = size[h0];
-	register cmph_uint32 n = (cmph_uint32)ceil(c * m);
+	m = size[h0];
+	n = (cmph_uint32)ceil(c * m);
 
 	#if defined (__ia64) || defined (__x86_64__)
-		register cmph_uint64 * g_is_ptr = (cmph_uint64 *)packed_mphf;
+		g_is_ptr = (cmph_uint64 *)packed_mphf;
 	#else
-		register cmph_uint32 * g_is_ptr = packed_mphf;
+		g_is_ptr = packed_mphf;
 	#endif
 	
-	register cmph_uint8 * h1_ptr = (cmph_uint8 *) g_is_ptr[h0];
+	h1_ptr = (cmph_uint8 *) g_is_ptr[h0];
 	
-	register cmph_uint8 * h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
+	h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
 
-	register cmph_uint8 * g = h2_ptr + hash_state_packed_size(h2_type);
+	g = h2_ptr + hash_state_packed_size(h2_type);
 	
-	register cmph_uint32 h1 = hash_packed(h1_ptr, h1_type, key, keylen) % n;
-	register cmph_uint32 h2 = hash_packed(h2_ptr, h2_type, key, keylen) % n;
-
-	register cmph_uint8 mphf_bucket;
+	h1 = hash_packed(h1_ptr, h1_type, key, keylen) % n;
+	h2 = hash_packed(h2_ptr, h2_type, key, keylen) % n;
 		
 	if (h1 == h2 && ++h2 >= n) h2 = 0;
 	mphf_bucket = (cmph_uint8)(g[h1] + g[h2]); 
@@ -925,49 +953,59 @@ static cmph_uint32 brz_fch_search_packed(cmph_uint32 *packed_mphf, const char *k
 	register CMPH_HASH h0_type = *packed_mphf++;
 	
 	register cmph_uint32 *h0_ptr = packed_mphf;
+	register cmph_uint32 k, h0, m, b, h1, h2;
+	register double c, p1, p2;
+	register CMPH_HASH h1_type, h2_type;
+	register cmph_uint8 *size, *h1_ptr, *h2_ptr, *g;
+	register cmph_uint32 *offset;
+#if defined (__ia64) || defined (__x86_64__)
+	register cmph_uint64 * g_is_ptr;
+#else
+	register cmph_uint32 * g_is_ptr;
+#endif
+	register cmph_uint8 mphf_bucket;
+
 	packed_mphf = (cmph_uint32 *)(((cmph_uint8 *)packed_mphf) + hash_state_packed_size(h0_type)); 
 	
-	register cmph_uint32 k = *packed_mphf++;
+	k = *packed_mphf++;
 
-	register double c = (double)(*((cmph_uint64*)packed_mphf));
+	c = (double)(*((cmph_uint64*)packed_mphf));
 	packed_mphf += 2;
 
-	register CMPH_HASH h1_type = *packed_mphf++; 
+	h1_type = *packed_mphf++;
 
-	register CMPH_HASH h2_type = *packed_mphf++; 
+	h2_type = *packed_mphf++;
 
-	register cmph_uint8 * size = (cmph_uint8 *) packed_mphf;
+	size = (cmph_uint8 *) packed_mphf;
 	packed_mphf = (cmph_uint32 *)(size + k);  
 	
-	register cmph_uint32 * offset = packed_mphf;
+	offset = packed_mphf;
 	packed_mphf += k;
 	
-	register cmph_uint32 h0;
-	
 	hash_vector_packed(h0_ptr, h0_type, key, keylen, fingerprint);
 	h0 = fingerprint[2] % k;
 	
-	register cmph_uint32 m = size[h0];
-	register cmph_uint32 b = fch_calc_b(c, m);
-	register double p1 = fch_calc_p1(m);
-	register double p2 = fch_calc_p2(b);
+	m = size[h0];
+	b = fch_calc_b(c, m);
+	p1 = fch_calc_p1(m);
+	p2 = fch_calc_p2(b);
 	
 	#if defined (__ia64) || defined (__x86_64__)
-		register cmph_uint64 * g_is_ptr = (cmph_uint64 *)packed_mphf;
+		g_is_ptr = (cmph_uint64 *)packed_mphf;
 	#else
-		register cmph_uint32 * g_is_ptr = packed_mphf;
+		g_is_ptr = packed_mphf;
 	#endif
 	
-	register cmph_uint8 * h1_ptr = (cmph_uint8 *) g_is_ptr[h0];
+	h1_ptr = (cmph_uint8 *) g_is_ptr[h0];
 	
-	register cmph_uint8 * h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
+	h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
 
-	register cmph_uint8 * g = h2_ptr + hash_state_packed_size(h2_type);
+	g = h2_ptr + hash_state_packed_size(h2_type);
 	
-	register cmph_uint32 h1 = hash_packed(h1_ptr, h1_type, key, keylen) % m;
-	register cmph_uint32 h2 = hash_packed(h2_ptr, h2_type, key, keylen) % m;
+	h1 = hash_packed(h1_ptr, h1_type, key, keylen) % m;
+	h2 = hash_packed(h2_ptr, h2_type, key, keylen) % m;
 
-	register cmph_uint8 mphf_bucket = 0;
+	mphf_bucket = 0;
 	h1 = mixh10h11h12(b, p1, p2, h1);
 	mphf_bucket = (cmph_uint8)((h2 + g[h1]) % m);
 	return (mphf_bucket + offset[h0]);
diff --git a/girepository/cmph/chd.c b/girepository/cmph/chd.c
index 71579ee3..46aec52d 100644
--- a/girepository/cmph/chd.c
+++ b/girepository/cmph/chd.c
@@ -190,9 +190,10 @@ void chd_load(FILE *fd, cmph_t *mphf)
 	DEBUGP("Loading Compressed rank structure, which has %u bytes\n", chd->packed_cr_size);
 	chd->packed_cr = (cmph_uint8 *) calloc((size_t)chd->packed_cr_size, (size_t)1);
 	nbytes = fread(chd->packed_cr, chd->packed_cr_size, (size_t)1, fd);
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
         }
+
 }
 
 int chd_dump(cmph_t *mphf, FILE *fd)
@@ -207,13 +208,14 @@ int chd_dump(cmph_t *mphf, FILE *fd)
 	nbytes = fwrite(&data->packed_chd_phf_size, sizeof(cmph_uint32), (size_t)1, fd);
 	nbytes = fwrite(data->packed_chd_phf, data->packed_chd_phf_size, (size_t)1, fd);
 
-	DEBUGP("Dumping compressed rank structure with %u bytes to disk\n", buflen);
+	DEBUGP("Dumping compressed rank structure with %u bytes to disk\n", data->packed_cr_size);
 	nbytes = fwrite(&data->packed_cr_size, sizeof(cmph_uint32), (size_t)1, fd);
 	nbytes = fwrite(data->packed_cr, data->packed_cr_size, (size_t)1, fd);
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
+
 	return 1;
 }
 
diff --git a/girepository/cmph/chd_ph.c b/girepository/cmph/chd_ph.c
index 6cd9437a..8356bded 100644
--- a/girepository/cmph/chd_ph.c
+++ b/girepository/cmph/chd_ph.c
@@ -193,8 +193,9 @@ void chd_ph_config_set_hashfuncs(cmph_config_t *mph, CMPH_HASH *hashfuncs)
 
 void chd_ph_config_set_b(cmph_config_t *mph, cmph_uint32 keys_per_bucket)
 {
+	chd_ph_config_data_t *chd_ph;
 	assert(mph);
-	chd_ph_config_data_t *chd_ph = (chd_ph_config_data_t *)mph->data;
+	chd_ph = (chd_ph_config_data_t *)mph->data;
 	if(keys_per_bucket < 1 || keys_per_bucket >= 15)
 	{
 	    keys_per_bucket = 4;
@@ -205,8 +206,9 @@ void chd_ph_config_set_b(cmph_config_t *mph, cmph_uint32 keys_per_bucket)
 
 void chd_ph_config_set_keys_per_bin(cmph_config_t *mph, cmph_uint32 keys_per_bin)
 {
+	chd_ph_config_data_t *chd_ph;
 	assert(mph);
-	chd_ph_config_data_t *chd_ph = (chd_ph_config_data_t *)mph->data;
+	chd_ph = (chd_ph_config_data_t *)mph->data;
 	if(keys_per_bin <= 1 || keys_per_bin >= 128)
 	{
 	    keys_per_bin = 1;
@@ -860,9 +862,10 @@ void chd_ph_load(FILE *fd, cmph_t *mphf)
 	DEBUGP("Reading n and nbuckets\n");
 	nbytes = fread(&(chd_ph->n), sizeof(cmph_uint32), (size_t)1, fd);	
 	nbytes = fread(&(chd_ph->nbuckets), sizeof(cmph_uint32), (size_t)1, fd);	
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
         }
+
 }
 
 int chd_ph_dump(cmph_t *mphf, FILE *fd)
@@ -889,7 +892,7 @@ int chd_ph_dump(cmph_t *mphf, FILE *fd)
 	// dumping n and nbuckets
 	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
 	nbytes = fwrite(&(data->nbuckets), sizeof(cmph_uint32), (size_t)1, fd);
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
diff --git a/girepository/cmph/chm.c b/girepository/cmph/chm.c
index 3af8c806..36a07a0d 100644
--- a/girepository/cmph/chm.c
+++ b/girepository/cmph/chm.c
@@ -226,7 +226,7 @@ int chm_dump(cmph_t *mphf, FILE *fd)
 	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
 	
 	nbytes = fwrite(data->g, sizeof(cmph_uint32)*data->n, (size_t)1, fd);
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
@@ -270,7 +270,7 @@ void chm_load(FILE *f, cmph_t *mphf)
 
 	chm->g = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*chm->n);
 	nbytes = fread(chm->g, chm->n*sizeof(cmph_uint32), (size_t)1, f);
-        if (nbytes == 0 && ferror(f)) {
+	if (nbytes == 0 && ferror(f)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return;
         }
@@ -313,6 +313,7 @@ void chm_pack(cmph_t *mphf, void *packed_mphf)
 {
 	chm_data_t *data = (chm_data_t *)mphf->data;
 	cmph_uint8 * ptr = packed_mphf;
+	CMPH_HASH h2_type;
 
 	// packing h1 type
 	CMPH_HASH h1_type = hash_get_type(data->hashes[0]);
@@ -324,7 +325,7 @@ void chm_pack(cmph_t *mphf, void *packed_mphf)
 	ptr += hash_state_packed_size(h1_type);
 
 	// packing h2 type
-	CMPH_HASH h2_type = hash_get_type(data->hashes[1]);
+	h2_type = hash_get_type(data->hashes[1]);
 	*((cmph_uint32 *) ptr) = h2_type;
 	ptr += sizeof(cmph_uint32);
 
@@ -370,19 +371,24 @@ cmph_uint32 chm_search_packed(void *packed_mphf, const char *key, cmph_uint32 ke
 {
 	register cmph_uint8 *h1_ptr = packed_mphf;
 	register CMPH_HASH h1_type  = *((cmph_uint32 *)h1_ptr);
+	register cmph_uint8 *h2_ptr;
+	register CMPH_HASH h2_type;
+	register cmph_uint32 *g_ptr;
+	register cmph_uint32 n, m, h1, h2;
+
 	h1_ptr += 4;
 
-	register cmph_uint8 *h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
-	register CMPH_HASH h2_type  = *((cmph_uint32 *)h2_ptr);
+	h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
+	h2_type  = *((cmph_uint32 *)h2_ptr);
 	h2_ptr += 4;
 	
-	register cmph_uint32 *g_ptr = (cmph_uint32 *)(h2_ptr + hash_state_packed_size(h2_type));
+	g_ptr = (cmph_uint32 *)(h2_ptr + hash_state_packed_size(h2_type));
 	
-	register cmph_uint32 n = *g_ptr++;  
-	register cmph_uint32 m = *g_ptr++;  
+	n = *g_ptr++;
+	m = *g_ptr++;
 	
-	register cmph_uint32 h1 = hash_packed(h1_ptr, h1_type, key, keylen) % n; 
-	register cmph_uint32 h2 = hash_packed(h2_ptr, h2_type, key, keylen) % n; 
+	h1 = hash_packed(h1_ptr, h1_type, key, keylen) % n;
+	h2 = hash_packed(h2_ptr, h2_type, key, keylen) % n;
 	DEBUGP("key: %s h1: %u h2: %u\n", key, h1, h2);
 	if (h1 == h2 && ++h2 >= n) h2 = 0;
 	DEBUGP("key: %s g[h1]: %u g[h2]: %u edges: %u\n", key, g_ptr[h1], g_ptr[h2], m);
diff --git a/girepository/cmph/compressed_rank.c b/girepository/cmph/compressed_rank.c
index 822b2e15..8019dbe5 100644
--- a/girepository/cmph/compressed_rank.c
+++ b/girepository/cmph/compressed_rank.c
@@ -83,9 +83,9 @@ cmph_uint32 compressed_rank_query(compressed_rank_t * cr, cmph_uint32 idx)
 		return cr->n;
 	}
 	
-	val_quot = idx >> cr->rem_r; 	
-	rems_mask = (1U << cr->rem_r) - 1U; 
-	val_rem = idx & rems_mask; 
+	val_quot = idx >> cr->rem_r;
+	rems_mask = (1U << cr->rem_r) - 1U;
+	val_rem = idx & rems_mask;
 	if(val_quot == 0)
 	{
 		rank = sel_res = 0;
@@ -128,6 +128,9 @@ void compressed_rank_dump(compressed_rank_t * cr, char **buf, cmph_uint32 *bufle
 	register cmph_uint32 pos = 0;
 	char * buf_sel = 0;
 	cmph_uint32 buflen_sel = 0;
+#ifdef DEBUG
+	cmph_uint32 i;
+#endif
 	
 	*buflen = 4*(cmph_uint32)sizeof(cmph_uint32) + sel_size +  vals_rems_size;
 	
@@ -164,7 +167,7 @@ void compressed_rank_dump(compressed_rank_t * cr, char **buf, cmph_uint32 *bufle
 	memcpy(*buf + pos, buf_sel, buflen_sel);
 	
 	#ifdef DEBUG	
-	cmph_uint32 i = 0; 
+	i = 0;
 	for(i = 0; i < buflen_sel; i++)
 	{
 	    DEBUGP("pos = %u  -- buf_sel[%u] = %u\n", pos, i, *(*buf + pos + i));
@@ -192,6 +195,9 @@ void compressed_rank_load(compressed_rank_t * cr, const char *buf, cmph_uint32 b
 	register cmph_uint32 pos = 0;
 	cmph_uint32 buflen_sel = 0;
 	register cmph_uint32 vals_rems_size = 0;
+#ifdef DEBUG
+	cmph_uint32 i;
+#endif
 	
 	// loading max_val, n, and rem_r
 	memcpy(&(cr->max_val), buf, sizeof(cmph_uint32));
@@ -213,7 +219,7 @@ void compressed_rank_load(compressed_rank_t * cr, const char *buf, cmph_uint32 b
 
 	select_load(&cr->sel, buf + pos, buflen_sel);
 	#ifdef DEBUG	
-	cmph_uint32 i = 0;  
+	i = 0;
 	for(i = 0; i < buflen_sel; i++)
 	{
 	    DEBUGP("pos = %u  -- buf_sel[%u] = %u\n", pos, i, *(buf + pos + i));
diff --git a/girepository/cmph/compressed_seq.c b/girepository/cmph/compressed_seq.c
index e558196d..e5191fd5 100644
--- a/girepository/cmph/compressed_seq.c
+++ b/girepository/cmph/compressed_seq.c
@@ -167,6 +167,9 @@ void compressed_seq_dump(compressed_seq_t * cs, char ** buf, cmph_uint32 * bufle
 	register cmph_uint32 pos = 0;
 	char * buf_sel = 0;
 	cmph_uint32 buflen_sel = 0;
+#ifdef DEBUG
+	cmph_uint32 i;
+#endif
 	
 	*buflen = 4*(cmph_uint32)sizeof(cmph_uint32) + sel_size +  length_rems_size + store_table_size;
 	
@@ -202,8 +205,8 @@ void compressed_seq_dump(compressed_seq_t * cs, char ** buf, cmph_uint32 * bufle
 	DEBUGP("buflen_sel = %u\n", buflen_sel);
 
 	memcpy(*buf + pos, buf_sel, buflen_sel);
-	#ifdef DEBUG	
-	cmph_uint32 i = 0; 
+	#ifdef DEBUG
+	i = 0;
 	for(i = 0; i < buflen_sel; i++)
 	{
 	    DEBUGP("pos = %u  -- buf_sel[%u] = %u\n", pos, i, *(*buf + pos + i));
@@ -215,7 +218,7 @@ void compressed_seq_dump(compressed_seq_t * cs, char ** buf, cmph_uint32 * bufle
 	
 	// dumping length_rems
 	memcpy(*buf + pos, cs->length_rems, length_rems_size);
-	#ifdef DEBUG	
+	#ifdef DEBUG
 	for(i = 0; i < length_rems_size; i++)
 	{
 	    DEBUGP("pos = %u -- length_rems_size = %u  -- length_rems[%u] = %u\n", pos, length_rems_size, i, *(*buf + pos + i));
@@ -226,7 +229,7 @@ void compressed_seq_dump(compressed_seq_t * cs, char ** buf, cmph_uint32 * bufle
 	// dumping store_table
 	memcpy(*buf + pos, cs->store_table, store_table_size);
 
-	#ifdef DEBUG	
+	#ifdef DEBUG
 	for(i = 0; i < store_table_size; i++)
 	{
 	    DEBUGP("pos = %u -- store_table_size = %u  -- store_table[%u] = %u\n", pos, store_table_size, i, *(*buf + pos + i));
@@ -241,6 +244,9 @@ void compressed_seq_load(compressed_seq_t * cs, const char * buf, cmph_uint32 bu
 	cmph_uint32 buflen_sel = 0;
 	register cmph_uint32 length_rems_size = 0;
 	register cmph_uint32 store_table_size = 0;
+#ifdef DEBUG
+	cmph_uint32 i;
+#endif
 	
 	// loading n, rem_r and total_length
 	memcpy(&(cs->n), buf, sizeof(cmph_uint32));
@@ -261,8 +267,8 @@ void compressed_seq_load(compressed_seq_t * cs, const char * buf, cmph_uint32 bu
 	DEBUGP("buflen_sel = %u\n", buflen_sel);
 
 	select_load(&cs->sel, buf + pos, buflen_sel);
-	#ifdef DEBUG	
-	cmph_uint32 i = 0;  
+	#ifdef DEBUG
+	i = 0;
 	for(i = 0; i < buflen_sel; i++)
 	{
 	    DEBUGP("pos = %u  -- buf_sel[%u] = %u\n", pos, i, *(buf + pos + i));
@@ -280,7 +286,7 @@ void compressed_seq_load(compressed_seq_t * cs, const char * buf, cmph_uint32 bu
 	length_rems_size *= 4;
 	memcpy(cs->length_rems, buf + pos, length_rems_size);
 	
-	#ifdef DEBUG	
+	#ifdef DEBUG
 	for(i = 0; i < length_rems_size; i++)
 	{
 	    DEBUGP("pos = %u -- length_rems_size = %u  -- length_rems[%u] = %u\n", pos, length_rems_size, i, *(buf + pos + i));
@@ -298,7 +304,7 @@ void compressed_seq_load(compressed_seq_t * cs, const char * buf, cmph_uint32 bu
         store_table_size *= 4;
 	memcpy(cs->store_table, buf + pos, store_table_size);
 	
-	#ifdef DEBUG	
+	#ifdef DEBUG
 	for(i = 0; i < store_table_size; i++)
 	{
 	    DEBUGP("pos = %u -- store_table_size = %u  -- store_table[%u] = %u\n", pos, store_table_size, i, *(buf + pos + i));
@@ -336,19 +342,19 @@ cmph_uint32 compressed_seq_query_packed(void * cs_packed, cmph_uint32 idx)
 	register cmph_uint32 *ptr = (cmph_uint32 *)cs_packed;
 	register cmph_uint32 n = *ptr++;
 	register cmph_uint32 rem_r = *ptr++;
+	register cmph_uint32 buflen_sel, length_rems_size, enc_idx, enc_length;
+	// compressed sequence query computation
+	register cmph_uint32 rems_mask, stored_value, sel_res;
+	register cmph_uint32 *sel_packed, *length_rems, *store_table;
+
 	ptr++; // skipping total_length 
 // 	register cmph_uint32 total_length = *ptr++;
-	register cmph_uint32 buflen_sel = *ptr++;
-	register cmph_uint32 * sel_packed = ptr;
-	register cmph_uint32 * length_rems = (ptr += (buflen_sel >> 2)); 
-	register cmph_uint32 length_rems_size = BITS_TABLE_SIZE(n, rem_r);
-	register cmph_uint32 * store_table = (ptr += length_rems_size);
+	buflen_sel = *ptr++;
+	sel_packed = ptr;
+	length_rems = (ptr += (buflen_sel >> 2));
+	length_rems_size = BITS_TABLE_SIZE(n, rem_r);
+	store_table = (ptr += length_rems_size);
 
-	// compressed sequence query computation
-	register cmph_uint32 enc_idx, enc_length;
-	register cmph_uint32 rems_mask;
-	register cmph_uint32 stored_value;
-	register cmph_uint32 sel_res;
 
 	rems_mask = (1U << rem_r) - 1U;
 	
diff --git a/girepository/cmph/fch.c b/girepository/cmph/fch.c
index f6e16e34..33b959e2 100644
--- a/girepository/cmph/fch.c
+++ b/girepository/cmph/fch.c
@@ -10,6 +10,7 @@
 #include <assert.h>
 #include <string.h>
 #include <errno.h>
+
 #define INDEX 0 /* alignment index within a bucket */
 //#define DEBUG
 #include "debug.h"
@@ -320,6 +321,10 @@ int fch_dump(cmph_t *mphf, FILE *fd)
 	register size_t nbytes;
 	
 	fch_data_t *data = (fch_data_t *)mphf->data;
+
+#ifdef DEBUG
+	cmph_uint32 i;
+#endif
 	__cmph_dump(mphf, fd);
 
 	hash_state_dump(data->h1, &buf, &buflen);
@@ -340,12 +345,11 @@ int fch_dump(cmph_t *mphf, FILE *fd)
 	nbytes = fwrite(&(data->p1), sizeof(double), (size_t)1, fd);
 	nbytes = fwrite(&(data->p2), sizeof(double), (size_t)1, fd);
 	nbytes = fwrite(data->g, sizeof(cmph_uint32)*(data->b), (size_t)1, fd);
-        if (nbytes == 0 && ferror(fd)) {
+	if (nbytes == 0 && ferror(fd)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return 0;
         }
 	#ifdef DEBUG
-	cmph_uint32 i;
 	fprintf(stderr, "G: ");
 	for (i = 0; i < data->b; ++i) fprintf(stderr, "%u ", data->g[i]);
 	fprintf(stderr, "\n");
@@ -359,6 +363,9 @@ void fch_load(FILE *f, cmph_t *mphf)
 	cmph_uint32 buflen;
 	register size_t nbytes;
 	fch_data_t *fch = (fch_data_t *)malloc(sizeof(fch_data_t));
+#ifdef DEBUG
+	cmph_uint32 i;
+#endif
 
 	//DEBUGP("Loading fch mphf\n");
 	mphf->data = fch;
@@ -392,12 +399,12 @@ void fch_load(FILE *f, cmph_t *mphf)
 
 	fch->g = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*fch->b);
 	nbytes = fread(fch->g, fch->b*sizeof(cmph_uint32), (size_t)1, f);
-        if (nbytes == 0 && ferror(f)) {
+	if (nbytes == 0 && ferror(f)) {
           fprintf(stderr, "ERROR: %s\n", strerror(errno));
           return;
         }
+
 	#ifdef DEBUG
-	cmph_uint32 i;
 	fprintf(stderr, "G: ");
 	for (i = 0; i < fch->b; ++i) fprintf(stderr, "%u ", fch->g[i]);
 	fprintf(stderr, "\n");
@@ -436,6 +443,7 @@ void fch_pack(cmph_t *mphf, void *packed_mphf)
 
 	// packing h1 type
 	CMPH_HASH h1_type = hash_get_type(data->h1);
+	CMPH_HASH h2_type;
 	*((cmph_uint32 *) ptr) = h1_type;
 	ptr += sizeof(cmph_uint32);
 
@@ -444,7 +452,7 @@ void fch_pack(cmph_t *mphf, void *packed_mphf)
 	ptr += hash_state_packed_size(h1_type);
 
 	// packing h2 type
-	CMPH_HASH h2_type = hash_get_type(data->h2);
+	h2_type = hash_get_type(data->h2);
 	*((cmph_uint32 *) ptr) = h2_type;
 	ptr += sizeof(cmph_uint32);
 
@@ -499,27 +507,32 @@ cmph_uint32 fch_search_packed(void *packed_mphf, const char *key, cmph_uint32 ke
 {
 	register cmph_uint8 *h1_ptr = packed_mphf;
 	register CMPH_HASH h1_type  = *((cmph_uint32 *)h1_ptr);
+	register cmph_uint8 *h2_ptr;
+	register CMPH_HASH h2_type;
+	register cmph_uint32 *g_ptr;
+	register cmph_uint32 m, b, h1, h2;
+	register double p1, p2;
+
 	h1_ptr += 4;
 
-	register cmph_uint8 *h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
-	register CMPH_HASH h2_type  = *((cmph_uint32 *)h2_ptr);
+	h2_ptr = h1_ptr + hash_state_packed_size(h1_type);
+	h2_type  = *((cmph_uint32 *)h2_ptr);
 	h2_ptr += 4;
 	
-	register cmph_uint32 *g_ptr = (cmph_uint32 *)(h2_ptr + hash_state_packed_size(h2_type));
+	g_ptr = (cmph_uint32 *)(h2_ptr + hash_state_packed_size(h2_type));
 	
-	register cmph_uint32 m = *g_ptr++;  
+	m = *g_ptr++;
 
-	register cmph_uint32 b = *g_ptr++;  
+	b = *g_ptr++;
 
-	register double p1 = (double)(*((cmph_uint64 *)g_ptr));
+	p1 = (double)(*((cmph_uint64 *)g_ptr));
 	g_ptr += 2;
 
-	register double p2 = (double)(*((cmph_uint64 *)g_ptr));
+	p2 = (double)(*((cmph_uint64 *)g_ptr));
 	g_ptr += 2;
 
-	register cmph_uint32 h1 = hash_packed(h1_ptr, h1_type, key, keylen) % m; 
-	register cmph_uint32 h2 = hash_packed(h2_ptr, h2_type, key, keylen) % m;
-
+	h1 = hash_packed(h1_ptr, h1_type, key, keylen) % m;
+	h2 = hash_packed(h2_ptr, h2_type, key, keylen) % m;
 	h1 = mixh10h11h12 (b, p1, p2, h1);
 	return (h2 + g_ptr[h1]) % m;
 }