自学教程：C++ GRN_FREE函数代码示例

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_rcgrn_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_rcmecab_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 voidgrn_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_rcgrn_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_rcgrn_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 voidgrn_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_rcgrn_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_valuemrb_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_rcgrn_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_rcngram_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;}

voidgrn_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_rcgrn_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_rcgrn_dat_close(grn_ctx *ctx, grn_dat *dat){  if (dat) {    grn_dat_fin(ctx, dat);    GRN_FREE(dat);  }  return GRN_SUCCESS;}

grn_rcgrn_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_rcgrn_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);}

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