/* Multiply a matrix by itself over GF(2). Both mat and square must have 32
rows. */
static inline void gf2_matrix_square(uint32_t *square, uint32_t *mat) {
- for (unsigned n = 0; n < 32; n++)
+ unsigned n;
+ for (n = 0; n < 32; n++)
square[n] = gf2_matrix_times(mat, mat[n]);
}
/* put operator for one zero bit in odd */
odd[0] = POLY; /* CRC-32C polynomial */
uint32_t row = 1;
- for (unsigned n = 1; n < 32; n++) {
+ unsigned n;
+ for (n = 1; n < 32; n++) {
odd[n] = row;
row <<= 1;
}
} while (len);
/* answer ended up in odd -- copy to even */
- for (unsigned n = 0; n < 32; n++)
+ for (n = 0; n < 32; n++)
even[n] = odd[n];
}
uint32_t op[32];
crc32c_zeros_op(op, len);
- for (unsigned n = 0; n < 256; n++) {
+ unsigned n;
+ for (n = 0; n < 256; n++) {
zeros[0][n] = gf2_matrix_times(op, n);
zeros[1][n] = gf2_matrix_times(op, n << 8);
zeros[2][n] = gf2_matrix_times(op, n << 16);
static bool crc32c_once_little;
static uint32_t crc32c_table_little[8][256];
static void crc32c_init_sw_little(void) {
- for (unsigned n = 0; n < 256; n++) {
+ unsigned n;
+ for (n = 0; n < 256; n++) {
uint32_t crc = n;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc32c_table_little[0][n] = crc;
}
- for (unsigned n = 0; n < 256; n++) {
+ for (n = 0; n < 256; n++) {
uint32_t crc = crc32c_table_little[0][n];
- for (unsigned k = 1; k < 8; k++) {
+ unsigned k;
+ for (k = 1; k < 8; k++) {
crc = crc32c_table_little[0][crc & 0xff] ^ (crc >> 8);
crc32c_table_little[k][n] = crc;
}
static uint32_t crc32c_table_big_byte[256];
static uint64_t crc32c_table_big[8][256];
static void crc32c_init_sw_big(void) {
- for (unsigned n = 0; n < 256; n++) {
+ unsigned n;
+ for (n = 0; n < 256; n++) {
uint32_t crc = n;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
crc32c_table_big_byte[n] = crc;
}
- for (unsigned n = 0; n < 256; n++) {
+ for (n = 0; n < 256; n++) {
uint32_t crc = crc32c_table_big_byte[n];
crc32c_table_big[0][n] = swap(crc);
- for (unsigned k = 1; k < 8; k++) {
+ unsigned k;
+ for (k = 1; k < 8; k++) {
crc = crc32c_table_big_byte[crc & 0xff] ^ (crc >> 8);
crc32c_table_big[k][n] = swap(crc);
}
{
const uint32_t delta=0x9E3779B9;
uint32_t v0=(v>>32), v1=v, sum=0;
+ int i;
- for (int i=0; i < NUM_DOUBLE_ROUNDS; i++) {
+ for (i=0; i < NUM_DOUBLE_ROUNDS; i++) {
v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + secret->u.u32[sum & 3]);
sum += delta;
v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + secret->u.u32[(sum>>11) & 3]);
{
const uint32_t delta=0x9E3779B9;
uint32_t v0=(e>>32), v1=e, sum=delta*NUM_DOUBLE_ROUNDS;
+ int i;
- for (int i=0; i < NUM_DOUBLE_ROUNDS; i++) {
+ for (i=0; i < NUM_DOUBLE_ROUNDS; i++) {
v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + secret->u.u32[(sum>>11) & 3]);
sum -= delta;
v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + secret->u.u32[sum & 3]);
ed_dist *delcost = malloc(ED_TMAT_SIZE(slen + 1) * sizeof(ed_dist));
ed_dist *delcostitr = delcost;
ed_dist *delcostprevitr = delcost;
+ ed_size i2, i1;
*delcostitr++ = 0;
- for (ed_size i2 = 1; i2 <= slen; ++i2) {
+ for (i2 = 1; i2 <= slen; ++i2) {
ed_dist costi2 = ED_DEL_COST(src[i2 - 1]);
- for (ed_size i1 = 0; i1 < i2; ++i1) {
+ for (i1 = 0; i1 < i2; ++i1) {
*delcostitr++ = *delcostprevitr++ + costi2;
}
*delcostitr++ = 0;
ed_dist *inscost = malloc(ED_TMAT_SIZE(tlen + 1) * sizeof(ed_dist));
ed_dist *inscostitr = inscost;
ed_dist *inscostprevitr = inscost;
+ ed_size j2, j1;
*inscostitr++ = 0;
- for (ed_size j2 = 1; j2 <= tlen; ++j2) {
+ for (j2 = 1; j2 <= tlen; ++j2) {
ed_dist costj2 = ED_INS_COST(tgt[j2 - 1]);
- for (ed_size j1 = 0; j1 < j2; ++j1) {
+ for (j1 = 0; j1 < j2; ++j1) {
*inscostitr++ = *inscostprevitr++ + costj2;
}
*inscostitr++ = 0;
#endif
/* Initialize first row with maximal cost */
- for (ed_size i = 0; i < slen + 2; ++i) {
+ ed_size i, j;
+ for (i = 0; i < slen + 2; ++i) {
dist[i] = maxdist;
}
/* Initialize row with cost to delete src[0..i-1] */
dist[-1] = maxdist;
dist[0] = 0;
- for (ed_size i = 1; i <= slen; ++i) {
+ for (i = 1; i <= slen; ++i) {
dist[i] = dist[i - 1] + ED_DEL_COST(src[i - 1]);
}
- for (ed_size j = 1; j <= tlen; ++j) {
+ for (j = 1; j <= tlen; ++j) {
/* Largest y < i such that src[y] = tgt[j] */
ed_size lastsrc = 0;
ed_dist *prevdist = dist;
* Loop invariant: lasttgt[ED_HASH_ELEM(c)] holds the largest
* x < j such that tgt[x-1] = c or 0 if no such x exists.
*/
- for (ed_size i = 1; i <= slen; ++i) {
+ ed_size i;
+ for (i = 1; i <= slen; ++i) {
ed_size i1 = lastsrc;
ed_size j1 = lasttgt[ED_HASH_ELEM(src[i - 1])];
ed_dist edit_distance_lcs(const ed_elem *src, ed_size slen,
const ed_elem *tgt, ed_size tlen)
{
+ ed_size i, j;
+
/* Optimization: Avoid malloc when row of distance matrix can fit on
* the stack.
*/
/* Initialize row with cost to delete src[0..i-1] */
dist[0] = 0;
- for (ed_size i = 1; i <= slen; ++i) {
+ for (i = 1; i <= slen; ++i) {
dist[i] = dist[i - 1] + ED_DEL_COST(src[i - 1]);
}
- for (ed_size j = 1; j <= tlen; ++j) {
+ for (j = 1; j <= tlen; ++j) {
/* Value for dist[j-1][i-1] (one row up, one col left). */
ed_dist diagdist = dist[0];
dist[0] = dist[0] + ED_INS_COST(tgt[j - 1]);
/* Loop invariant: dist[i] is the edit distance between first j
* elements of tgt and first i elements of src.
*/
- for (ed_size i = 1; i <= slen; ++i) {
+ for (i = 1; i <= slen; ++i) {
ed_dist nextdiagdist = dist[i];
if (ED_ELEM_EQUAL(src[i - 1], tgt[j - 1])) {
ed_dist edit_distance_lev(const ed_elem *src, ed_size slen,
const ed_elem *tgt, ed_size tlen)
{
+ ed_size i, j;
+
/* Optimization: Avoid malloc when row of distance matrix can fit on
* the stack.
*/
/* Initialize row with cost to delete src[0..i-1] */
dist[0] = 0;
- for (ed_size i = 1; i <= slen; ++i) {
+ for (i = 1; i <= slen; ++i) {
dist[i] = dist[i - 1] + ED_DEL_COST(src[i - 1]);
}
- for (ed_size j = 1; j <= tlen; ++j) {
+ for (j = 1; j <= tlen; ++j) {
/* Value for dist[j-1][i-1] (one row up, one col left). */
ed_dist diagdist = dist[0];
dist[0] = dist[0] + ED_INS_COST(tgt[j - 1]);
/* Loop invariant: dist[i] is the edit distance between first j
* elements of tgt and first i elements of src.
*/
- for (ed_size i = 1; i <= slen; ++i) {
+ for (i = 1; i <= slen; ++i) {
ed_dist nextdiagdist = dist[i];
if (ED_ELEM_EQUAL(src[i - 1], tgt[j - 1])) {
ed_dist edit_distance_rdl(const ed_elem *src, ed_size slen,
const ed_elem *tgt, ed_size tlen)
{
+ ed_size i, j;
+
/* Optimization: Avoid malloc when required rows of distance matrix can
* fit on the stack.
*/
/* Initialize row with cost to delete src[0..i-1] */
dist[0] = 0;
- for (ed_size i = 1; i <= slen; ++i) {
+ for (i = 1; i <= slen; ++i) {
dist[i] = dist[i - 1] + ED_DEL_COST(src[i - 1]);
}
- for (ed_size j = 1; j <= tlen; ++j) {
+ for (j = 1; j <= tlen; ++j) {
/* Value for dist[j-2][i-1] (two rows up, one col left). */
/* Note: dist[0] is not initialized when j == 1, var unused. */
ed_dist diagdist1 = prevdist[0];
/* Loop invariant: dist[i] is the edit distance between first j
* elements of tgt and first i elements of src.
*/
- for (ed_size i = 1; i <= slen; ++i) {
+ for (i = 1; i <= slen; ++i) {
ed_dist nextdiagdist = dist[i];
if (ED_ELEM_EQUAL(src[i - 1], tgt[j - 1])) {
static int find_always(const struct io_plan *plan)
{
- for (size_t i = 0; i < num_always; i++)
+ size_t i = 0;
+
+ for (i = 0; i < num_always; i++)
if (always[i] == plan)
return i;
return -1;
/* For simplicity, we do one always at a time */
static bool handle_always(void)
{
+ int i;
+
/* Backwards is simple easier to remove entries */
- for (int i = num_always - 1; i >= 0; i--) {
+ for (i = num_always - 1; i >= 0; i--) {
struct io_plan *plan = always[i];
if (num_exclusive && !*exclusive(plan))
* else that we manipulate events. */
static void exclude_pollfds(void)
{
+ size_t i;
+
if (num_exclusive == 0)
return;
- for (size_t i = 0; i < num_fds; i++) {
+ for (i = 0; i < num_fds; i++) {
struct pollfd *pfd = &pollfds[fds[i]->backend_info];
if (!fds[i]->exclusive[IO_IN])
static void restore_pollfds(void)
{
+ size_t i;
+
if (num_exclusive == 0)
return;
- for (size_t i = 0; i < num_fds; i++) {
+ for (i = 0; i < num_fds; i++) {
struct pollfd *pfd = &pollfds[fds[i]->backend_info];
if (fds[i]->listener) {
bool json_escape_needed(const char *str, size_t len)
{
- for (size_t i = 0; i < len; i++) {
+ size_t i;
+ for (i = 0; i < len; i++) {
if ((unsigned)str[i] < ' '
|| str[i] == 127
|| str[i] == '"'
goto fail;
if (childpid == 0) {
- for (int i = 0; i < num_child_close; i++)
+ int i;
+ for (i = 0; i < num_child_close; i++)
close(child_close[i]);
// Child runs command.
/* Make (fairly!) sure all other fds are closed. */
int max = sysconf(_SC_OPEN_MAX);
- for (int i = 3; i < max; i++)
+ for (i = 3; i < max; i++)
if (i != execfail[1])
close(i);
exit(127);
}
- for (int i = 0; i < num_par_close; i++)
+ int i;
+ for (i = 0; i < num_par_close; i++)
close(par_close[i]);
/* Child will close this without writing on successful exec. */
return childpid;
fail:
- for (int i = 0; i < num_par_close; i++)
+ for (i = 0; i < num_par_close; i++)
close_noerr(par_close[i]);
return -1;
}
{
uint64_t acc = 0;
size_t num_pad = 0;
- for (int i = 0; i < 8; i++) {
+ int i;
+ for (i = 0; i < 8; i++) {
const char *p;
acc <<= 5;