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;
}
}
