[devel] [PATCH 1/8] set.c, set.h: get rid of C++-style comments
Kirill A. Shutsemov
kirill на shutemov.name
Вт Ноя 16 15:56:35 UTC 2010
From: Kirill A. Shutemov <kirill на shutemov.name>
Signed-off-by: Kirill A. Shutemov <kirill на shutemov.name>
---
lib/set.c | 164 ++++++++++++++++++++++++++++++++-----------------------------
lib/set.h | 12 +++--
2 files changed, 93 insertions(+), 83 deletions(-)
diff --git a/lib/set.c b/lib/set.c
index a45e02b..e80ce61 100644
--- a/lib/set.c
+++ b/lib/set.c
@@ -28,16 +28,18 @@
* how multiple escapes can be effectively avoided.
*/
-// Estimate base62 buffer size required to encode a given number of bits.
+/* Estimate base62 buffer size required to encode a given number of bits. */
static inline
int encode_base62_size(int bitc)
{
- // Four bits can make a character; the remaining bits can make
- // a character, too. And the string should be null-terminated.
+ /*
+ * Four bits can make a character; the remaining bits can make
+ * a character, too. And the string should be null-terminated.
+ */
return (bitc >> 2) + 2;
}
-// Main base62 encoding routine: pack bitv into base62 string.
+/* Main base62 encoding routine: pack bitv into base62 string. */
static
int encode_base62(int bitc, const char *bitv, char *base62)
{
@@ -52,32 +54,32 @@ int encode_base62(int bitc, const char *bitv, char *base62)
else if (c < 62)
*base62++ = c - 36 + 'A';
}
- int bits2 = 0; // number of high bits set
- int bits6 = 0; // number of regular bits set
- int num6b = 0; // pending 6-bit number
+ int bits2 = 0; /* number of high bits set */
+ int bits6 = 0; /* number of regular bits set */
+ int num6b = 0; /* pending 6-bit number */
while (bitc-- > 0) {
assert(bits6 + bits2 < 6);
num6b |= (*bitv++ << bits6++);
if (bits6 + bits2 == 6) {
switch (num6b) {
case 61:
- // escape
+ /* escape */
put_digit(61);
- // extra "00...." high bits (in the next character)
+ /* extra "00...." high bits (in the next character) */
bits2 = 2;
bits6 = 0;
num6b = 0;
break;
case 62:
put_digit(61);
- // extra "01...." hight bits
+ /* extra "01...." hight bits */
bits2 = 2;
bits6 = 0;
num6b = 16;
break;
case 63:
put_digit(61);
- // extra "10...." hight bits
+ /* extra "10...." hight bits */
bits2 = 2;
bits6 = 0;
num6b = 32;
@@ -100,16 +102,16 @@ int encode_base62(int bitc, const char *bitv, char *base62)
return base62 - base62_start;
}
-// Estimate how many bits will result from decoding a base62 string.
+/* Estimate how many bits will result from decoding a base62 string. */
static inline
int decode_base62_size(const char *base62)
{
int len = strlen(base62);
- // Each character will fill at most 6 bits.
+ /* Each character will fill at most 6 bits. */
return (len << 2) + (len << 1);
}
-// Main base62 decoding routine: unpack base62 string into bitv.
+/* Main base62 decoding routine: unpack base62 string into bitv. */
static
int decode_base62(const char *base62, char *bitv)
{
@@ -183,30 +185,30 @@ void test_base62()
1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1,
0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0,
0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
- // trigger some 'Z'
+ /* trigger some 'Z' */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
};
const int rnd_bitc = sizeof rnd_bitv;
- // encode
+ /* encode */
char base62[encode_base62_size(rnd_bitc)];
int len = encode_base62(rnd_bitc, rnd_bitv, base62);
assert(len > 0);
assert(len == (int)strlen(base62));
fprintf(stderr, "len=%d base62=%s\n", len, base62);
- // The length cannot be shorter than 6 bits per symbol.
+ /* The length cannot be shorter than 6 bits per symbol. */
assert(len >= rnd_bitc / 6);
- // Neither too long: each second character must fill at least 4 bits.
+ /* Neither too long: each second character must fill at least 4 bits. */
assert(len <= rnd_bitc / 2 / 4 + rnd_bitc / 2 / 6 + 1);
- // decode
+ /* decode */
char bitv[decode_base62_size(base62)];
int bitc = decode_base62(base62, bitv);
fprintf(stderr, "rnd_bitc=%d bitc=%d\n", rnd_bitc, bitc);
assert(bitc >= rnd_bitc);
- // Decoded bits must match.
+ /* Decoded bits must match. */
int i;
for (i = 0; i < rnd_bitc; i++)
assert(rnd_bitv[i] == bitv[i]);
- // The remaining bits must be zero bits.
+ /* The remaining bits must be zero bits. */
for (i = rnd_bitc; i < bitc; i++)
assert(bitv[i] == 0);
fprintf(stderr, "%s: base62 test OK\n", __FILE__);
@@ -233,7 +235,7 @@ void test_base62()
* http://algo2.iti.uni-karlsruhe.de/singler/publications/cacheefficientbloomfilters-wea2007.pdf
*/
-// Calculate Mshift paramter for encoding.
+/* Calculate Mshift paramter for encoding. */
static
int encode_golomb_Mshift(int c, int bpp)
{
@@ -244,10 +246,12 @@ int encode_golomb_Mshift(int c, int bpp)
m++;
return m;
}
- // XXX Slightly better Mshift estimations are probably possible.
- // Recheck "Compression and coding algorithms" by Moffat & Turpin.
+ /*
+ * XXX Slightly better Mshift estimations are probably possible.
+ * Recheck "Compression and coding algorithms" by Moffat & Turpin.
+ */
int Mshift = bpp - log2i(c) - 1;
- // Adjust out-of-range values.
+ /* Adjust out-of-range values. */
if (Mshift < 7)
Mshift = 7;
if (Mshift > 31)
@@ -256,16 +260,18 @@ int encode_golomb_Mshift(int c, int bpp)
return Mshift;
}
-// Estimate how many bits can be filled up.
+/* Estimate how many bits can be filled up. */
static inline
int encode_golomb_size(int c, int Mshift)
{
- // XXX No precise estimation. However, we do not expect unary-encoded bits
- // to take more than binary-encoded Mshift bits.
+ /*
+ * XXX No precise estimation. However, we do not expect unary-encoded bits
+ * to take more than binary-encoded Mshift bits.
+ */
return (Mshift << 1) * c + 16;
}
-// Main golomb encoding routine: package integers into bits.
+/* Main golomb encoding routine: package integers into bits. */
static
int encode_golomb(int c, const unsigned *v, int Mshift, char *bitv)
{
@@ -275,12 +281,12 @@ int encode_golomb(int c, const unsigned *v, int Mshift, char *bitv)
c--;
unsigned v0 = *v++;
int i;
- // first part: variable-length sequence
+ /* first part: variable-length sequence */
unsigned q = v0 >> Mshift;
for (i = 0; i < (int)q; i++)
*bitv++ = 0;
*bitv++ = 1;
- // second part: lower Mshift bits
+ /* second part: lower Mshift bits */
unsigned r = v0 & mask;
for (i = 0; i < Mshift; i++)
*bitv++ = (r >> i) & 1;
@@ -288,23 +294,25 @@ int encode_golomb(int c, const unsigned *v, int Mshift, char *bitv)
return bitv - bitv_start;
}
-// Estimate how many values will emerge.
+/* Estimate how many values will emerge. */
static inline
int decode_golomb_size(int bitc, int Mshift)
{
- // Each (Mshift + 1) bits can make a value.
- // The remaining bits cannot make a value, though.
+ /*
+ * Each (Mshift + 1) bits can make a value.
+ * The remaining bits cannot make a value, though.
+ */
return bitc / (Mshift + 1);
}
-// Main golomb decoding routine: unpackage bits into values.
+/* Main golomb decoding routine: unpackage bits into values. */
static
int decode_golomb(int bitc, const char *bitv, int Mshift, unsigned *v)
{
unsigned *v_start = v;
- // next value
+ /* next value */
while (bitc > 0) {
- // first part
+ /* first part */
unsigned q = 0;
char bit = 0;
while (bitc > 0) {
@@ -315,13 +323,13 @@ int decode_golomb(int bitc, const char *bitv, int Mshift, unsigned *v)
else
break;
}
- // trailing zero bits in the input are okay
+ /* trailing zero bits in the input are okay */
if (bitc == 0 && bit == 0)
break;
- // otherwise, incomplete value is not okay
+ /* otherwise, incomplete value is not okay */
if (bitc < Mshift)
return -1;
- // second part
+ /* second part */
unsigned r = 0;
int i;
for (i = 0; i < Mshift; i++) {
@@ -329,7 +337,7 @@ int decode_golomb(int bitc, const char *bitv, int Mshift, unsigned *v)
if (*bitv++)
r |= (1 << i);
}
- // the value
+ /* the value */
*v++ = (q << Mshift) | r;
}
return v - v_start;
@@ -339,9 +347,9 @@ int decode_golomb(int bitc, const char *bitv, int Mshift, unsigned *v)
void test_golomb()
{
const unsigned rnd_v[] = {
- // do re mi fa sol la si
+ /* do re mi fa sol la si */
1, 2, 3, 4, 5, 6, 7,
- // koshka sela na taksi
+ /* koshka sela na taksi */
7, 6, 5, 4, 3, 2, 1,
};
const int rnd_c = sizeof rnd_v / sizeof *rnd_v;
@@ -350,7 +358,7 @@ void test_golomb()
fprintf(stderr, "rnd_c=%d bpp=%d Mshift=%d\n", rnd_c, bpp, Mshift);
assert(Mshift > 0);
assert(Mshift < bpp);
- // encode
+ /* encode */
int alloc_bitc = encode_golomb_size(rnd_c, Mshift);
assert(alloc_bitc > rnd_c);
char bitv[alloc_bitc];
@@ -358,19 +366,19 @@ void test_golomb()
fprintf(stderr, "alloc_bitc=%d bitc=%d\n", alloc_bitc, bitc);
assert(bitc > rnd_c);
assert(bitc <= alloc_bitc);
- // decode
+ /* decode */
int alloc_c = decode_golomb_size(bitc, Mshift);
assert(alloc_c >= rnd_c);
unsigned v[alloc_c];
int c = decode_golomb(bitc, bitv, Mshift, v);
fprintf(stderr, "rnd_c=%d alloc_c=%d c=%d\n", rnd_c, alloc_c, c);
assert(alloc_c >= c);
- // Decoded values must match.
+ /* Decoded values must match. */
assert(rnd_c == c);
int i;
for (i = 0; i < c; i++)
assert(rnd_v[i] == v[i]);
- // At the end of the day, did it save your money?
+ /* At the end of the day, did it save your money? */
int golomb_bpp = bitc / c;
fprintf(stderr, "bpp=%d golomb_bpp=%d\n", bpp, golomb_bpp);
assert(golomb_bpp < bpp);
@@ -506,35 +514,35 @@ int encode_set_size(int c, int bpp)
{
int Mshift = encode_golomb_Mshift(c, bpp);
int bitc = encode_golomb_size(c, Mshift);
- // two leading characters are special
+ /* two leading characters are special */
return 2 + encode_base62_size(bitc);
}
static
int encode_set(int c, unsigned *v, int bpp, char *base62)
{
- // XXX v is non-const due to encode_delta
+ /* XXX v is non-const due to encode_delta */
int Mshift = encode_golomb_Mshift(c, bpp);
int bitc = encode_golomb_size(c, Mshift);
char bitv[bitc];
- // bpp
+ /* bpp */
if (bpp < 10 || bpp > 32)
return -1;
*base62++ = bpp - 7 + 'a';
- // golomb parameter
+ /* golomb parameter */
if (Mshift < 7 || Mshift > 31)
return -2;
*base62++ = Mshift - 7 + 'a';
- // delta
+ /* delta */
encode_delta(c, v);
- // golomb
+ /* golomb */
bitc = encode_golomb(c, v, Mshift, bitv);
#ifdef SELF_TEST
decode_delta(c, v);
#endif
if (bitc < 0)
return -3;
- // base62
+ /* base62 */
int len = encode_base62(bitc, bitv, base62);
if (len < 0)
return -4;
@@ -544,17 +552,17 @@ int encode_set(int c, unsigned *v, int bpp, char *base62)
static
int decode_set_init(const char *str, int *pbpp, int *pMshift)
{
- // 7..32 values encoded with 'a'..'z'
+ /* 7..32 values encoded with 'a'..'z' */
int bpp = *str++ + 7 - 'a';
if (bpp < 10 || bpp > 32)
return -1;
- // golomb parameter
+ /* golomb parameter */
int Mshift = *str++ + 7 - 'a';
if (Mshift < 7 || Mshift > 31)
return -2;
if (Mshift >= bpp)
return -3;
- // no empty sets for now
+ /* no empty sets for now */
if (*str == '\0')
return -4;
*pbpp = bpp;
@@ -574,16 +582,16 @@ static
int decode_set(const char *str, int Mshift, unsigned *v)
{
str += 2;
- // base62
+ /* base62 */
char bitv[decode_base62_size(str)];
int bitc = decode_base62(str, bitv);
if (bitc < 0)
return -1;
- // golomb
+ /* golomb */
int c = decode_golomb(bitc, bitv, Mshift, v);
if (c < 0)
return -2;
- // delta
+ /* delta */
decode_delta(c, v);
return c;
}
@@ -608,13 +616,13 @@ void test_set()
0xb584, 0xb89f, 0xbb40, 0xf39e,
};
int rnd_c = sizeof rnd_v / sizeof *rnd_v;
- // encode
+ /* encode */
int bpp = 16;
char base62[encode_set_size(rnd_c, bpp)];
int len = encode_set(rnd_c, rnd_v, bpp, base62);
assert(len > 0);
fprintf(stderr, "len=%d set=%s\n", len, base62);
- // decode
+ /* decode */
int Mshift = bpp;
int rc = decode_set_init(base62, &bpp, &Mshift);
assert(rc == 0);
@@ -624,7 +632,7 @@ void test_set()
assert(c >= rnd_c);
unsigned v[c];
c = decode_set(base62, Mshift, v);
- // Decoded values must match.
+ /* Decoded values must match. */
assert(c == rnd_c);
int i;
for (i = 0; i < c; i++)
@@ -639,31 +647,31 @@ void test_set()
#include "set.h"
-// main API routine
+/* main API routine */
int rpmsetcmp(const char *str1, const char *str2)
{
if (strncmp(str1, "set:", 4) == 0)
str1 += 4;
if (strncmp(str2, "set:", 4) == 0)
str2 += 4;
- // initialize decoding
+ /* initialize decoding */
int bpp1, Mshift1;
int bpp2, Mshift2;
if (decode_set_init(str1, &bpp1, &Mshift1) < 0)
return -3;
if (decode_set_init(str2, &bpp2, &Mshift2) < 0)
return -4;
- // make room for hash values
+ /* make room for hash values */
unsigned v1[decode_set_size(str1, Mshift1)];
unsigned v2[decode_set_size(str2, Mshift2)];
- // decode hash values
+ /* decode hash values */
int c1 = decode_set(str1, Mshift1, v1);
if (c1 < 0)
return -3;
int c2 = decode_set(str2, Mshift2, v2);
if (c2 < 0)
return -4;
- // adjust for comparison
+ /* adjust for comparison */
if (bpp1 > bpp2) {
bpp1 = bpp2;
c1 = downsample_set(c1, v1, bpp1);
@@ -672,7 +680,7 @@ int rpmsetcmp(const char *str1, const char *str2)
bpp2 = bpp1;
c2 = downsample_set(c2, v2, bpp2);
}
- // compare
+ /* compare */
int ge = 1;
int le = 1;
int i1 = 0, i2 = 0;
@@ -689,7 +697,7 @@ int rpmsetcmp(const char *str1, const char *str2)
i1++;
i2++;
}
- // return
+ /* return */
if (i1 < c1)
le = 0;
if (i2 < c2)
@@ -710,7 +718,7 @@ int rpmsetcmp(const char *str1, const char *str2)
#include "system.h"
#include "rpmlib.h"
-// Internally, "struct set" is just a bag of strings and their hash values.
+/* Internally, "struct set" is just a bag of strings and their hash values. */
struct set {
int c;
struct sv {
@@ -748,7 +756,7 @@ struct set *set_free(struct set *set)
return NULL;
}
-// This routine does the whole job.
+/* This routine does the whole job. */
const char *set_fini(struct set *set, int bpp)
{
if (set->c < 1)
@@ -758,7 +766,7 @@ const char *set_fini(struct set *set, int bpp)
if (bpp > 32)
return NULL;
unsigned mask = (bpp < 32) ? (1u << bpp) - 1 : ~0u;
- // Jenkins' one-at-a-time hash
+ /* Jenkins' one-at-a-time hash */
inline
unsigned int hash(const char *str)
{
@@ -774,11 +782,11 @@ const char *set_fini(struct set *set, int bpp)
hash += (hash << 15);
return hash;
}
- // hash sv strings
+ /* hash sv strings */
int i;
for (i = 0; i < set->c; i++)
set->sv[i].v = hash(set->sv[i].s) & mask;
- // sort by hash value
+ /* sort by hash value */
int cmp(const void *arg1, const void *arg2)
{
struct sv *sv1 = (struct sv *) arg1;
@@ -790,7 +798,7 @@ const char *set_fini(struct set *set, int bpp)
return 0;
}
qsort(set->sv, set->c, sizeof *set->sv, cmp);
- // warn on hash collisions
+ /* warn on hash collisions */
for (i = 0; i < set->c - 1; i++) {
if (set->sv[i].v != set->sv[i+1].v)
continue;
@@ -799,7 +807,7 @@ const char *set_fini(struct set *set, int bpp)
fprintf(stderr, "warning: hash collision: %s %s\n",
set->sv[i].s, set->sv[i+1].s);
}
- // encode
+ /* encode */
unsigned v[set->c];
for (i = 0; i < set->c; i++)
v[i] = set->sv[i].v;
@@ -871,4 +879,4 @@ int main()
return 0;
}
#endif
-// ex: set ts=8 sts=4 sw=4 noet:
+/* ex: set ts=8 sts=4 sw=4 noet: */
diff --git a/lib/set.h b/lib/set.h
index 49b8ea6..6f32e88 100644
--- a/lib/set.h
+++ b/lib/set.h
@@ -1,7 +1,9 @@
#ifndef SET_H
#define SET_H
-/* Compare two set-versions.
+/*
+ * Compare two set-versions.
+ *
* Return value:
* 1: set1 > set2
* 0: set1 == set2
@@ -16,16 +18,16 @@ int rpmsetcmp(const char *set1, const char *set2);
* API for creating set versions.
*/
-// initialize new set
+/* initialize new set */
struct set *set_new(void);
-// add new symbol to set
+/* add new symbol to set */
void set_add(struct set *set, const char *sym);
-// make set-version
+/* make set-version */
const char *set_fini(struct set *set, int bpp);
-// free set
+/* free set */
struct set *set_free(struct set *set);
#endif
--
1.7.3.2
Подробная информация о списке рассылки Devel