mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-29 02:05:57 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove compiler warnings regarding signed/unsigned compare in mroonga

Browse source
This commit is contained in:
Monty 2020-08-22 02:12:07 +03:00 • committed by Sergei Golubchik
parent e42130e9cd
commit 163be5fd8c
20 changed files with 165 additions and 151 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
storage/mroonga/vendor/groonga/include/groonga/groonga.h vendored
View file

@ -1540,7 +1540,7 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
} while (0)
#define GRN_BULK_POP(obj, value, type, default) do {\
if (GRN_BULK_VSIZE(obj) >= sizeof(type)) {\
if ((size_t) GRN_BULK_VSIZE(obj) >= sizeof(type)) { \
GRN_BULK_INCR_LEN((obj), -(sizeof(type)));\
value = *(type *)(GRN_BULK_CURR(obj));\
} else {\

20
storage/mroonga/vendor/groonga/lib/expr.c vendored
View file

@ -529,7 +529,7 @@ typedef struct {
static grn_expr_dfi *
grn_expr_dfi_pop(grn_expr *expr)
{
if (GRN_BULK_VSIZE(&expr->dfi) >= sizeof(grn_expr_dfi)) {
if ((size_t) GRN_BULK_VSIZE(&expr->dfi) >= sizeof(grn_expr_dfi)) {
grn_expr_dfi *dfi;
GRN_BULK_INCR_LEN(&expr->dfi, -((ssize_t)(sizeof(grn_expr_dfi))));
dfi = (grn_expr_dfi *)GRN_BULK_CURR(&expr->dfi);
@ -1459,7 +1459,7 @@ grn_proc_call(grn_ctx *ctx, grn_obj *proc, int nargs, grn_obj *caller)
grn_proc_ctx pctx;
grn_obj *obj = NULL, **args;
grn_proc *p = (grn_proc *)proc;
if (nargs > ctx->impl->stack_curr) { return GRN_INVALID_ARGUMENT; }
if ((uint32_t) nargs > ctx->impl->stack_curr) { return GRN_INVALID_ARGUMENT; }
GRN_API_ENTER;
if (grn_obj_is_selector_only_proc(ctx, proc)) {
char name[GRN_TABLE_MAX_KEY_SIZE];
@ -3841,7 +3841,7 @@ grn_expr_get_value(grn_ctx *ctx, grn_obj *expr, int offset)
grn_obj *res = NULL;
grn_expr *e = (grn_expr *)expr;
GRN_API_ENTER;
if (0 <= offset && offset < e->values_size) {
if (0 <= offset && (uint) offset < e->values_size) {
res = &e->values[offset];
}
GRN_API_RETURN(res);
@ -5386,7 +5386,7 @@ grn_scan_info_build_simple_and_operations(grn_ctx *ctx,
int i;
int nth_sis;
for (i = 0, nth_sis = 0; i < e->codes_curr; i += 3, nth_sis++) {
for (i = 0, nth_sis = 0; (uint) i < e->codes_curr; i += 3, nth_sis++) {
grn_expr_code *target = e->codes + i;
grn_expr_code *constant = e->codes + i + 1;
grn_expr_code *operator = e->codes + i + 2;
@ -5454,7 +5454,7 @@ grn_scan_info_build_simple_and_operations(grn_ctx *ctx,
return NULL;
}
for (i = 0, nth_sis = 0; i < e->codes_curr; i += 3, nth_sis++) {
for (i = 0, nth_sis = 0; (uint) i < e->codes_curr; i += 3, nth_sis++) {
grn_expr_code *target = e->codes + i;
grn_expr_code *constant = e->codes + i + 1;
grn_expr_code *operator = e->codes + i + 2;
@ -5920,7 +5920,7 @@ grn_table_select_index_equal(grn_ctx *ctx,
if (si->position.specified) {
while ((posting = grn_ii_cursor_next_pos(ctx, ii_cursor))) {
if (posting->pos == si->position.start) {
if ((int) posting->pos == si->position.start) {
break;
}
}
@ -6037,7 +6037,7 @@ grn_table_select_index_not_equal(grn_ctx *ctx,
if (si->position.specified) {
while ((posting = grn_ii_cursor_next_pos(ctx, ii_cursor))) {
if (posting->pos == si->position.start) {
if ((int) posting->pos == si->position.start) {
break;
}
}
@ -6561,7 +6561,7 @@ grn_table_select_index_range_column(grn_ctx *ctx, grn_obj *table,
if (si->position.specified) {
while ((posting = grn_ii_cursor_next_pos(ctx, ii_cursor))) {
if (posting->pos == si->position.start) {
if ((int) posting->pos == si->position.start) {
break;
}
}
@ -6849,7 +6849,7 @@ grn_table_select(grn_ctx *ctx, grn_obj *table, grn_obj *expr,
grn_id min_id = GRN_ID_NIL;
v = grn_expr_get_var_by_offset(ctx, (grn_obj *)e, 0);
GRN_PTR_INIT(&res_stack, GRN_OBJ_VECTOR, GRN_ID_NIL);
for (i = 0; i < scanner->n_sis; i++) {
for (i = 0; (uint) i < scanner->n_sis; i++) {
scan_info *si = scanner->sis[i];
if (si->flags & SCAN_POP) {
grn_obj *res_;
@ -6897,7 +6897,7 @@ grn_table_select(grn_ctx *ctx, grn_obj *table, grn_obj *expr,
i = 0;
if (!res_created) { i++; }
for (; i < GRN_BULK_VSIZE(&res_stack) / sizeof(grn_obj *); i++) {
for (; (uint) i < GRN_BULK_VSIZE(&res_stack) / sizeof(grn_obj *); i++) {
grn_obj *stacked_res;
stacked_res = *((grn_obj **)GRN_BULK_HEAD(&res_stack) + i);
grn_obj_close(ctx, stacked_res);

3
storage/mroonga/vendor/groonga/lib/geo.c vendored
View file

@ -64,7 +64,8 @@ typedef struct {
static int
compute_diff_bit(uint8_t *geo_key1, uint8_t *geo_key2)
{
int i, j, diff_bit = 0;
size_t i;
int j, diff_bit = 0;
for (i = 0; i < sizeof(grn_geo_point); i++) {
if (geo_key1[i] != geo_key2[i]) {

4
storage/mroonga/vendor/groonga/lib/hash.c vendored
View file

@ -2261,7 +2261,7 @@ grn_hash_lock(grn_ctx *ctx, grn_hash *hash, int timeout)
GRN_ATOMIC_ADD_EX(hash->lock, 1, lock);
if (lock) {
GRN_ATOMIC_ADD_EX(hash->lock, -1, lock);
if (!timeout || (timeout > 0 && timeout == count)) { break; }
if (!timeout || (timeout > 0 && (uint32_t) timeout == count)) { break; }
if (!(++_ncolls % 1000000) && (_ncolls > _ncalls)) {
if (_ncolls < 0 || _ncalls < 0) {
_ncolls = 0; _ncalls = 0;
@ -3350,7 +3350,7 @@ grn_hash_sort(grn_ctx *ctx, grn_hash *hash,
return 0;
}
}
if (limit > *hash->n_entries) { limit = *hash->n_entries; }
if ((uint) limit > (uint) *hash->n_entries) { limit = *hash->n_entries; }
/* hash->limit = limit; */
if (optarg) {
int dir = (optarg->flags & GRN_TABLE_SORT_DESC);

75
storage/mroonga/vendor/groonga/lib/ii.c vendored
View file

@ -227,10 +227,9 @@ segment_get(grn_ctx *ctx, grn_ii *ii)
pseg = ii->header->pnext;
#ifndef CUT_OFF_COMPATIBILITY
if (!pseg) {
int i;
uint32_t pmax = 0;
char *used;
uint32_t max_segment = ii->seg->header->max_segment;
uint32_t i, max_segment = ii->seg->header->max_segment;
used = GRN_CALLOC(max_segment);
if (!used) { return max_segment; }
for (i = 0; i < GRN_II_MAX_LSEG && i < max_segment; i++) {
@ -457,8 +456,8 @@ chunk_new(grn_ctx *ctx, grn_ii *ii, uint32_t *res, uint32_t size)
}
*/
if (size > S_CHUNK) {
int i, j;
uint32_t n = (size + S_CHUNK - 1) >> GRN_II_W_CHUNK;
int j;
uint32_t n = (size + S_CHUNK - 1) >> GRN_II_W_CHUNK, i;
for (i = 0, j = -1; i < n_chunks; i++) {
if (HEADER_CHUNK_AT(ii, i)) {
j = i;
@ -466,7 +465,7 @@ chunk_new(grn_ctx *ctx, grn_ii *ii, uint32_t *res, uint32_t size)
if (i == j + n) {
j++;
*res = j << GRN_II_N_CHUNK_VARIATION;
for (; j <= i; j++) { HEADER_CHUNK_ON(ii, j); }
for (; j <= (int) i; j++) { HEADER_CHUNK_ON(ii, j); }
return GRN_SUCCESS;
}
}
@ -538,7 +537,7 @@ chunk_new(grn_ctx *ctx, grn_ii *ii, uint32_t *res, uint32_t size)
if (*vp == GRN_II_PSEG_NOT_ASSIGNED) {
int i = 0;
while (HEADER_CHUNK_AT(ii, i)) {
if (++i >= n_chunks) {
if (++i >= (int) n_chunks) {
DEFINE_NAME(ii);
MERR("[ii][chunk][new] failed to find a free chunk: "
"<%.*s>: "
@ -1757,7 +1756,7 @@ static grn_rc
datavec_reset(grn_ctx *ctx, datavec *dv, uint32_t dvlen,
size_t unitsize, size_t totalsize)
{
int i;
uint32_t i;
if (!dv[0].data || dv[dvlen].data < dv[0].data + totalsize) {
if (dv[0].data) { GRN_FREE(dv[0].data); }
if (!(dv[0].data = GRN_MALLOC(totalsize * sizeof(uint32_t)))) {
@ -1782,7 +1781,7 @@ static grn_rc
datavec_init(grn_ctx *ctx, datavec *dv, uint32_t dvlen,
size_t unitsize, size_t totalsize)
{
int i;
uint32_t i;
if (!totalsize) {
memset(dv, 0, sizeof(datavec) * (dvlen + 1));
return GRN_SUCCESS;
@ -2951,14 +2950,14 @@ buffer_merge_dump_datavec(grn_ctx *ctx,
grn_obj buffer;
GRN_TEXT_INIT(&buffer, 0);
for (i = 0; i < ii->n_elements; i++) {
for (i = 0; (uint) i < ii->n_elements; i++) {
GRN_LOG(ctx, GRN_LOG_DEBUG, "rdv[%d] data_size=%d, flags=%d",
i, rdv[i].data_size, rdv[i].flags);
GRN_BULK_REWIND(&buffer);
for (j = 0; j < rdv[i].data_size;) {
for (j = 0; (uint) j < rdv[i].data_size;) {
grn_text_printf(ctx, &buffer, " %d", rdv[i].data[j]);
j++;
if (!(j % 32) || j == rdv[i].data_size) {
if (!(j % 32) || (uint) j == rdv[i].data_size) {
GRN_LOG(ctx, GRN_LOG_DEBUG,
"rdv[%d].data[%d]%.*s",
i, j,
@ -2969,14 +2968,14 @@ buffer_merge_dump_datavec(grn_ctx *ctx,
}
}
for (i = 0; i < ii->n_elements; i++) {
for (i = 0; (uint) i < ii->n_elements; i++) {
GRN_LOG(ctx, GRN_LOG_DEBUG, "dv[%d] data_size=%d, flags=%d",
i, dv[i].data_size, dv[i].flags);
GRN_BULK_REWIND(&buffer);
for (j = 0; j < dv[i].data_size;) {
for (j = 0; (uint) j < dv[i].data_size;) {
grn_text_printf(ctx, &buffer, " %d", dv[i].data[j]);
j++;
if (!(j % 32) || j == dv[i].data_size) {
if (!(j % 32) || (uint) j == dv[i].data_size) {
GRN_LOG(ctx, GRN_LOG_DEBUG,
"dv[%d].data[%d]%.*s",
i, j,
@ -3031,7 +3030,7 @@ buffer_merge(grn_ctx *ctx, grn_ii *ii, uint32_t seg, grn_hash *h,
uint32_t nvchunks = 0;
chunk_info *cinfo = NULL;
grn_id crid = GRN_ID_NIL;
docinfo cid = {0, 0, 0, 0, 0}, lid = {0, 0, 0, 0, 0}, bid = {0, 0};
docinfo cid = {0, 0, 0, 0, 0}, lid = {0, 0, 0, 0, 0}, bid = {0, 0, 0, 0, 0};
uint32_t sdf = 0, snn = 0, ndf;
uint32_t *srp = NULL, *ssp = NULL, *stp = NULL, *sop = NULL, *snp = NULL;
if (!bt->tid) {
@ -3075,7 +3074,7 @@ buffer_merge(grn_ctx *ctx, grn_ii *ii, uint32_t seg, grn_hash *h,
}
return ctx->rc;
}
for (i = 0; i < nchunks; i++) {
for (i = 0; (uint) i < nchunks; i++) {
GRN_B_DEC(cinfo[i].segno, scp);
GRN_B_DEC(cinfo[i].size, scp);
GRN_B_DEC(cinfo[i].dgap, scp);
@ -3247,7 +3246,7 @@ buffer_merge(grn_ctx *ctx, grn_ii *ii, uint32_t seg, grn_hash *h,
if (nvchunks) {
int i;
GRN_B_ENC(nvchunks, dcp);
for (i = 0; i < nchunks; i++) {
for (i = 0; (uint) i < nchunks; i++) {
if (cinfo[i].size) {
GRN_B_ENC(cinfo[i].segno, dcp);
GRN_B_ENC(cinfo[i].size, dcp);
@ -3281,7 +3280,7 @@ buffer_merge(grn_ctx *ctx, grn_ii *ii, uint32_t seg, grn_hash *h,
nvchunks++;
dcp = dcp0;
GRN_B_ENC(nvchunks, dcp);
for (i = 0; i <= nchunks; i++) {
for (i = 0; (uint) i <= nchunks; i++) {
if (cinfo[i].size) {
GRN_B_ENC(cinfo[i].segno, dcp);
GRN_B_ENC(cinfo[i].size, dcp);
@ -3522,7 +3521,7 @@ grn_ii_buffer_check(grn_ctx *ctx, grn_ii *ii, uint32_t seg)
uint32_t nchunks = 0;
chunk_info *cinfo = NULL;
grn_id crid = GRN_ID_NIL;
docinfo bid = {0, 0};
docinfo bid = {0, 0, 0, 0, 0};
uint32_t sdf = 0, snn = 0;
uint32_t *srp = NULL, *ssp = NULL, *stp = NULL, *sop = NULL, *snp = NULL;
if (!bt->tid && !bt->pos_in_buffer && !bt->size_in_buffer) {
@ -3558,7 +3557,7 @@ grn_ii_buffer_check(grn_ctx *ctx, grn_ii *ii, uint32_t seg)
GRN_OBJ_FIN(ctx, &buf);
return;
}
for (i = 0; i < nchunks; i++) {
for (i = 0; (uint) i < nchunks; i++) {
GRN_B_DEC(cinfo[i].segno, scp);
GRN_B_DEC(cinfo[i].size, scp);
GRN_B_DEC(cinfo[i].dgap, scp);
@ -5070,7 +5069,7 @@ grn_ii_cursor_open(grn_ctx *ctx, grn_ii *ii, grn_id tid,
c = NULL;
goto exit;
}
for (i = 0, crid = GRN_ID_NIL; i < c->nchunks; i++) {
for (i = 0, crid = GRN_ID_NIL; (uint) i < c->nchunks; i++) {
GRN_B_DEC(c->cinfo[i].segno, c->cp);
GRN_B_DEC(c->cinfo[i].size, c->cp);
GRN_B_DEC(c->cinfo[i].dgap, c->cp);
@ -5471,7 +5470,7 @@ grn_ii_cursor_next_pos(grn_ctx *ctx, grn_ii_cursor *c)
{
uint32_t gap;
if ((c->ii->header->flags & GRN_OBJ_WITH_POSITION)) {
if (c->nelements == c->ii->n_elements) {
if (c->nelements == (int) c->ii->n_elements) {
if (c->buf) {
if (c->post == &c->pc) {
if (c->pc.rest) {
@ -6465,7 +6464,7 @@ grn_ii_column_update(grn_ctx *ctx, grn_ii *ii, grn_id rid, unsigned int section,
grn_id tid_ = 0, gap, tid, *tpe;
grn_table_sort_optarg arg = {GRN_TABLE_SORT_ASC|
GRN_TABLE_SORT_AS_NUMBER|
GRN_TABLE_SORT_AS_UNSIGNED, NULL, NULL,0 };
GRN_TABLE_SORT_AS_UNSIGNED, NULL, NULL, 0, 0};
grn_array *sorted = grn_array_create(ctx, NULL, sizeof(grn_id), 0);
grn_hash_sort(ctx, (grn_hash *)new, -1, sorted, &arg);
GRN_TEXT_PUT(ctx, posting, ((grn_hash *)new)->n_entries, sizeof(uint32_t));
@ -7599,7 +7598,7 @@ grn_ii_similar_search(grn_ctx *ctx, grn_ii *ii,
grn_hash_cursor_close(ctx, c);
}
limit = optarg->similarity_threshold
? (optarg->similarity_threshold > GRN_HASH_SIZE(h)
? (optarg->similarity_threshold > (int) GRN_HASH_SIZE(h)
? GRN_HASH_SIZE(h)
: optarg->similarity_threshold)
: (GRN_HASH_SIZE(h) >> 3) + 1;
@ -7613,7 +7612,7 @@ grn_ii_similar_search(grn_ctx *ctx, grn_ii *ii,
GRN_TABLE_SORT_DESC|GRN_TABLE_SORT_BY_VALUE|GRN_TABLE_SORT_AS_NUMBER,
NULL,
NULL,
0
0, 0
};
grn_array *sorted = grn_array_create(ctx, NULL, sizeof(grn_id), 0);
if (!sorted) {
@ -7632,7 +7631,7 @@ grn_ii_similar_search(grn_ctx *ctx, grn_ii *ii,
} else if (optarg->vector_size) {
wvm = optarg->weight_vector ? grn_wv_static : grn_wv_constant;
}
for (j = 1; j <= limit; j++) {
for (j = 1; j <= (uint) limit; j++) {
grn_array_get_value(ctx, sorted, j, &id);
_grn_hash_get_key_value(ctx, h, id, (void **) &tp, (void **) &w1);
if (!*tp || !(c = grn_ii_cursor_open(ctx, ii, *tp, GRN_ID_NIL, GRN_ID_MAX,
@ -8056,7 +8055,7 @@ grn_ii_select_cursor_next(grn_ctx *ctx,
if (ti->pos == pos) {
score += ti->p->weight + ti->cursors->bins[0]->weight;
count++;
if (ti->p->pos > end_pos) {
if ((int) ti->p->pos > end_pos) {
end_pos = ti->p->pos;
}
} else {
@ -8065,9 +8064,9 @@ grn_ii_select_cursor_next(grn_ctx *ctx,
start_pos = pos = ti->pos;
end_pos = ti->p->pos;
}
if (count == n_tis) {
if (count == (int) n_tis) {
pos++;
if (ti->p->pos > end_pos) {
if ((int) ti->p->pos > end_pos) {
end_pos = ti->p->pos;
}
tf = 1;
@ -8224,7 +8223,7 @@ grn_ii_select_regexp(grn_ctx *ctx, grn_ii *ii,
grn_bool have_error = GRN_FALSE;
cursors = GRN_CALLOC(sizeof(grn_ii_select_cursor *) * n_parsed_strings);
for (i = 0; i < n_parsed_strings; i++) {
for (i = 0; (uint) i < n_parsed_strings; i++) {
const char *parsed_string;
unsigned int parsed_string_len;
parsed_string_len = grn_vector_get_element(ctx,
@ -8254,7 +8253,7 @@ grn_ii_select_regexp(grn_ctx *ctx, grn_ii *ii,
}
pos = posting->end_pos;
for (i = 1; i < n_parsed_strings; i++) {
for (i = 1; (uint) i < n_parsed_strings; i++) {
grn_ii_select_cursor_posting *posting_i;
for (;;) {
@ -8286,14 +8285,14 @@ grn_ii_select_regexp(grn_ctx *ctx, grn_ii *ii,
pos = posting_i->end_pos;
}
if (i == n_parsed_strings) {
if ((uint) i == n_parsed_strings) {
grn_rset_posinfo pi = {posting->rid, posting->sid, pos};
double record_score = 1.0;
res_add(ctx, s, &pi, record_score, op);
}
}
for (i = 0; i < n_parsed_strings; i++) {
for (i = 0; (uint) i < n_parsed_strings; i++) {
if (cursors[i]) {
grn_ii_select_cursor_close(ctx, cursors[i]);
}
@ -8768,7 +8767,7 @@ grn_ii_select(grn_ctx *ctx, grn_ii *ii,
record.n_candidates += ti->size;
record.n_tokens += ti->ntoken;
}
if (count == n) {
if ((uint) count == n) {
if (rep) {
pi.pos = pos; res_add(ctx, s, &pi, (score + 1) * weight, op);
}
@ -9556,7 +9555,7 @@ grn_ii_buffer_flush(grn_ctx *ctx, grn_ii_buffer *ii_buffer)
encode_last_tf(ctx, ii_buffer, outbuf);
{
ssize_t r = grn_write(ii_buffer->tmpfd, outbuf, encsize);
if (r != encsize) {
if (r != (ssize_t) encsize) {
ERR(GRN_INPUT_OUTPUT_ERROR,
"write returned %" GRN_FMT_LLD " != %" GRN_FMT_LLU,
(long long int)r, (unsigned long long int)encsize);
@ -12218,7 +12217,7 @@ grn_ii_builder_set_sid_bits(grn_ctx *ctx, grn_ii_builder *builder)
if (!grn_obj_get_value(ctx, builder->srcs[0], rid, &obj)) {
continue;
}
if (obj.u.v.n_sections > max_elems) {
if (obj.u.v.n_sections > (int) max_elems) {
max_elems = obj.u.v.n_sections;
}
}
@ -12610,7 +12609,7 @@ grn_ii_builder_read_to_chunk(grn_ctx *ctx, grn_ii_builder *builder,
/* Read positions or a frequency. */
if (ii_flags & GRN_OBJ_WITH_POSITION) {
uint32_t pos = -1;
uint32_t pos = (uint32_t) -1;
freq = 0;
for (;;) {
rc = grn_ii_builder_read_from_block(ctx, builder, block_id, &value);
@ -12626,7 +12625,7 @@ grn_ii_builder_read_to_chunk(grn_ctx *ctx, grn_ii_builder *builder,
return rc;
}
}
if (pos == -1) {
if (pos == (uint32_t) -1) {
chunk->pos_buf[chunk->pos_offset] = value - 1;
chunk->pos_sum += value - 1;
} else {

3
storage/mroonga/vendor/groonga/lib/index_column.c vendored
View file

@ -66,7 +66,8 @@ grn_index_column_build_call_hook(grn_ctx *ctx, grn_obj *obj,
grn_obj oldvalue;
/* todo : grn_proc_ctx_open() */
grn_obj id_, flags_;
grn_proc_ctx pctx = {{0}, hooks->proc, NULL, hooks, hooks, PROC_INIT, 4, 4};
grn_proc_ctx pctx = {{0}, hooks->proc, NULL, hooks, hooks, PROC_INIT, 4, 4,
{{0}}};
GRN_TEXT_INIT(&oldvalue, 0);
GRN_UINT32_INIT(&id_, 0);
GRN_UINT32_INIT(&flags_, 0);

26
storage/mroonga/vendor/groonga/lib/io.c vendored
View file

@ -526,7 +526,7 @@ grn_io_detect_type(grn_ctx *ctx, const char *path)
grn_open(fd, path, O_RDONLY | GRN_OPEN_FLAG_BINARY);
if (fd != -1) {
struct stat s;
if (fstat(fd, &s) != -1 && s.st_size >= sizeof(struct _grn_io_header)) {
if (fstat(fd, &s) != -1 && (size_t) s.st_size >= sizeof(struct _grn_io_header)) {
if (grn_read(fd, &h, sizeof(struct _grn_io_header)) ==
sizeof(struct _grn_io_header)) {
if (!memcmp(h.idstr, GRN_IO_IDSTR, GRN_IO_IDSTR_LEN)) {
@ -593,7 +593,7 @@ grn_io_open(grn_ctx *ctx, const char *path, grn_io_mode mode)
grn_close(fd);
return NULL;
}
if (s.st_size < sizeof(struct _grn_io_header)) {
if ((size_t) s.st_size < sizeof(struct _grn_io_header)) {
ERR(GRN_INCOMPATIBLE_FILE_FORMAT,
"[io][open] file size is too small: "
"<%" GRN_FMT_INT64D ">(required: >= %" GRN_FMT_SIZE "): <%s>",
@ -707,7 +707,7 @@ grn_io_close(grn_ctx *ctx, grn_io *io)
segment_size = io->header->segment_size;
file_size = grn_io_compute_file_size(io->header->version);
segments_per_file = file_size / segment_size;
for (i = 0; i < max_segment; i++) {
for (i = 0; (uint) i < max_segment; i++) {
grn_io_mapinfo *mi;
mi = &(io->maps[i]);
if (mi->map) {
@ -726,7 +726,7 @@ grn_io_close(grn_ctx *ctx, grn_io *io)
GRN_MUNMAP(ctx, &grn_gctx, io, (io->fis ? &io->fis->fmo : NULL),
io->fis, io->header, io->base);
if (io->fis) {
int i;
uint i;
for (i = 0; i < max_nfiles; i++) {
fileinfo *fi = &(io->fis[i]);
grn_fileinfo_close(ctx, fi);
@ -797,7 +797,7 @@ grn_io_n_files(grn_ctx *ctx, grn_io *io)
grn_rc
grn_io_size(grn_ctx *ctx, grn_io *io, uint64_t *size)
{
int fno;
uint32_t fno;
struct stat s;
uint64_t tsize = 0;
char buffer[PATH_MAX];
@ -930,7 +930,7 @@ grn_io_read_ja(grn_io *io, grn_ctx *ctx, grn_io_ja_einfo *einfo, uint32_t epos,
*value_len = 0;
return GRN_NO_MEMORY_AVAILABLE;
}
if (pos + size > file_size) {
if ((unsigned long) (pos + size) > file_size) {
rest = pos + size - file_size;
size = file_size - pos;
}
@ -1026,7 +1026,7 @@ grn_io_write_ja(grn_io *io, grn_ctx *ctx, uint32_t key,
fileinfo *fi = &io->fis[fno];
off_t base = fno ? 0 : io->base - (uint64_t)segment_size * io->base_seg;
off_t pos = (uint64_t)segment_size * (bseg % segments_per_file) + offset + base;
if (pos + size > file_size) {
if ((unsigned long) (pos + size) > file_size) {
rest = pos + size - file_size;
size = file_size - pos;
}
@ -1303,7 +1303,7 @@ grn_io_expire(grn_ctx *ctx, grn_io *io, int count_thresh, uint32_t limit)
{
uint32_t nref, nmaps, *pnref = &io->nref;
GRN_ATOMIC_ADD_EX(pnref, 1, nref);
if (!nref && grn_gtick - io->count > count_thresh) {
if (!nref && grn_gtick - io->count > (uint) count_thresh) {
{
uint32_t i = io->header->n_arrays;
grn_io_array_spec *array_specs = (grn_io_array_spec *)io->user_header;
@ -1341,10 +1341,10 @@ grn_io_expire(grn_ctx *ctx, grn_io *io, int count_thresh, uint32_t limit)
{
grn_io_mapinfo *info = io->maps;
for (m = io->max_map_seg; n < limit && m; info++, m--) {
if (info->map && (grn_gtick - info->count) > count_thresh) {
if (info->map && (grn_gtick - info->count) > (uint) count_thresh) {
uint32_t nmaps, nref, *pnref = &info->nref;
GRN_ATOMIC_ADD_EX(pnref, 1, nref);
if (!nref && info->map && (grn_gtick - info->count) > count_thresh) {
if (!nref && info->map && (grn_gtick - info->count) > (uint) count_thresh) {
GRN_MUNMAP(ctx, &grn_gctx, io, &info->fmo, NULL,
info->map, io->header->segment_size);
GRN_ATOMIC_ADD_EX(&io->nmaps, -1, nmaps);
@ -1395,7 +1395,7 @@ grn_io_lock(grn_ctx *ctx, grn_io *io, int timeout)
"io(%s) collisions(%d/%d): lock failed %d times",
io->path, _ncolls, _ncalls, count_log_border);
}
if (!timeout || (timeout > 0 && timeout == count)) {
if (!timeout || (timeout > 0 && timeout == (int) count)) {
GRN_LOG(ctx, GRN_LOG_WARNING,
"[DB Locked] time out(%d): io(%s) collisions(%d/%d)",
timeout, io->path, _ncolls, _ncalls);
@ -2166,7 +2166,7 @@ inline static grn_rc
grn_pread(grn_ctx *ctx, fileinfo *fi, void *buf, size_t count, off_t offset)
{
ssize_t r = pread(fi->fd, buf, count, offset);
if (r != count) {
if (r != (ssize_t) count) {
if (r == -1) {
SERR("pread");
} else {
@ -2184,7 +2184,7 @@ inline static grn_rc
grn_pwrite(grn_ctx *ctx, fileinfo *fi, void *buf, size_t count, off_t offset)
{
ssize_t r = pwrite(fi->fd, buf, count, offset);
if (r != count) {
if (r != (ssize_t) count) {
if (r == -1) {
SERR("pwrite");
} else {

5
storage/mroonga/vendor/groonga/lib/load.c vendored
View file

@ -468,7 +468,8 @@ bracket_close(grn_ctx *ctx, grn_loader *loader)
}
for (i = 0; i < nvalues; i++, value = values_next(ctx, value)) {
if (i == loader->id_offset || i == loader->key_offset) {
if ((uint) i == (uint) loader->id_offset ||
(uint) i == (uint) loader->key_offset) {
/* Skip _id and _key, because it's already used to get id. */
continue;
}
@ -532,7 +533,7 @@ brace_close(grn_ctx *ctx, grn_loader *loader)
GRN_ASSERT(value->header.domain == GRN_JSON_LOAD_OPEN_BRACE);
GRN_UINT32_SET(ctx, value_begin, loader->values_size - begin - 1);
value_begin++;
if (GRN_BULK_VSIZE(&loader->level) > sizeof(uint32_t) * loader->emit_level) {
if ((size_t) GRN_BULK_VSIZE(&loader->level) > sizeof(uint32_t) * loader->emit_level) {
return;
}
if (!loader->table) {

4
storage/mroonga/vendor/groonga/lib/logger.c vendored
View file

@ -495,9 +495,9 @@ grn_query_log_flags_parse(const char *string,
}
#define CHECK_FLAG(name) \
if (((string_end - string) >= (sizeof(#name) - 1)) && \
if (((size_t) (string_end - string) >= (sizeof(#name) - 1)) && \
(memcmp(string, #name, sizeof(#name) - 1) == 0) && \
(((string_end - string) == (sizeof(#name) - 1)) || \
(((size_t)(string_end - string) == (sizeof(#name) - 1)) || \
(string[sizeof(#name) - 1] == '|') || \
(string[sizeof(#name) - 1] == ' '))) { \
*flags |= GRN_QUERY_LOG_ ## name; \

7
storage/mroonga/vendor/groonga/lib/normalizer.c vendored
View file

@ -32,9 +32,10 @@ grn_normalizer_register(grn_ctx *ctx,
grn_proc_func *next,
grn_proc_func *fin)
{
grn_expr_var vars[] = {
{ NULL, 0 }
};
grn_expr_var vars[1];
vars[0].name= 0;
vars[0].name_size= 0;
GRN_PTR_INIT(&vars[0].value, 0, GRN_ID_NIL);
if (name_length < 0) {

38
storage/mroonga/vendor/groonga/lib/operator.c vendored
View file

@ -168,31 +168,31 @@ grn_operator_to_exec_func(grn_operator op)
#define DO_EQ_SUB do {\
switch (y->header.domain) {\
case GRN_DB_INT8 :\
r = (x_ == GRN_INT8_VALUE(y));\
r = ((unsigned char) x_ == (unsigned char) GRN_INT8_VALUE(y)); \
break;\
case GRN_DB_UINT8 :\
r = (x_ == GRN_UINT8_VALUE(y));\
break;\
case GRN_DB_INT16 :\
r = (x_ == GRN_INT16_VALUE(y));\
r = ((int) x_ == (int) GRN_INT16_VALUE(y)); \
break;\
case GRN_DB_UINT16 :\
r = (x_ == GRN_UINT16_VALUE(y));\
break;\
case GRN_DB_INT32 :\
r = (x_ == GRN_INT32_VALUE(y));\
r = ((int) x_ == (int) GRN_INT32_VALUE(y)); \
break;\
case GRN_DB_UINT32 :\
r = (x_ == GRN_UINT32_VALUE(y));\
r = ((uint) x_ == GRN_UINT32_VALUE(y)); \
break;\
case GRN_DB_INT64 :\
r = (x_ == GRN_INT64_VALUE(y));\
r = ((long long) x_ == GRN_INT64_VALUE(y)); \
break;\
case GRN_DB_TIME :\
r = (GRN_TIME_PACK(x_,0) == GRN_INT64_VALUE(y));\
break;\
case GRN_DB_UINT64 :\
r = (x_ == GRN_UINT64_VALUE(y));\
r = ((unsigned long long) x_ == GRN_UINT64_VALUE(y)); \
break;\
case GRN_DB_FLOAT :\
r = ((x_ <= GRN_FLOAT_VALUE(y)) && (x_ >= GRN_FLOAT_VALUE(y)));\
@ -203,7 +203,7 @@ grn_operator_to_exec_func(grn_operator op)
{\
const char *p_ = GRN_TEXT_VALUE(y);\
int i_ = grn_atoi(p_, p_ + GRN_TEXT_LEN(y), NULL);\
r = (x_ == i_);\
r = ((int) x_ == i_); \
}\
break;\
default :\
@ -271,10 +271,10 @@ grn_operator_to_exec_func(grn_operator op)
break;\
case GRN_DB_INT64 :\
case GRN_DB_TIME :\
r = (x_ == GRN_INT64_VALUE(y));\
r = ((long long) x_ == GRN_INT64_VALUE(y)); \
break;\
case GRN_DB_UINT64 :\
r = (x_ == GRN_UINT64_VALUE(y));\
r = ((unsigned long long) x_ == GRN_UINT64_VALUE(y)); \
break;\
case GRN_DB_FLOAT :\
r = (x_ == GRN_TIME_PACK(GRN_FLOAT_VALUE(y), 0));\
@ -405,31 +405,31 @@ grn_operator_exec_not_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y)
r = (x_ op (uint8_t)(GRN_BOOL_VALUE(y) ? 1 : 0));\
break;\
case GRN_DB_INT8 :\
r = (x_ op GRN_INT8_VALUE(y));\
r = ((signed char) x_ op GRN_INT8_VALUE(y)); \
break;\
case GRN_DB_UINT8 :\
r = (x_ op GRN_UINT8_VALUE(y));\
r = ((unsigned char) x_ op GRN_UINT8_VALUE(y)); \
break;\
case GRN_DB_INT16 :\
r = (x_ op GRN_INT16_VALUE(y));\
r = ((short) x_ op GRN_INT16_VALUE(y)); \
break;\
case GRN_DB_UINT16 :\
r = (x_ op GRN_UINT16_VALUE(y));\
r = ((unsigned short) x_ op GRN_UINT16_VALUE(y)); \
break;\
case GRN_DB_INT32 :\
r = (x_ op GRN_INT32_VALUE(y));\
r = ((int) x_ op GRN_INT32_VALUE(y)); \
break;\
case GRN_DB_UINT32 :\
r = (x_ op GRN_UINT32_VALUE(y));\
r = ((uint) x_ op GRN_UINT32_VALUE(y)); \
break;\
case GRN_DB_INT64 :\
r = (x_ op GRN_INT64_VALUE(y));\
r = ((long long) x_ op GRN_INT64_VALUE(y)); \
break;\
case GRN_DB_TIME :\
r = (GRN_TIME_PACK(x_,0) op GRN_INT64_VALUE(y));\
break;\
case GRN_DB_UINT64 :\
r = (x_ op GRN_UINT64_VALUE(y));\
r = ((unsigned long long) x_ op GRN_UINT64_VALUE(y)); \
break;\
case GRN_DB_FLOAT :\
r = (x_ op GRN_FLOAT_VALUE(y));\
@ -552,10 +552,10 @@ grn_operator_exec_not_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y)
break;\
case GRN_DB_INT64 :\
case GRN_DB_TIME :\
r = (x_ op GRN_INT64_VALUE(y));\
r = ((long long) x_ op GRN_INT64_VALUE(y)); \
break;\
case GRN_DB_UINT64 :\
r = (x_ op GRN_UINT64_VALUE(y));\
r = ((unsigned long long) x_ op GRN_UINT64_VALUE(y)); \
break;\
case GRN_DB_FLOAT :\
r = (x_ op GRN_TIME_PACK(GRN_FLOAT_VALUE(y), 0));\

2
storage/mroonga/vendor/groonga/lib/output.c vendored
View file

@ -774,7 +774,7 @@ grn_text_atoj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
}
if (a->next) {
a = a->next;
if (GRN_BULK_VSIZE(&buf) >= sizeof(grn_id)) {
if ((size_t) GRN_BULK_VSIZE(&buf) >= sizeof(grn_id)) {
id = *((grn_id *)GRN_BULK_HEAD(&buf));
} else {
id = GRN_ID_NIL;

78
storage/mroonga/vendor/groonga/lib/pat.c vendored
View file

@ -350,11 +350,11 @@ delinfo_turn_2(grn_ctx *ctx, grn_pat *pat, grn_pat_delinfo *di)
return GRN_FILE_CORRUPT;
}
c = PAT_CHK(rn);
if (c <= c0 || len <= c) {
if ((int) c <= (int) c0 || (int) len <= (int) c) {
break;
}
if (c & 1) {
p0 = (c + 1 < len) ? &rn->lr[1] : &rn->lr[0];
p0 = (c + 1 < (int) len) ? &rn->lr[1] : &rn->lr[0];
} else {
p0 = &rn->lr[nth_bit((uint8_t *)key, c, len)];
}
@ -430,7 +430,7 @@ delinfo_new(grn_ctx *ctx, grn_pat *pat)
}
pat->header->curr_del2 = (pat->header->curr_del2 + 1) & GRN_PAT_MDELINFOS;
}
if (n == pat->header->curr_del3) {
if ((int) n == (int) pat->header->curr_del3) {
if (delinfo_turn_3(ctx, pat, &pat->header->delinfos[pat->header->curr_del3])) {
GRN_LOG(ctx, GRN_LOG_CRIT, "d3 failed: %d", pat->header->delinfos[pat->header->curr_del3].ld);
}
@ -879,7 +879,7 @@ chop(grn_ctx *ctx, grn_pat *pat, const char **key, const char *end, uint32_t *lk
#define MAX_FIXED_KEY_SIZE (sizeof(int64_t))
#define KEY_NEEDS_CONVERT(pat,size) \
(!((pat)->obj.header.flags & GRN_OBJ_KEY_VAR_SIZE) && (size) <= MAX_FIXED_KEY_SIZE)
(!((pat)->obj.header.flags & GRN_OBJ_KEY_VAR_SIZE) && (size_t) (size) <= MAX_FIXED_KEY_SIZE)
#define KEY_ENC(pat,keybuf,key,size) do {\
switch ((pat)->obj.header.flags & GRN_OBJ_KEY_MASK) {\
@ -1007,7 +1007,7 @@ _grn_pat_get(grn_ctx *ctx, grn_pat *pat, const void *key, uint32_t key_size, voi
PAT_AT(pat, r, rn);
if (!rn) { break; /* corrupt? */ }
c = PAT_CHK(rn);
if (len <= c) { break; }
if ((int) len <= c) { break; }
if (c <= c0) {
const uint8_t *k = pat_node_get_key(ctx, pat, rn);
if (k && key_size == PAT_LEN(rn) && !memcmp(k, key, key_size)) {
@ -1024,7 +1024,7 @@ _grn_pat_get(grn_ctx *ctx, grn_pat *pat, const void *key, uint32_t key_size, voi
break;
}
if (c & 1) {
r = (c + 1 < len) ? rn->lr[1] : rn->lr[0];
r = (c + 1 < (int) len) ? rn->lr[1] : rn->lr[0];
} else {
r = rn->lr[nth_bit((uint8_t *)key, c, len)];
}
@ -1109,9 +1109,9 @@ grn_pat_prefix_search(grn_ctx *ctx, grn_pat *pat,
PAT_AT(pat, r, rn);
if (!rn) { return GRN_FILE_CORRUPT; }
c = PAT_CHK(rn);
if (c0 < c && c < len - 1) {
if (c0 < c && c < (int) len - 1) {
if (c & 1) {
r = (c + 1 < len) ? rn->lr[1] : rn->lr[0];
r = (c + 1 < (int) len) ? rn->lr[1] : rn->lr[0];
} else {
r = rn->lr[nth_bit((uint8_t *)key, c, len)];
}
@ -1121,7 +1121,7 @@ grn_pat_prefix_search(grn_ctx *ctx, grn_pat *pat,
if (!(k = pat_node_get_key(ctx, pat, rn))) { break; }
if (PAT_LEN(rn) < key_size) { break; }
if (!memcmp(k, key, key_size)) {
if (c >= len - 1) {
if (c >= (int) len - 1) {
get_tc(ctx, pat, h, rn);
} else {
grn_hash_add(ctx, h, &r, sizeof(grn_id), NULL, NULL);
@ -1204,7 +1204,7 @@ grn_pat_lcp_search(grn_ctx *ctx, grn_pat *pat, const void *key, uint32_t key_siz
}
break;
}
if (len <= c) { break; }
if ((int) len <= c) { break; }
if (c & 1) {
uint8_t *p;
pat_node *rn0;
@ -1214,7 +1214,7 @@ grn_pat_lcp_search(grn_ctx *ctx, grn_pat *pat, const void *key, uint32_t key_siz
p = pat_node_get_key(ctx, pat, rn0);
if (!p) { break; }
if (PAT_LEN(rn0) <= key_size && !memcmp(p, key, PAT_LEN(rn0))) { r2 = r0; }
r = (c + 1 < len) ? rn->lr[1] : rn->lr[0];
r = (c + 1 < (int) len) ? rn->lr[1] : rn->lr[0];
} else {
r = rn->lr[nth_bit((uint8_t *)key, c, len)];
}
@ -1240,9 +1240,9 @@ common_prefix_pat_node_get(grn_ctx *ctx, grn_pat *pat, const void *key, uint32_t
PAT_AT(pat, r, rn);
if (!rn) { return GRN_ID_NIL; }
c = PAT_CHK(rn);
if (c0 < c && c < len - 1) {
if (c0 < c && c < (int) len - 1) {
if (c & 1) {
r = (c + 1 < len) ? rn->lr[1] : rn->lr[0];
r = (c + 1 < (int) len) ? rn->lr[1] : rn->lr[0];
} else {
r = rn->lr[nth_bit((uint8_t *)key, c, len)];
}
@ -1542,7 +1542,7 @@ grn_pat_fuzzy_search(grn_ctx *ctx, grn_pat *pat,
key, key_size, dists, lx,
-1, &last_node, max_distance, flags, heap);
GRN_FREE(dists);
for (i = 0; i < heap->n_entries; i++) {
for (i = 0; i < (uint32_t) heap->n_entries; i++) {
if (max_expansion > 0 && i >= max_expansion) {
break;
}
@ -1598,7 +1598,7 @@ _grn_pat_del(grn_ctx *ctx, grn_pat *pat, const char *key, uint32_t key_size, int
return GRN_FILE_CORRUPT;
}
ch = PAT_CHK(rn);
if (len <= ch) {
if ((int) len <= ch) {
return GRN_INVALID_ARGUMENT;
}
if (c >= ch) {
@ -1617,7 +1617,7 @@ _grn_pat_del(grn_ctx *ctx, grn_pat *pat, const char *key, uint32_t key_size, int
p0 = p;
c = ch;
if (c & 1) {
p = (c + 1 < len) ? &rn->lr[1] : &rn->lr[0];
p = (c + 1 < (int) len) ? &rn->lr[1] : &rn->lr[0];
} else {
p = &rn->lr[nth_bit((uint8_t *)key, c, len)];
}
@ -2163,7 +2163,7 @@ grn_pat_scan(grn_ctx *ctx, grn_pat *pat, const char *str, unsigned int str_len,
grn_string_get_normalized(ctx, nstr, &sp, &normalized_length_in_bytes,
NULL);
se = sp + normalized_length_in_bytes;
while (n < sh_size) {
while (n < (int) sh_size) {
if ((tid = grn_pat_lcp_search(ctx, pat, sp, se - sp))) {
const char *key;
uint32_t len;
@ -2231,7 +2231,7 @@ grn_pat_scan(grn_ctx *ctx, grn_pat *pat, const char *str, unsigned int str_len,
} else {
uint32_t len;
const char *sp, *se = str + str_len;
for (sp = str; sp < se && n < sh_size; sp += len) {
for (sp = str; sp < se && n < (int) sh_size; sp += len) {
if ((tid = grn_pat_lcp_search(ctx, pat, sp, se - sp))) {
_grn_pat_key(ctx, pat, tid, &len);
sh[n].id = tid;
@ -2415,9 +2415,9 @@ set_cursor_prefix(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
PAT_AT(pat, id, node);
if (!node) { return GRN_FILE_CORRUPT; }
ch = PAT_CHK(node);
if (c0 < ch && ch < len - 1) {
if (c0 < ch && ch < (int) len - 1) {
if (ch & 1) {
id = (ch + 1 < len) ? node->lr[1] : node->lr[0];
id = (ch + 1 < (int) len) ? node->lr[1] : node->lr[0];
} else {
id = node->lr[nth_bit((uint8_t *)key, ch, len)];
}
@ -2431,13 +2431,13 @@ set_cursor_prefix(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
: !memcmp(k, key, key_size)) {
if (c0 < ch) {
if (flags & GRN_CURSOR_DESCENDING) {
if ((ch > len - 1) || !(flags & GRN_CURSOR_GT)) {
if ((ch > (int) len - 1) || !(flags & GRN_CURSOR_GT)) {
push(c, node->lr[0], ch);
}
push(c, node->lr[1], ch);
} else {
push(c, node->lr[1], ch);
if ((ch > len - 1) || !(flags & GRN_CURSOR_GT)) {
if ((ch > (int) len - 1) || !(flags & GRN_CURSOR_GT)) {
push(c, node->lr[0], ch);
}
}
@ -2469,13 +2469,13 @@ set_cursor_near(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
if (!node) { return GRN_FILE_CORRUPT; }
ch = PAT_CHK(node);
if (ch <= check) {
if (check >= min) { push(c, id, check); }
if (check >= (int) min) { push(c, id, check); }
break;
}
if ((check += 2) < ch) {
if (!(k = pat_node_get_key(ctx, pat, node))) { return GRN_FILE_CORRUPT; }
if ((r = bitcmp(key, k, check >> 1, (ch - check) >> 1))) {
if (ch >= min) {
if (ch >= (int) min) {
push(c, node->lr[1], ch);
push(c, node->lr[0], ch);
}
@ -2484,10 +2484,10 @@ set_cursor_near(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
}
check = ch;
if (nth_bit((uint8_t *)key, check, pat->key_size)) {
if (check >= min) { push(c, node->lr[0], check); }
if (check >= (int) min) { push(c, node->lr[0], check); }
id = node->lr[1];
} else {
if (check >= min) { push(c, node->lr[1], check); }
if (check >= (int) min) { push(c, node->lr[1], check); }
id = node->lr[0];
}
}
@ -2521,7 +2521,7 @@ set_cursor_common_prefix(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
break;
}
check = ch;
if (len <= check) { break; }
if ((int) len <= check) { break; }
if (check & 1) {
grn_id id0 = node->lr[0];
pat_node *node0;
@ -2577,7 +2577,7 @@ set_cursor_ascend(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
}
break;
}
c2 = len < ch ? len : ch;
c2 = (int) len < ch ? (int) len : ch;
if ((check += 2) < c2) {
if (!(k = pat_node_get_key(ctx, pat, node))) { return GRN_FILE_CORRUPT; }
if ((r = bitcmp(key, k, check >> 1, ((c2 + 1) >> 1) - (check >> 1)))) {
@ -2589,13 +2589,13 @@ set_cursor_ascend(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
}
}
check = ch;
if (len <= check) {
if ((int) len <= check) {
push(c, node->lr[1], ch);
push(c, node->lr[0], ch);
break;
}
if (check & 1) {
if (check + 1 < len) {
if (check + 1 < (int) len) {
id = node->lr[1];
} else {
push(c, node->lr[1], check);
@ -2645,7 +2645,7 @@ set_cursor_descend(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
}
break;
}
c2 = len < ch ? len : ch;
c2 = (int) len < ch ? (int) len : ch;
if ((check += 2) < c2) {
if (!(k = pat_node_get_key(ctx, pat, node))) { return GRN_FILE_CORRUPT; }
if ((r = bitcmp(key, k, check >> 1, ((c2 + 1) >> 1) - (check >> 1)))) {
@ -2657,9 +2657,9 @@ set_cursor_descend(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
}
}
check = ch;
if (len <= check) { break; }
if ((int) len <= check) { break; }
if (check & 1) {
if (check + 1 < len) {
if (check + 1 < (int) len) {
push(c, node->lr[0], check);
id = node->lr[1];
} else {
@ -2750,7 +2750,7 @@ grn_pat_cursor_open_by_id(grn_ctx *ctx, grn_pat *pat,
}
}
} else {
if ((dir * (c->tail - c->curr_rec)) < offset) {
if ((int) (dir * (c->tail - c->curr_rec)) < offset) {
c->curr_rec = c->tail;
} else {
c->curr_rec += dir * offset;
@ -3101,7 +3101,7 @@ grn_pat_inspect_nodes(grn_ctx *ctx, grn_pat *pat, grn_obj *buf)
static void
grn_pat_cursor_inspect_entries(grn_ctx *ctx, grn_pat_cursor *c, grn_obj *buf)
{
int i;
uint i;
GRN_TEXT_PUTS(ctx, buf, "[");
for (i = 0; i < c->sp; i++) {
grn_pat_cursor_entry *e = c->ss + i;
@ -3504,9 +3504,9 @@ sub_search(grn_ctx *ctx, grn_pat *pat, grn_id id,
while (pn) {
int ch;
ch = PAT_CHK(pn);
if (*c0 < ch && ch < len - 1) {
if (*c0 < ch && ch < (int) len - 1) {
if (ch & 1) {
id = (ch + 1 < len) ? pn->lr[1] : pn->lr[0];
id = (ch + 1 < (int) len) ? pn->lr[1] : pn->lr[0];
} else {
id = pn->lr[nth_bit(key, ch, len)];
}
@ -3563,11 +3563,11 @@ search_push(grn_ctx *ctx, grn_pat *pat, grn_pat_cursor *c,
uint32_t len = key_len * 16;
if (c0 < ch) {
if (flags & GRN_CURSOR_DESCENDING) {
if ((ch > len - 1) || !(flags & GRN_CURSOR_GT)) { push(c, pn->lr[0], ch); }
if ((ch > (int) len - 1) || !(flags & GRN_CURSOR_GT)) { push(c, pn->lr[0], ch); }
push(c, pn->lr[1], ch);
} else {
push(c, pn->lr[1], ch);
if ((ch > len - 1) || !(flags & GRN_CURSOR_GT)) { push(c, pn->lr[0], ch); }
if ((ch > (int) len - 1) || !(flags & GRN_CURSOR_GT)) { push(c, pn->lr[0], ch); }
}
} else {
if (PAT_LEN(pn) * 16 > len || !(flags & GRN_CURSOR_GT)) { push(c, id, ch); }

6
storage/mroonga/vendor/groonga/lib/proc/proc_column.c vendored
View file

@ -479,6 +479,12 @@ void
grn_proc_init_column_rename(grn_ctx *ctx)
{
grn_expr_var vars[3];
vars[0].name= NULL;
vars[0].name_size= 0;
vars[1].name= NULL;
vars[1].name_size= 0;
vars[2].name= NULL;
vars[2].name_size= 0;
grn_plugin_expr_var_init(ctx, &(vars[0]), "table", -1);
grn_plugin_expr_var_init(ctx, &(vars[1]), "name", -1);

2
storage/mroonga/vendor/groonga/lib/scanner.c vendored
View file

@ -58,7 +58,7 @@ grn_scanner_close(grn_ctx *ctx, grn_scanner *scanner)
}
if (scanner->sis) {
int i;
uint i;
for (i = 0; i < scanner->n_sis; i++) {
grn_scan_info_close(ctx, scanner->sis[i]);
}

6
storage/mroonga/vendor/groonga/lib/store.c vendored
View file

@ -756,7 +756,7 @@ grn_ja_alloc(grn_ctx *ctx, grn_ja *ja, grn_id id,
if (SEGMENTS_AT(ja, i)) {
j = i;
} else {
if (i == j + n) {
if (i == (uint) (j + n)) {
j++;
addr = grn_io_win_map(ja->io, ctx, iw, j, 0, element_size, grn_io_wronly);
if (!addr) {
@ -764,7 +764,7 @@ grn_ja_alloc(grn_ctx *ctx, grn_ja *ja, grn_id id,
return GRN_NO_MEMORY_AVAILABLE;
}
EHUGE_ENC(einfo, j, element_size);
for (; j <= i; j++) { SEGMENTS_HUGE_ON(ja, j); }
for (; j <= (int) i; j++) { SEGMENTS_HUGE_ON(ja, j); }
grn_io_unlock(ja->io);
return GRN_SUCCESS;
}
@ -862,7 +862,7 @@ grn_ja_alloc(grn_ctx *ctx, grn_ja *ja, grn_id id,
}
vp = &ja->header->free_elements[m - JA_W_EINFO];
if (!vp->seg) {
int i = 0;
uint i = 0;
while (SEGMENTS_AT(ja, i)) {
if (++i >= JA_N_DSEGMENTS) {
grn_io_unlock(ja->io);

12
storage/mroonga/vendor/groonga/lib/tokenizer.c vendored
View file

@ -292,11 +292,13 @@ grn_tokenizer_register(grn_ctx *ctx, const char *plugin_name_ptr,
grn_proc_func *init, grn_proc_func *next,
grn_proc_func *fin)
{
grn_expr_var vars[] = {
{ NULL, 0 },
{ NULL, 0 },
{ NULL, 0 }
};
grn_expr_var vars[3];
vars[0].name= NULL;
vars[0].name_size= 0;
vars[1].name= NULL;
vars[1].name_size= 0;
vars[2].name= NULL;
vars[2].name_size= 0;
GRN_TEXT_INIT(&vars[0].value, 0);
GRN_TEXT_INIT(&vars[1].value, 0);
GRN_UINT32_INIT(&vars[2].value, 0);

17
storage/mroonga/vendor/groonga/lib/tokenizers.c vendored
View file

@ -668,7 +668,7 @@ regexp_next(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
break;
}
if (n_characters == ngram_unit) {
if (n_characters == (uint) ngram_unit) {
break;
}
}
@ -676,7 +676,7 @@ regexp_next(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
if (tokenizer->is_overlapping) {
status |= GRN_TOKEN_OVERLAP;
}
if (n_characters < ngram_unit) {
if (n_characters < (uint) ngram_unit) {
status |= GRN_TOKEN_UNMATURED;
}
tokenizer->is_overlapping = (n_characters > 1);
@ -835,11 +835,14 @@ grn_rc
grn_db_init_builtin_tokenizers(grn_ctx *ctx)
{
grn_obj *obj;
grn_expr_var vars[] = {
{NULL, 0},
{NULL, 0},
{NULL, 0}
};
grn_expr_var vars[3];
vars[0].name= NULL;
vars[0].name_size= 0;
vars[1].name= NULL;
vars[1].name_size= 0;
vars[2].name= NULL;
vars[2].name_size= 0;
GRN_TEXT_INIT(&vars[0].value, 0);
GRN_TEXT_INIT(&vars[1].value, 0);
GRN_UINT32_INIT(&vars[2].value, 0);

2
storage/mroonga/vendor/groonga/lib/util.c vendored
View file

@ -1155,7 +1155,7 @@ grn_geo_point_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj)
point.latitude = latitude;
point.longitude = longitude;
grn_gton(encoded, &point, sizeof(grn_geo_point));
for (i = 0; i < sizeof(grn_geo_point); i++) {
for (i = 0; (uint) i < sizeof(grn_geo_point); i++) {
if (i != 0) {
GRN_TEXT_PUTS(ctx, buf, " ");
}

4
storage/mroonga/vendor/groonga/lib/window_function.c vendored
View file

@ -63,7 +63,7 @@ grn_window_next(grn_ctx *ctx, grn_window *window)
}
if (window->direction == GRN_WINDOW_DIRECTION_ASCENDING) {
if (window->current_index >= window->n_ids) {
if ((unsigned long) window->current_index >= window->n_ids) {
GRN_API_RETURN(GRN_ID_NIL);
}
} else {
@ -250,7 +250,7 @@ grn_expr_is_window_function_call(grn_ctx *ctx,
if (call->op != GRN_OP_CALL) {
return GRN_FALSE;
}
if (call->nargs != (expr->codes_curr - 1)) {
if ((unsigned int) call->nargs != (expr->codes_curr - 1)) {
return GRN_FALSE;
}