grn_dat * grn_dat_open(grn_ctx *ctx, const char *path) { if (path && (std::strlen(path) >= (PATH_MAX - (FILE_ID_LENGTH + 1)))) { ERR(GRN_FILENAME_TOO_LONG, "too long path"); return NULL; } grn_dat * const dat = static_cast<grn_dat *>(GRN_MALLOC(sizeof(grn_dat))); if (!dat) { return NULL; } grn_dat_init(ctx, dat); dat->io = grn_io_open(ctx, path, grn_io_auto); if (!dat->io) { GRN_FREE(dat); return NULL; } dat->header = (struct grn_dat_header *)grn_io_header(dat->io); if (!dat->header) { grn_io_close(ctx, dat->io); GRN_FREE(dat); return NULL; } dat->file_id = dat->header->file_id; dat->encoding = dat->header->encoding; dat->obj.header.flags = dat->header->flags; dat->tokenizer = grn_ctx_at(ctx, dat->header->tokenizer); return dat; }
/* It should be renamed to grn_snip_close() and marked as internal. * TODO: 3.0 */ grn_rc grn_snip_close_real(grn_ctx *ctx, grn_snip *snip) { snip_cond *cond, *cond_end; if (!snip) { return GRN_INVALID_ARGUMENT; } GRN_API_ENTER; if (snip->flags & GRN_SNIP_COPY_TAG) { int i; snip_cond *sc; const char *dot = snip->defaultopentag, *dct = snip->defaultclosetag; for (i = snip->cond_len, sc = snip->cond; i; i--, sc++) { if (sc->opentag != dot) { GRN_FREE((void *)sc->opentag); } if (sc->closetag != dct) { GRN_FREE((void *)sc->closetag); } } if (dot) { GRN_FREE((void *)dot); } if (dct) { GRN_FREE((void *)dct); } } if (snip->nstr) { grn_obj_close(ctx, snip->nstr); } for (cond = snip->cond, cond_end = cond + snip->cond_len; cond < cond_end; cond++) { grn_snip_cond_close(ctx, cond); } GRN_FREE(snip); GRN_API_RETURN(GRN_SUCCESS); }
/* This function finalizes a tokenization. */ static grn_obj * mecab_fin(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { grn_mecab_tokenizer *token = user_data->ptr; grn_str_close(ctx, token->nstr); GRN_FREE(token->buf); GRN_FREE(token); return NULL; }
static grn_rc mecab_fin(grn_ctx *ctx, grn_obj *table, grn_proc_data *user_data) { grn_mecab_tokenizer *token = user_data->ptr; // if (token->mecab) { mecab_destroy(token->mecab); } grn_str_close(ctx, token->nstr); GRN_FREE(token->buf); GRN_FREE(token); return GRN_SUCCESS; }
static void grn_ctx_impl_init(grn_ctx *ctx) { if (!(ctx->impl = GRN_MALLOC(sizeof(struct _grn_ctx_impl)))) { return; } if (!(ctx->impl->segs = grn_io_anon_map(ctx, &ctx->impl->mi, sizeof(grn_io_mapinfo) * N_SEGMENTS))) { GRN_FREE(ctx->impl); ctx->impl = NULL; return; } #ifdef USE_DYNAMIC_MALLOC_CHANGE grn_ctx_impl_init_malloc(ctx); #endif if (!(ctx->impl->values = grn_array_create(ctx, NULL, sizeof(grn_tmp_db_obj), GRN_ARRAY_TINY))) { grn_io_anon_unmap(ctx, &ctx->impl->mi, sizeof(grn_io_mapinfo) * N_SEGMENTS); GRN_FREE(ctx->impl); ctx->impl = NULL; return; } ctx->impl->encoding = ctx->encoding; ctx->impl->lifoseg = -1; ctx->impl->currseg = -1; ctx->impl->db = NULL; ctx->impl->qe = grn_hash_create(ctx, NULL, sizeof(grn_id), sizeof(void *), 0); ctx->impl->stack_curr = 0; ctx->impl->phs = NIL; ctx->impl->code = NIL; ctx->impl->dump = NIL; ctx->impl->op = GRN_OP_T0LVL; ctx->impl->args = NIL; ctx->impl->envir = NIL; ctx->impl->value = NIL; ctx->impl->ncells = 0; ctx->impl->n_entries = 0; ctx->impl->seqno = 0; ctx->impl->lseqno = 0; ctx->impl->nbinds = 0; ctx->impl->nunbinds = 0; ctx->impl->feed_mode = grn_ql_atonce; ctx->impl->cur = NULL; ctx->impl->str_end = NULL; ctx->impl->batchmode = 0; ctx->impl->gc_verbose = 0; ctx->impl->inbuf = NULL; ctx->impl->co.mode = 0; ctx->impl->co.func = NULL; ctx->impl->objects = NULL; ctx->impl->symbols = NULL; ctx->impl->com = NULL; ctx->impl->outbuf = grn_obj_open(ctx, GRN_BULK, 0, 0); GRN_TEXT_INIT(&ctx->impl->subbuf, 0); }
grn_rc grn_com_event_init(grn_ctx *ctx, grn_com_event *ev, int max_nevents, int data_size) { ev->max_nevents = max_nevents; if ((ev->hash = grn_hash_create(ctx, NULL, sizeof(grn_sock), data_size, 0))) { MUTEX_INIT(ev->mutex); COND_INIT(ev->cond); GRN_COM_QUEUE_INIT(&ev->recv_old); ev->msg_handler = NULL; memset(&(ev->curr_edge_id), 0, sizeof(grn_com_addr)); ev->acceptor = NULL; ev->opaque = NULL; #ifndef USE_SELECT # ifdef USE_EPOLL if ((ev->events = GRN_MALLOC(sizeof(struct epoll_event) * max_nevents))) { if ((ev->epfd = epoll_create(max_nevents)) != -1) { goto exit; } else { SERR("epoll_create"); } GRN_FREE(ev->events); } # else /* USE_EPOLL */ # ifdef USE_KQUEUE if ((ev->events = GRN_MALLOC(sizeof(struct kevent) * max_nevents))) { if ((ev->kqfd = kqueue()) != -1) { goto exit; } else { SERR("kqueue"); } GRN_FREE(ev->events); } # else /* USE_KQUEUE */ if ((ev->events = GRN_MALLOC(sizeof(struct pollfd) * max_nevents))) { goto exit; } # endif /* USE_KQUEUE*/ # endif /* USE_EPOLL */ grn_hash_close(ctx, ev->hash); ev->hash = NULL; ev->events = NULL; #else /* USE_SELECT */ goto exit; #endif /* USE_SELECT */ } exit : return ctx->rc; }
grn_rc grn_ra_truncate(grn_ctx *ctx, grn_ra *ra) { grn_rc rc; char *path; unsigned int element_size; if ((path = (char *)grn_io_path(ra->io)) && *path != '\0') { if (!(path = GRN_STRDUP(path))) { ERR(GRN_NO_MEMORY_AVAILABLE, "cannot duplicate path."); return GRN_NO_MEMORY_AVAILABLE; } } else { path = NULL; } element_size = ra->header->element_size; if ((rc = grn_io_close(ctx, ra->io))) { goto exit; } ra->io = NULL; if (path && (rc = grn_io_remove(ctx, path))) { goto exit; } if (!_grn_ra_create(ctx, ra, path, element_size)) { rc = GRN_UNKNOWN_ERROR; } exit: if (path) { GRN_FREE(path); } return rc; }
static grn_obj * delimited_init(grn_ctx *ctx, grn_obj *table, grn_user_data *user_data, uint8_t *delimiter, uint32_t delimiter_len) { grn_obj *str; int nflags = 0; grn_delimited_tokenizer *token; grn_obj_flags table_flags; if (!(str = grn_ctx_pop(ctx))) { ERR(GRN_INVALID_ARGUMENT, "missing argument"); return NULL; } if (!(token = GRN_MALLOC(sizeof(grn_delimited_tokenizer)))) { return NULL; } user_data->ptr = token; token->delimiter = delimiter; token->delimiter_len = delimiter_len; token->pos = 0; grn_table_get_info(ctx, table, &table_flags, &token->encoding, NULL); nflags |= (table_flags & GRN_OBJ_KEY_NORMALIZE); if (!(token->nstr = grn_str_open_(ctx, GRN_TEXT_VALUE(str), GRN_TEXT_LEN(str), nflags, token->encoding))) { GRN_FREE(token); ERR(GRN_TOKENIZER_ERROR, "grn_str_open failed at grn_token_open"); return NULL; } token->next = (unsigned char *)token->nstr->norm; token->end = token->next + token->nstr->norm_blen; token->len = token->nstr->length; GRN_TEXT_INIT(&token->curr_, GRN_OBJ_DO_SHALLOW_COPY); GRN_UINT32_INIT(&token->stat_, 0); return NULL; }
static void grn_token_cursor_close_token_filters(grn_ctx *ctx, grn_token_cursor *token_cursor) { grn_obj *token_filters = token_cursor->token_filter.objects; unsigned int i, n_token_filters; if (token_filters) { n_token_filters = GRN_BULK_VSIZE(token_filters) / sizeof(grn_obj *); } else { n_token_filters = 0; } if (n_token_filters == 0) { return; } for (i = 0; i < n_token_filters; i++) { grn_obj *token_filter_object = GRN_PTR_VALUE_AT(token_filters, i); grn_proc *token_filter = (grn_proc *)token_filter_object; void *data = token_cursor->token_filter.data[i]; token_filter->callbacks.token_filter.fin(ctx, data); } GRN_FREE(token_cursor->token_filter.data); }
grn_rc grn_string_close(grn_ctx *ctx, grn_obj *string) { grn_rc rc; grn_string *string_ = (grn_string *)string; if (string_) { if (string_->normalized) { GRN_FREE(string_->normalized); } if (string_->ctypes) { GRN_FREE(string_->ctypes); } if (string_->checks) { GRN_FREE(string_->checks); } GRN_FREE(string); rc = GRN_SUCCESS; } else { rc = GRN_INVALID_ARGUMENT; } return rc; }
static mrb_value mrb_grn_table_group_raw(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; grn_obj *table; mrb_value mrb_keys; grn_table_sort_key *keys; int i, n_keys; mrb_value mrb_result; grn_table_group_result *result; table = DATA_PTR(self); mrb_get_args(mrb, "oo", &mrb_keys, &mrb_result); mrb_keys = mrb_convert_type(mrb, mrb_keys, MRB_TT_ARRAY, "Array", "to_ary"); n_keys = RARRAY_LEN(mrb_keys); keys = GRN_MALLOCN(grn_table_sort_key, n_keys); for (i = 0; i < n_keys; i++) { memcpy(&(keys[i]), DATA_PTR(RARRAY_PTR(mrb_keys)[i]), sizeof(grn_table_sort_key)); } result = DATA_PTR(mrb_result); grn_table_group(ctx, table, keys, n_keys, result, 1); GRN_FREE(keys); grn_mrb_ctx_check(mrb); return mrb_result; }
grn_obj * grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size, grn_obj_flags flags, unsigned int size) { grn_id id; struct _grn_type *res = NULL; grn_obj *db; if (!ctx || !ctx->impl || !(db = ctx->impl->db)) { ERR(GRN_INVALID_ARGUMENT, "db not initialized"); return NULL; } GRN_API_ENTER; if (grn_db_check_name(ctx, name, name_size)) { GRN_DB_CHECK_NAME_ERR("[type][create]", name, name_size); GRN_API_RETURN(NULL); } if (!GRN_DB_P(db)) { ERR(GRN_INVALID_ARGUMENT, "invalid db assigned"); GRN_API_RETURN(NULL); } id = grn_obj_register(ctx, db, name, name_size); if (id && (res = GRN_MALLOC(sizeof(grn_db_obj)))) { GRN_DB_OBJ_SET_TYPE(res, GRN_TYPE); res->obj.header.flags = flags; res->obj.header.domain = GRN_ID_NIL; GRN_TYPE_SIZE(&res->obj) = size; if (grn_db_obj_init(ctx, db, id, DB_OBJ(res))) { // grn_obj_delete(ctx, db, id); GRN_FREE(res); GRN_API_RETURN(NULL); } } GRN_API_RETURN((grn_obj *)res); }
grn_rc grn_ja_truncate(grn_ctx *ctx, grn_ja *ja) { grn_rc rc; char *path; unsigned int max_element_size; uint32_t flags; if ((path = (char *)grn_io_path(ja->io)) && *path != '\0') { if (!(path = GRN_STRDUP(path))) { ERR(GRN_NO_MEMORY_AVAILABLE, "cannot duplicate path."); return GRN_NO_MEMORY_AVAILABLE; } } else { path = NULL; } max_element_size = ja->header->max_element_size; flags = ja->header->flags; if ((rc = grn_io_close(ctx, ja->io))) { goto exit; } ja->io = NULL; if (path && (rc = grn_io_remove(ctx, path))) { goto exit; } if (!_grn_ja_create(ctx, ja, path, max_element_size, flags)) { rc = GRN_UNKNOWN_ERROR; } exit: if (path) { GRN_FREE(path); } return rc; }
static grn_rc ngram_fin(grn_ctx *ctx, grn_obj *table, grn_proc_data *user_data) { grn_ngram_tokenizer *token = user_data->ptr; grn_str_close(ctx, token->nstr); GRN_FREE(token); return GRN_SUCCESS; }
static grn_obj * uvector_fin(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { grn_uvector_tokenizer *tokenizer = user_data->ptr; grn_tokenizer_token_fin(ctx, &(tokenizer->token)); GRN_FREE(tokenizer); return NULL; }
void grn_dat_cursor_close(grn_ctx *ctx, grn_dat_cursor *c) { if (c) { grn_dat_cursor_fin(ctx, c); GRN_FREE(c); } }
grn_dat * grn_dat_create(grn_ctx *ctx, const char *path, uint32_t, uint32_t, uint32_t flags) { if (path) { if (path[0] == '\0') { path = NULL; } else if (std::strlen(path) >= (PATH_MAX - (FILE_ID_LENGTH + 1))) { ERR(GRN_FILENAME_TOO_LONG, "too long path"); return NULL; } } grn_dat * const dat = static_cast<grn_dat *>(GRN_MALLOC(sizeof(grn_dat))); if (!dat) { return NULL; } grn_dat_init(ctx, dat); dat->obj.header.flags = flags; dat->io = grn_io_create(ctx, path, sizeof(struct grn_dat_header), 4096, 0, grn_io_auto, GRN_IO_EXPIRE_SEGMENT); if (!dat->io) { GRN_FREE(dat); return NULL; } grn_io_set_type(dat->io, GRN_TABLE_DAT_KEY); dat->header = static_cast<struct grn_dat_header *>(grn_io_header(dat->io)); if (!dat->header) { grn_io_close(ctx, dat->io); grn_dat_remove_file(ctx, path); GRN_FREE(dat); return NULL; } const grn_encoding encoding = (ctx->encoding != GRN_ENC_DEFAULT) ? ctx->encoding : grn_gctx.encoding; dat->header->flags = flags; dat->header->encoding = encoding; dat->header->tokenizer = GRN_ID_NIL; dat->header->file_id = 0; dat->encoding = encoding; dat->tokenizer = NULL; return dat; }
static grn_obj * ngram_fin(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { grn_ngram_tokenizer *tokenizer = user_data->ptr; grn_tokenizer_token_fin(ctx, &(tokenizer->token)); grn_tokenizer_query_close(ctx, tokenizer->query); GRN_FREE(tokenizer); return NULL; }
/* grn_ts_obj_cursor_close() destroys a wrapper cursor. */ static grn_rc grn_ts_obj_cursor_close(grn_ctx *ctx, grn_ts_obj_cursor *cursor) { if (cursor->obj) { grn_obj_close(ctx, cursor->obj); } GRN_FREE(cursor); return GRN_SUCCESS; }
grn_rc grn_dat_close(grn_ctx *ctx, grn_dat *dat) { if (dat) { grn_dat_fin(ctx, dat); GRN_FREE(dat); } return GRN_SUCCESS; }
grn_rc grn_query_close(grn_ctx *ctx, grn_query *q) { if (!q) { return GRN_INVALID_ARGUMENT; } if (q->opt.weight_vector) { GRN_FREE(q->opt.weight_vector); } if (q->weight_set) { grn_hash_close(ctx, q->weight_set); } if (q->snip_conds) { snip_cond *sc; for (sc = q->snip_conds; sc < q->snip_conds + q->cur_expr; sc++) { grn_snip_cond_close(ctx, sc); } GRN_FREE(q->snip_conds); } GRN_FREE(q); return GRN_SUCCESS; }
grn_rc grn_command_input_close(grn_ctx *ctx, grn_command_input *input) { GRN_API_ENTER; /* TODO: Free input->arguments by self. */ /* grn_expr_clear_vars(ctx, input->command); */ GRN_FREE(input); GRN_API_RETURN(ctx->rc); }
void grn_scanner_close(grn_ctx *ctx, grn_scanner *scanner) { if (!scanner) { return; } if (scanner->sis) { int i; for (i = 0; i < scanner->n_sis; i++) { grn_scan_info_close(ctx, scanner->sis[i]); } GRN_FREE(scanner->sis); } if (scanner->expr != scanner->source_expr) { grn_obj_close(ctx, scanner->expr); } GRN_FREE(scanner); }
static grn_obj * delimited_fin(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { grn_delimited_tokenizer *tokenizer = user_data->ptr; if (!tokenizer) { return NULL; } grn_tokenizer_query_close(ctx, tokenizer->query); grn_tokenizer_token_fin(ctx, &(tokenizer->token)); GRN_FREE(tokenizer); return NULL; }
grn_rc grn_snip_add_cond(grn_ctx *ctx, grn_snip *snip, const char *keyword, unsigned int keyword_len, const char *opentag, unsigned int opentag_len, const char *closetag, unsigned int closetag_len) { grn_rc rc; int copy_tag; snip_cond *cond; unsigned int norm_blen; if (!snip || !keyword || !keyword_len || snip->cond_len >= MAX_SNIP_COND_COUNT) { return GRN_INVALID_ARGUMENT; } cond = snip->cond + snip->cond_len; if ((rc = grn_snip_cond_init(ctx, cond, keyword, keyword_len, snip->encoding, snip->normalizer, snip->flags))) { return rc; } grn_string_get_normalized(ctx, cond->keyword, NULL, &norm_blen, NULL); if (norm_blen > snip->width) { grn_snip_cond_close(ctx, cond); return GRN_INVALID_ARGUMENT; } copy_tag = snip->flags & GRN_SNIP_COPY_TAG; rc = grn_snip_cond_set_tag(ctx, &(cond->opentag), &(cond->opentag_len), opentag, opentag_len, snip->defaultopentag, snip->defaultopentag_len, copy_tag); if (rc) { grn_snip_cond_close(ctx, cond); return rc; } rc = grn_snip_cond_set_tag(ctx, &(cond->closetag), &(cond->closetag_len), closetag, closetag_len, snip->defaultclosetag, snip->defaultclosetag_len, copy_tag); if (rc) { if (opentag && copy_tag) { GRN_FREE((void *)cond->opentag); } grn_snip_cond_close(ctx, cond); return rc; } snip->cond_len++; return GRN_SUCCESS; }
static grn_obj * regexp_fin(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { grn_regexp_tokenizer *tokenizer = user_data->ptr; if (!tokenizer) { return NULL; } grn_tokenizer_token_fin(ctx, &(tokenizer->token)); grn_tokenizer_query_close(ctx, tokenizer->query); GRN_OBJ_FIN(ctx, &(tokenizer->buffer)); GRN_FREE(tokenizer); return NULL; }
grn_rc grn_ts_expr_close(grn_ctx *ctx, grn_ts_expr *expr) { if (!ctx) { return GRN_INVALID_ARGUMENT; } if (!expr) { GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument"); } grn_ts_expr_fin(ctx, expr); GRN_FREE(expr); return GRN_SUCCESS; }
grn_ja * grn_ja_create(grn_ctx *ctx, const char *path, unsigned int max_element_size, uint32_t flags) { grn_ja *ja = NULL; if (!(ja = GRN_GMALLOC(sizeof(grn_ja)))) { return NULL; } GRN_DB_OBJ_SET_TYPE(ja, GRN_COLUMN_VAR_SIZE); if (!_grn_ja_create(ctx, ja, path, max_element_size, flags)) { GRN_FREE(ja); return NULL; } return ja; }
grn_ra * grn_ra_create(grn_ctx *ctx, const char *path, unsigned int element_size) { grn_ra *ra = NULL; if (!(ra = GRN_GMALLOC(sizeof(grn_ra)))) { return NULL; } GRN_DB_OBJ_SET_TYPE(ra, GRN_COLUMN_FIX_SIZE); if (!_grn_ra_create(ctx, ra, path, element_size)) { GRN_FREE(ra); return NULL; } return ra; }
grn_rc grn_token_close(grn_ctx *ctx, grn_token *token) { if (token) { if (token->tokenizer) { ((grn_proc *)token->tokenizer)->funcs[PROC_FIN](ctx, 1, &token->table, &token->pctx.user_data); } GRN_FREE(token); return GRN_SUCCESS; } else { return GRN_INVALID_ARGUMENT; } }