null+****@clear*****
null+****@clear*****
2010年 6月 14日 (月) 21:37:31 JST
Daijiro MORI 2010-06-14 12:37:31 +0000 (Mon, 14 Jun 2010)
New Revision: bf27fd8d8b8259d356b13b80e1c5b85b6ab1dfa5
Log:
Added grn_proc_get_var().
Modified files:
lib/ctx.c
lib/db.h
lib/expr.c
lib/proc.c
lib/ql.h
Modified: lib/ctx.c (+11 -11)
===================================================================
--- lib/ctx.c 2010-06-13 09:10:38 +0000 (b368296)
+++ lib/ctx.c 2010-06-14 12:37:31 +0000 (1803b45)
@@ -252,7 +252,7 @@ grn_ctx_impl_init(grn_ctx *ctx)
CRITICAL_SECTION_INIT(ctx->impl->lock);
ctx->impl->db = NULL;
- ctx->impl->expr_vars = grn_hash_create(ctx, NULL, sizeof(grn_id), sizeof(grn_expr_vars), 0);
+ ctx->impl->expr_vars = grn_hash_create(ctx, NULL, sizeof(grn_id), sizeof(grn_obj *), 0);
ctx->impl->stack_curr = 0;
ctx->impl->qe_next = NULL;
ctx->impl->parser = NULL;
@@ -429,13 +429,15 @@ grn_ctx_fin(grn_ctx *ctx)
rc = grn_bulk_fin(ctx, &ctx->impl->subbuf);
{
uint32_t i;
- grn_expr_var *v;
- grn_expr_vars *vp;
- GRN_HASH_EACH(ctx, ctx->impl->expr_vars, id, NULL, NULL, &vp, {
- for (v = vp->vars, i = vp->nvars; i; v++, i--) {
- GRN_OBJ_FIN(ctx, &v->value);
+ grn_hash **vp;
+ grn_obj *value;
+ GRN_HASH_EACH(ctx, ctx->impl->expr_vars, eid, NULL, NULL, &vp, {
+ if (*vp) {
+ GRN_HASH_EACH(ctx, *vp, id, NULL, NULL, &value, {
+ GRN_OBJ_FIN(ctx, value);
+ });
}
- GRN_FREE(vp->vars);
+ grn_hash_close(ctx, *vp);
});
}
grn_hash_close(ctx, ctx->impl->expr_vars);
@@ -869,8 +871,7 @@ grn_ctx_qe_exec_uri(grn_ctx *ctx, const char *path, uint32_t path_len)
v = GRN_TEXT_VALUE(&buf);
get_content_mime_type(ctx, v, GRN_BULK_CURR(&buf));
} else {
- if (!(val = grn_expr_get_var(ctx, expr, v, l)) &&
- !(val = grn_expr_add_var(ctx, expr, v, l))) {
+ if (!(val = grn_expr_get_or_add_var(ctx, expr, v, l))) {
val = &buf;
}
grn_obj_reinit(ctx, val, GRN_DB_TEXT, 0);
@@ -919,8 +920,7 @@ grn_ctx_qe_exec(grn_ctx *ctx, const char *str, uint32_t str_len)
p = grn_text_unesc_tok(ctx, &buf, p, e, &tok_type);
v = GRN_TEXT_VALUE(&buf);
get_content_mime_type(ctx, v, GRN_BULK_CURR(&buf));
- } else if ((val = grn_expr_get_var(ctx, expr, v, l)) ||
- (val = grn_expr_add_var(ctx, expr, v, l))) {
+ } else if ((val = grn_expr_get_or_add_var(ctx, expr, v, l))) {
grn_obj_reinit(ctx, val, GRN_DB_TEXT, 0);
p = grn_text_unesc_tok(ctx, val, p, e, &tok_type);
} else {
Modified: lib/db.h (+13 -0)
===================================================================
--- lib/db.h 2010-06-13 09:10:38 +0000 (7c41d52)
+++ lib/db.h 2010-06-14 12:37:31 +0000 (f95e216)
@@ -179,6 +179,19 @@ struct _grn_proc {
// grn_obj results[16];
};
+#define GRN_PROC_GET_VAR(name) (grn_proc_get_var(ctx, user_data, name, strlen(name)))
+#define GRN_PROC_GET_VAR_BY_OFFSET(offset) (grn_proc_get_var_by_offset(ctx, user_data, offset))
+#define GRN_PROC_ALLOC(offset) (grn_proc_alloc(ctx, user_data, domain, flags))
+
+grn_obj *grn_proc_get_var(grn_ctx *ctx, grn_user_data *user_data,
+ const char *name, unsigned name_size);
+
+grn_obj *grn_proc_get_var_by_offset(grn_ctx *ctx, grn_user_data *user_data,
+ unsigned int offset);
+
+grn_obj *grn_proc_alloc(grn_ctx *ctx, grn_user_data *user_data,
+ grn_id domain, grn_obj_flags flags);
+
typedef struct _grn_accessor_view grn_accessor_view;
struct _grn_accessor_view {
Modified: lib/expr.c (+73 -52)
===================================================================
--- lib/expr.c 2010-06-13 09:10:38 +0000 (fe197ee)
+++ lib/expr.c 2010-06-14 12:37:31 +0000 (8b8c7d2)
@@ -40,39 +40,34 @@ grn_expr_alloc(grn_ctx *ctx, grn_obj *expr, grn_id domain, grn_obj_flags flags)
return res;
}
-grn_expr_var *
+static grn_hash *
grn_expr_get_vars(grn_ctx *ctx, grn_obj *expr, unsigned *nvars)
{
- grn_expr_var *vars = NULL;
- *nvars = 0;
+ grn_hash *vars = NULL;
if (expr->header.type == GRN_PROC || expr->header.type == GRN_EXPR) {
grn_id id = DB_OBJ(expr)->id;
grn_expr *e = (grn_expr *)expr;
- if (id & GRN_OBJ_TMP_OBJECT) {
- vars = e->vars;
- *nvars = e->nvars;
- } else {
- int added = 0;
- grn_expr_vars *vp;
- if (grn_hash_add(ctx, ctx->impl->expr_vars, &id, sizeof(grn_id), (void **)&vp, &added)) {
- if (!vp->vars) {
- grn_expr_var *v, *v0;
- if ((vars = vp->vars = GRN_MALLOCN(grn_expr_var, e->nvars))) {
- uint32_t i;
- for (v0 = e->vars, v = vars, i = e->nvars; i; v0++, v++, i--) {
- v->name = v0->name;
- v->name_size = v0->name_size;
- GRN_OBJ_INIT(&v->value, v0->value.header.type, 0, v0->value.header.domain);
- GRN_TEXT_PUT(ctx, &v->value, GRN_TEXT_VALUE(&v0->value), GRN_TEXT_LEN(&v0->value));
- }
- vp->nvars = e->nvars;
+ int added = 0;
+ grn_hash **vp;
+ if (grn_hash_add(ctx, ctx->impl->expr_vars, &id, sizeof(grn_id), (void **)&vp, &added)) {
+ if (!*vp) {
+ *vp = grn_hash_create(ctx, NULL, GRN_TABLE_MAX_KEY_SIZE, sizeof(grn_obj),
+ GRN_OBJ_KEY_VAR_SIZE|GRN_OBJ_TEMPORARY|GRN_HASH_TINY);
+ if (*vp) {
+ uint32_t i;
+ grn_obj *value;
+ grn_expr_var *v;
+ for (v = e->vars, i = e->nvars; i; v++, i--) {
+ grn_hash_add(ctx, *vp, v->name, v->name_size, (void **)&value, &added);
+ GRN_OBJ_INIT(value, v->value.header.type, 0, v->value.header.domain);
+ GRN_TEXT_PUT(ctx, value, GRN_TEXT_VALUE(&v->value), GRN_TEXT_LEN(&v->value));
}
}
- *nvars = vp->nvars;
- vars = vp->vars;
}
+ vars = *vp;
}
}
+ *nvars = vars ? GRN_HASH_SIZE(vars) : 0;
return vars;
}
@@ -80,26 +75,17 @@ grn_rc
grn_expr_clear_vars(grn_ctx *ctx, grn_obj *expr)
{
if (expr->header.type == GRN_PROC || expr->header.type == GRN_EXPR) {
- uint32_t i;
- grn_expr_var *v;
- grn_id id = DB_OBJ(expr)->id;
- grn_expr *e = (grn_expr *)expr;
- if (id & GRN_OBJ_TMP_OBJECT) {
- for (v = e->vars, i = e->nvars; i; v++, i--) {
- GRN_OBJ_FIN(ctx, &v->value);
- }
- } else {
- grn_id eid;
- grn_expr_vars *vp;
- if ((eid = grn_hash_get(ctx, ctx->impl->expr_vars, &id, sizeof(grn_id), (void **)&vp))) {
- if (vp->vars) {
- for (v = vp->vars, i = vp->nvars; i; v++, i--) {
- GRN_OBJ_FIN(ctx, &v->value);
- }
- GRN_FREE(vp->vars);
- }
- grn_hash_delete_by_id(ctx, ctx->impl->expr_vars, eid, NULL);
+ grn_hash **vp;
+ grn_id eid, id = DB_OBJ(expr)->id;
+ if ((eid = grn_hash_get(ctx, ctx->impl->expr_vars, &id, sizeof(grn_id), (void **)&vp))) {
+ if (*vp) {
+ grn_obj *value;
+ GRN_HASH_EACH(ctx, *vp, i, NULL, NULL, (void **)&value, {
+ GRN_OBJ_FIN(ctx, value);
+ });
+ grn_hash_close(ctx, *vp);
}
+ grn_hash_delete_by_id(ctx, ctx->impl->expr_vars, eid, NULL);
}
}
return ctx->rc;
@@ -112,7 +98,9 @@ grn_proc_get_info(grn_ctx *ctx, grn_user_data *user_data,
grn_proc_ctx *pctx = (grn_proc_ctx *)user_data;
if (caller) { *caller = pctx->caller; }
if (pctx->proc) {
- *vars = grn_expr_get_vars(ctx, (grn_obj *)pctx->proc, nvars);
+ *vars = pctx->proc->vars;
+ *nvars = pctx->proc->nvars;
+ // *vars = grn_expr_get_vars(ctx, (grn_obj *)pctx->proc, nvars);
} else {
*vars = NULL;
*nvars = 0;
@@ -120,6 +108,27 @@ grn_proc_get_info(grn_ctx *ctx, grn_user_data *user_data,
return (grn_obj *)pctx->proc;
}
+grn_obj *
+grn_proc_get_var(grn_ctx *ctx, grn_user_data *user_data, const char *name, unsigned name_size)
+{
+ grn_proc_ctx *pctx = (grn_proc_ctx *)user_data;
+ return pctx->proc ? grn_expr_get_var(ctx, (grn_obj *)pctx->proc, name, name_size) : NULL;
+}
+
+grn_obj *
+grn_proc_get_var_by_offset(grn_ctx *ctx, grn_user_data *user_data, unsigned int offset)
+{
+ grn_proc_ctx *pctx = (grn_proc_ctx *)user_data;
+ return pctx->proc ? grn_expr_get_var_by_offset(ctx, (grn_obj *)pctx->proc, offset) : NULL;
+}
+
+grn_obj *
+grn_proc_alloc(grn_ctx *ctx, grn_user_data *user_data, grn_id domain, grn_obj_flags flags)
+{
+ grn_proc_ctx *pctx = (grn_proc_ctx *)user_data;
+ return pctx->caller ? grn_expr_alloc(ctx, (grn_obj *)pctx->caller, domain, flags) : NULL;
+}
+
/* grn_expr */
static char *opstrs[] = {
@@ -651,22 +660,34 @@ grn_obj *
grn_expr_get_var(grn_ctx *ctx, grn_obj *expr, const char *name, unsigned name_size)
{
uint32_t n;
- grn_expr_var *v;
- for (v = grn_expr_get_vars(ctx, expr, &n); n--; v++) {
- if (v->name_size == name_size && !memcmp(v->name, name, name_size)) {
- return &v->value;
- }
+ grn_obj *res = NULL;
+ grn_hash *vars = grn_expr_get_vars(ctx, expr, &n);
+ if (vars) { grn_hash_get(ctx, vars, name, name_size, (void **)&res); }
+ return res;
+}
+
+grn_obj *
+grn_expr_get_or_add_var(grn_ctx *ctx, grn_obj *expr, const char *name, unsigned name_size)
+{
+ uint32_t n;
+ grn_obj *res = NULL;
+ grn_hash *vars = grn_expr_get_vars(ctx, expr, &n);
+ if (vars) {
+ int added = 0;
+ grn_hash_add(ctx, vars, name, name_size, (void **)&res, &added);
+ if (added) { GRN_TEXT_INIT(res, 0); }
}
- return NULL;
+ return res;
}
grn_obj *
grn_expr_get_var_by_offset(grn_ctx *ctx, grn_obj *expr, unsigned int offset)
{
uint32_t n;
- grn_expr_var *v;
- v = grn_expr_get_vars(ctx, expr, &n);
- return (offset < n) ? &v[offset].value : NULL;
+ grn_obj *res = NULL;
+ grn_hash *vars = grn_expr_get_vars(ctx, expr, &n);
+ if (vars) { res = (grn_obj *)grn_hash_get_value_(ctx, vars, offset + 1, &n); }
+ return res;
}
#define EXPRVP(x) ((x)->header.impl_flags & GRN_OBJ_EXPRVALUE)
Modified: lib/proc.c (+127 -158)
===================================================================
--- lib/proc.c 2010-06-13 09:10:38 +0000 (bae1131)
+++ lib/proc.c 2010-06-14 12:37:31 +0000 (6044760)
@@ -31,6 +31,8 @@
/**** globals for procs ****/
const char *grn_admin_html_path = NULL;
+#define VAR GRN_PROC_GET_VAR_BY_OFFSET
+
/**** procs ****/
#define DEFAULT_LIMIT 10
@@ -43,28 +45,27 @@ proc_select(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
+ grn_content_type ct = ctx->impl->output_type;
grn_obj *outbuf = ctx->impl->outbuf;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 16) ? grn_get_ctype(&vars[15].value) : GRN_CONTENT_JSON;
if (nvars == 16) {
- int offset = GRN_TEXT_LEN(&vars[7].value)
- ? grn_atoi(GRN_TEXT_VALUE(&vars[7].value), GRN_BULK_CURR(&vars[7].value), NULL)
+ int offset = GRN_TEXT_LEN(VAR(7))
+ ? grn_atoi(GRN_TEXT_VALUE(VAR(7)), GRN_BULK_CURR(VAR(7)), NULL)
: 0;
- int limit = GRN_TEXT_LEN(&vars[8].value)
- ? grn_atoi(GRN_TEXT_VALUE(&vars[8].value), GRN_BULK_CURR(&vars[8].value), NULL)
+ int limit = GRN_TEXT_LEN(VAR(8))
+ ? grn_atoi(GRN_TEXT_VALUE(VAR(8)), GRN_BULK_CURR(VAR(8)), NULL)
: DEFAULT_LIMIT;
- char *output_columns = GRN_TEXT_VALUE(&vars[6].value);
- uint32_t output_columns_len = GRN_TEXT_LEN(&vars[6].value);
- char *drilldown_output_columns = GRN_TEXT_VALUE(&vars[11].value);
- uint32_t drilldown_output_columns_len = GRN_TEXT_LEN(&vars[11].value);
- int drilldown_offset = GRN_TEXT_LEN(&vars[12].value)
- ? grn_atoi(GRN_TEXT_VALUE(&vars[12].value), GRN_BULK_CURR(&vars[12].value), NULL)
+ char *output_columns = GRN_TEXT_VALUE(VAR(6));
+ uint32_t output_columns_len = GRN_TEXT_LEN(VAR(6));
+ char *drilldown_output_columns = GRN_TEXT_VALUE(VAR(11));
+ uint32_t drilldown_output_columns_len = GRN_TEXT_LEN(VAR(11));
+ int drilldown_offset = GRN_TEXT_LEN(VAR(12))
+ ? grn_atoi(GRN_TEXT_VALUE(VAR(12)), GRN_BULK_CURR(VAR(12)), NULL)
: 0;
- int drilldown_limit = GRN_TEXT_LEN(&vars[13].value)
- ? grn_atoi(GRN_TEXT_VALUE(&vars[13].value), GRN_BULK_CURR(&vars[13].value), NULL)
+ int drilldown_limit = GRN_TEXT_LEN(VAR(13))
+ ? grn_atoi(GRN_TEXT_VALUE(VAR(13)), GRN_BULK_CURR(VAR(13)), NULL)
: DEFAULT_DRILLDOWN_LIMIT;
if (!output_columns_len) {
output_columns = DEFAULT_OUTPUT_COLUMNS;
@@ -76,19 +77,19 @@ proc_select(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
}
if (grn_select(ctx, outbuf, ct,
- GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value),
- GRN_TEXT_VALUE(&vars[1].value), GRN_TEXT_LEN(&vars[1].value),
- GRN_TEXT_VALUE(&vars[2].value), GRN_TEXT_LEN(&vars[2].value),
- GRN_TEXT_VALUE(&vars[3].value), GRN_TEXT_LEN(&vars[3].value),
- GRN_TEXT_VALUE(&vars[4].value), GRN_TEXT_LEN(&vars[4].value),
- GRN_TEXT_VALUE(&vars[5].value), GRN_TEXT_LEN(&vars[5].value),
+ GRN_TEXT_VALUE(VAR(0)), GRN_TEXT_LEN(VAR(0)),
+ GRN_TEXT_VALUE(VAR(1)), GRN_TEXT_LEN(VAR(1)),
+ GRN_TEXT_VALUE(VAR(2)), GRN_TEXT_LEN(VAR(2)),
+ GRN_TEXT_VALUE(VAR(3)), GRN_TEXT_LEN(VAR(3)),
+ GRN_TEXT_VALUE(VAR(4)), GRN_TEXT_LEN(VAR(4)),
+ GRN_TEXT_VALUE(VAR(5)), GRN_TEXT_LEN(VAR(5)),
output_columns, output_columns_len,
offset, limit,
- GRN_TEXT_VALUE(&vars[9].value), GRN_TEXT_LEN(&vars[9].value),
- GRN_TEXT_VALUE(&vars[10].value), GRN_TEXT_LEN(&vars[10].value),
+ GRN_TEXT_VALUE(VAR(9)), GRN_TEXT_LEN(VAR(9)),
+ GRN_TEXT_VALUE(VAR(10)), GRN_TEXT_LEN(VAR(10)),
drilldown_output_columns, drilldown_output_columns_len,
drilldown_offset, drilldown_limit,
- GRN_TEXT_VALUE(&vars[14].value), GRN_TEXT_LEN(&vars[14].value))) {
+ GRN_TEXT_VALUE(VAR(14)), GRN_TEXT_LEN(VAR(14)))) {
}
} else {
ERR(GRN_INVALID_ARGUMENT, "invalid argument number. %d for %d", nvars, 15);
@@ -101,14 +102,12 @@ proc_define_selector(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *use
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 17) ? grn_get_ctype(&vars[16].value) : GRN_CONTENT_JSON;
if (nvars == 17) {
grn_proc_create(ctx,
- GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value),
+ GRN_TEXT_VALUE(VAR(0)), GRN_TEXT_LEN(VAR(0)),
GRN_PROC_COMMAND, proc_select, NULL, NULL, nvars - 1, vars + 1);
} else {
ERR(GRN_INVALID_ARGUMENT, "invalid argument number. %d for %d", nvars, 16);
@@ -120,19 +119,17 @@ static grn_obj *
proc_load(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
- grn_content_type ct;
grn_obj *outbuf = ctx->impl->outbuf;
grn_expr_var *vars;
- grn_obj *proc = grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 6) ? grn_get_ctype(&vars[5].value) : GRN_CONTENT_JSON;
+ grn_obj *proc = grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 6) {
- grn_load(ctx, grn_get_ctype(&vars[4].value),
- GRN_TEXT_VALUE(&vars[1].value), GRN_TEXT_LEN(&vars[1].value),
- GRN_TEXT_VALUE(&vars[2].value), GRN_TEXT_LEN(&vars[2].value),
- GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value),
- GRN_TEXT_VALUE(&vars[3].value), GRN_TEXT_LEN(&vars[3].value));
+ grn_load(ctx, grn_get_ctype(VAR(4)),
+ GRN_TEXT_VALUE(VAR(1)), GRN_TEXT_LEN(VAR(1)),
+ GRN_TEXT_VALUE(VAR(2)), GRN_TEXT_LEN(VAR(2)),
+ GRN_TEXT_VALUE(VAR(0)), GRN_TEXT_LEN(VAR(0)),
+ GRN_TEXT_VALUE(VAR(3)), GRN_TEXT_LEN(VAR(3)));
if (ctx->impl->loader.stat != GRN_LOADER_END) {
grn_ctx_set_next_expr(ctx, proc);
} else {
@@ -153,11 +150,10 @@ proc_status(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
+ grn_content_type ct = ctx->impl->output_type;
grn_obj *outbuf = ctx->impl->outbuf;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 1) ? grn_get_ctype(&vars[0].value) : GRN_CONTENT_JSON;
if (nvars == 1) {
grn_timeval now;
@@ -335,38 +331,36 @@ proc_table_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_d
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 6) ? grn_get_ctype(&vars[5].value) : GRN_CONTENT_JSON;
if (nvars == 6) {
grn_obj *table;
const char *rest;
- grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[1].value),
- GRN_BULK_CURR(&vars[1].value), &rest);
- if (GRN_TEXT_VALUE(&vars[1].value) == rest) {
- flags = grn_parse_table_create_flags(ctx, GRN_TEXT_VALUE(&vars[1].value),
- GRN_BULK_CURR(&vars[1].value));
+ grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(VAR(1)),
+ GRN_BULK_CURR(VAR(1)), &rest);
+ if (GRN_TEXT_VALUE(VAR(1)) == rest) {
+ flags = grn_parse_table_create_flags(ctx, GRN_TEXT_VALUE(VAR(1)),
+ GRN_BULK_CURR(VAR(1)));
if (ctx->rc) {
return NULL;
}
}
- if (GRN_TEXT_LEN(&vars[0].value)) {
+ if (GRN_TEXT_LEN(VAR(0))) {
flags |= GRN_OBJ_PERSISTENT;
table = grn_table_create(ctx,
- GRN_TEXT_VALUE(&vars[0].value),
- GRN_TEXT_LEN(&vars[0].value),
+ GRN_TEXT_VALUE(VAR(0)),
+ GRN_TEXT_LEN(VAR(0)),
NULL, flags,
- grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[2].value),
- GRN_TEXT_LEN(&vars[2].value)),
- grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value),
- GRN_TEXT_LEN(&vars[3].value)));
+ grn_ctx_get(ctx, GRN_TEXT_VALUE(VAR(2)),
+ GRN_TEXT_LEN(VAR(2))),
+ grn_ctx_get(ctx, GRN_TEXT_VALUE(VAR(3)),
+ GRN_TEXT_LEN(VAR(3))));
if (table) {
grn_obj_set_info(ctx, table,
GRN_INFO_DEFAULT_TOKENIZER,
- grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[4].value),
- GRN_TEXT_LEN(&vars[4].value)));
+ grn_ctx_get(ctx, GRN_TEXT_VALUE(VAR(4)),
+ GRN_TEXT_LEN(VAR(4))));
grn_obj_unlink(ctx, table);
}
} else {
@@ -383,16 +377,14 @@ proc_table_remove(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_d
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 2) ? grn_get_ctype(&vars[1].value) : GRN_CONTENT_JSON;
if (nvars == 2) {
grn_obj *table;
- table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
- GRN_TEXT_LEN(&vars[0].value));
+ table = grn_ctx_get(ctx, GRN_TEXT_VALUE(VAR(0)),
+ GRN_TEXT_LEN(VAR(0)));
if (table) {
grn_obj_remove(ctx,table);
@@ -410,40 +402,38 @@ proc_column_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 6) ? grn_get_ctype(&vars[5].value) : GRN_CONTENT_JSON;
if (nvars == 6) {
grn_obj *column, *table, *type;
const char *rest;
- grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[2].value),
- GRN_BULK_CURR(&vars[2].value), &rest);
- if (GRN_TEXT_VALUE(&vars[2].value) == rest) {
- flags = grn_parse_column_create_flags(ctx, GRN_TEXT_VALUE(&vars[2].value),
- GRN_BULK_CURR(&vars[2].value));
+ grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(VAR(2)),
+ GRN_BULK_CURR(VAR(2)), &rest);
+ if (GRN_TEXT_VALUE(VAR(2)) == rest) {
+ flags = grn_parse_column_create_flags(ctx, GRN_TEXT_VALUE(VAR(2)),
+ GRN_BULK_CURR(VAR(2)));
if (ctx->rc) {
return NULL;
}
}
- table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
- GRN_TEXT_LEN(&vars[0].value));
- type = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value),
- GRN_TEXT_LEN(&vars[3].value));
- if (GRN_TEXT_LEN(&vars[1].value)) { flags |= GRN_OBJ_PERSISTENT; }
+ table = grn_ctx_get(ctx, GRN_TEXT_VALUE(VAR(0)),
+ GRN_TEXT_LEN(VAR(0)));
+ type = grn_ctx_get(ctx, GRN_TEXT_VALUE(VAR(3)),
+ GRN_TEXT_LEN(VAR(3)));
+ if (GRN_TEXT_LEN(VAR(1))) { flags |= GRN_OBJ_PERSISTENT; }
column = grn_column_create(ctx, table,
- GRN_TEXT_VALUE(&vars[1].value),
- GRN_TEXT_LEN(&vars[1].value),
+ GRN_TEXT_VALUE(VAR(1)),
+ GRN_TEXT_LEN(VAR(1)),
NULL, flags, type);
if (column) {
- if (GRN_TEXT_LEN(&vars[4].value)) {
+ if (GRN_TEXT_LEN(VAR(4))) {
grn_obj sources, source_ids, **p, **pe;
GRN_PTR_INIT(&sources, GRN_OBJ_VECTOR, GRN_ID_NIL);
GRN_UINT32_INIT(&source_ids, GRN_OBJ_VECTOR);
grn_obj_columns(ctx, type,
- GRN_TEXT_VALUE(&vars[4].value),
- GRN_TEXT_LEN(&vars[4].value),
+ GRN_TEXT_VALUE(VAR(4)),
+ GRN_TEXT_LEN(VAR(4)),
&sources);
p = (grn_obj **)GRN_BULK_HEAD(&sources);
pe = (grn_obj **)GRN_BULK_CURR(&sources);
@@ -478,21 +468,19 @@ proc_column_remove(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 3) ? grn_get_ctype(&vars[2].value) : GRN_CONTENT_JSON;
if (nvars == 3) {
grn_obj *table, *col;
char *colname,fullname[GRN_TABLE_MAX_KEY_SIZE];
unsigned colname_len,fullname_len;
- table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
- GRN_TEXT_LEN(&vars[0].value));
+ table = grn_ctx_get(ctx, GRN_TEXT_VALUE(VAR(0)),
+ GRN_TEXT_LEN(VAR(0)));
- colname = GRN_TEXT_VALUE(&vars[1].value);
- colname_len = GRN_TEXT_LEN(&vars[1].value);
+ colname = GRN_TEXT_VALUE(VAR(1));
+ colname_len = GRN_TEXT_LEN(VAR(1));
if ((fullname_len = grn_obj_name(ctx, table, fullname, GRN_TABLE_MAX_KEY_SIZE))) {
fullname[fullname_len] = GRN_DB_DELIMITER;
@@ -714,19 +702,18 @@ proc_column_list(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_da
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
+ grn_content_type ct = ctx->impl->output_type;
grn_obj *outbuf = ctx->impl->outbuf;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 2) ? grn_get_ctype(&vars[1].value) : GRN_CONTENT_JSON;
if (nvars == 2) {
grn_obj *table;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- if ((table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
- GRN_TEXT_LEN(&vars[0].value)))) {
+ if ((table = grn_ctx_get(ctx, GRN_TEXT_VALUE(VAR(0)),
+ GRN_TEXT_LEN(VAR(0))))) {
grn_hash *cols;
if ((cols = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY))) {
@@ -769,8 +756,8 @@ proc_column_list(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_da
grn_obj_unlink(ctx, table);
} else {
ERR(GRN_INVALID_ARGUMENT, "table '%.*s' is not exist.",
- GRN_TEXT_LEN(&vars[0].value),
- GRN_TEXT_VALUE(&vars[0].value));
+ GRN_TEXT_LEN(VAR(0)),
+ GRN_TEXT_VALUE(VAR(0)));
}
} else {
ERR(GRN_INVALID_ARGUMENT, "invalid argument number. %d for %d", nvars, 2);
@@ -783,11 +770,10 @@ proc_table_list(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_dat
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
+ grn_content_type ct = ctx->impl->output_type;
grn_obj *outbuf = ctx->impl->outbuf;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 1) ? grn_get_ctype(&vars[0].value) : GRN_CONTENT_JSON;
if (nvars == 1) {
grn_table_cursor *cur;
@@ -899,13 +885,13 @@ proc_missing(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
}
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 2 &&
- (plen = GRN_TEXT_LEN(&vars[0].value)) + grn_admin_html_path_len < PATH_MAX) {
+ (plen = GRN_TEXT_LEN(VAR(0))) + grn_admin_html_path_len < PATH_MAX) {
char path[PATH_MAX];
memcpy(path, grn_admin_html_path, grn_admin_html_path_len);
path[grn_admin_html_path_len] = PATH_SEPARATOR[0];
grn_str_url_path_normalize(ctx,
- GRN_TEXT_VALUE(&vars[0].value),
- GRN_TEXT_LEN(&vars[0].value),
+ GRN_TEXT_VALUE(VAR(0)),
+ GRN_TEXT_LEN(VAR(0)),
path + grn_admin_html_path_len + 1,
PATH_MAX - grn_admin_html_path_len - 1);
grn_bulk_put_from_file(ctx, outbuf, path);
@@ -920,18 +906,16 @@ proc_view_add(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 3) ? grn_get_ctype(&vars[2].value) : GRN_CONTENT_JSON;
if (nvars == 3) {
grn_obj *view = grn_ctx_get(ctx,
- GRN_TEXT_VALUE(&vars[0].value),
- GRN_TEXT_LEN(&vars[0].value));
+ GRN_TEXT_VALUE(VAR(0)),
+ GRN_TEXT_LEN(VAR(0)));
grn_obj *table = grn_ctx_get(ctx,
- GRN_TEXT_VALUE(&vars[1].value),
- GRN_TEXT_LEN(&vars[1].value));
+ GRN_TEXT_VALUE(VAR(1)),
+ GRN_TEXT_LEN(VAR(1)));
grn_view_add(ctx, view, table);
} else {
ERR(GRN_INVALID_ARGUMENT, "invalid argument number. %d for %d", nvars, 3);
@@ -944,10 +928,8 @@ proc_quit(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 1) ? grn_get_ctype(&vars[0].value) : GRN_CONTENT_JSON;
if (nvars == 1) {
ctx->stat = GRN_CTX_QUITTING;
@@ -962,10 +944,8 @@ proc_shutdown(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 1) ? grn_get_ctype(&vars[0].value) : GRN_CONTENT_JSON;
if (nvars == 1) {
grn_gctx.stat = GRN_CTX_QUIT;
@@ -982,17 +962,15 @@ proc_clearlock(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data
int olen;
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_obj *obj;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 2) ? grn_get_ctype(&vars[1].value) : GRN_CONTENT_JSON;
if (nvars == 2) {
- olen = GRN_TEXT_LEN(&vars[0].value);
+ olen = GRN_TEXT_LEN(VAR(0));
if (olen) {
- obj = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value), olen);
+ obj = grn_ctx_get(ctx, GRN_TEXT_VALUE(VAR(0)), olen);
} else {
obj = ctx->impl->db;
}
@@ -1017,15 +995,13 @@ proc_log_level(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 2) ? grn_get_ctype(&vars[1].value) : GRN_CONTENT_JSON;
if (nvars == 2) {
char *p;
- if (GRN_TEXT_LEN(&vars[0].value) &&
- (p = strchr(slev, GRN_TEXT_VALUE(&vars[0].value)[0]))) {
+ if (GRN_TEXT_LEN(VAR(0)) &&
+ (p = strchr(slev, GRN_TEXT_VALUE(VAR(0))[0]))) {
info.max_level = (int)(p - slev);
info.flags = GRN_LOG_TIME|GRN_LOG_MESSAGE;
info.func = NULL;
@@ -1045,17 +1021,15 @@ proc_log_put(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 3) ? grn_get_ctype(&vars[2].value) : GRN_CONTENT_JSON;
if (nvars == 3) {
char *p;
- if (GRN_TEXT_LEN(&vars[0].value) &&
- (p = strchr(slev, GRN_TEXT_VALUE(&vars[0].value)[0]))) {
- GRN_TEXT_PUTC(ctx, &vars[1].value, '\0');
- GRN_LOG(ctx, (int)(p - slev), "%s", GRN_TEXT_VALUE(&vars[1].value));
+ if (GRN_TEXT_LEN(VAR(0)) &&
+ (p = strchr(slev, GRN_TEXT_VALUE(VAR(0))[0]))) {
+ GRN_TEXT_PUTC(ctx, VAR(1), '\0');
+ GRN_LOG(ctx, (int)(p - slev), "%s", GRN_TEXT_VALUE(VAR(1)));
} else {
ERR(GRN_INVALID_ARGUMENT, "invalid log level.");
}
@@ -1070,10 +1044,8 @@ proc_log_reopen(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_dat
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 1) ? grn_get_ctype(&vars[0].value) : GRN_CONTENT_JSON;
if (nvars == 1) {
grn_log_reopen(ctx);
@@ -1096,22 +1068,21 @@ proc_set(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
+ grn_content_type ct = ctx->impl->output_type;
grn_obj *outbuf = ctx->impl->outbuf;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 6) ? grn_get_ctype(&vars[5].value) : GRN_CONTENT_JSON;
if (nvars == 6) {
grn_obj *table = grn_ctx_get(ctx,
- GRN_TEXT_VALUE(&vars[0].value),
- GRN_TEXT_LEN(&vars[0].value));
+ GRN_TEXT_VALUE(VAR(0)),
+ GRN_TEXT_LEN(VAR(0)));
if (table) {
grn_id id;
- if (GRN_TEXT_LEN(&vars[1].value)) {
+ if (GRN_TEXT_LEN(VAR(1))) {
if ((id = grn_table_get(ctx, table,
- GRN_TEXT_VALUE(&vars[1].value),
- GRN_TEXT_LEN(&vars[1].value)))) {
+ GRN_TEXT_VALUE(VAR(1)),
+ GRN_TEXT_LEN(VAR(1))))) {
/* todo */
{
grn_obj obj;
@@ -1120,8 +1091,8 @@ proc_set(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
GRN_OBJ_FORMAT_INIT(&format, 1, 0, 1, 0);
GRN_RECORD_SET(ctx, &obj, id);
grn_obj_columns(ctx, table,
- GRN_TEXT_VALUE(&vars[4].value),
- GRN_TEXT_LEN(&vars[4].value), &format.columns);
+ GRN_TEXT_VALUE(VAR(4)),
+ GRN_TEXT_LEN(VAR(4)), &format.columns);
switch (ct) {
case GRN_CONTENT_JSON:
format.flags = 0 /* GRN_OBJ_FORMAT_WITH_COLUMN_NAMES */;
@@ -1165,14 +1136,15 @@ proc_set(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
}
static grn_rc
-proc_get_resolve_parameters(grn_ctx *ctx, grn_expr_var *vars, grn_obj *outbuf,
+proc_get_resolve_parameters(grn_ctx *ctx, grn_user_data *user_data,
+ grn_expr_var *vars, grn_obj *outbuf,
grn_obj **table, grn_id *id)
{
const char *table_text, *id_text, *key_text;
int table_length, id_length, key_length;
- table_text = GRN_TEXT_VALUE(&vars[0].value);
- table_length = GRN_TEXT_LEN(&vars[0].value);
+ table_text = GRN_TEXT_VALUE(VAR(0));
+ table_length = GRN_TEXT_LEN(VAR(0));
if (table_length == 0) {
ERR(GRN_INVALID_ARGUMENT, "table isn't specified");
return ctx->rc;
@@ -1185,10 +1157,10 @@ proc_get_resolve_parameters(grn_ctx *ctx, grn_expr_var *vars, grn_obj *outbuf,
return ctx->rc;
}
- key_text = GRN_TEXT_VALUE(&vars[1].value);
- key_length = GRN_TEXT_LEN(&vars[1].value);
- id_text = GRN_TEXT_VALUE(&vars[4].value);
- id_length = GRN_TEXT_LEN(&vars[4].value);
+ key_text = GRN_TEXT_VALUE(VAR(1));
+ key_length = GRN_TEXT_LEN(VAR(1));
+ id_text = GRN_TEXT_VALUE(VAR(4));
+ id_length = GRN_TEXT_LEN(VAR(4));
switch ((*table)->header.type) {
case GRN_TABLE_NO_KEY:
if (key_length) {
@@ -1263,28 +1235,27 @@ proc_get(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
+ grn_content_type ct = ctx->impl->output_type;
grn_obj *outbuf = ctx->impl->outbuf;
grn_obj *table = NULL;
grn_id id;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 4) ? grn_get_ctype(&vars[3].value) : GRN_CONTENT_JSON;
if (nvars != 5) {
ERR(GRN_INVALID_ARGUMENT, "invalid argument number. %d for %d", nvars, 5);
return NULL;
}
- if (!proc_get_resolve_parameters(ctx, vars, outbuf, &table, &id)) {
+ if (!proc_get_resolve_parameters(ctx, user_data, vars, outbuf, &table, &id)) {
grn_obj obj;
grn_obj_format format;
GRN_RECORD_INIT(&obj, 0, ((grn_db_obj *)table)->id);
GRN_OBJ_FORMAT_INIT(&format, 1, 0, 1, 0);
GRN_RECORD_SET(ctx, &obj, id);
grn_obj_columns(ctx, table,
- GRN_TEXT_VALUE(&vars[2].value),
- GRN_TEXT_LEN(&vars[2].value), &format.columns);
+ GRN_TEXT_VALUE(VAR(2)),
+ GRN_TEXT_LEN(VAR(2)), &format.columns);
switch (ct) {
case GRN_CONTENT_JSON:
format.flags = 0 /* GRN_OBJ_FORMAT_WITH_COLUMN_NAMES */;
@@ -1312,26 +1283,24 @@ proc_delete(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
grn_rc rc;
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 4) ? grn_get_ctype(&vars[3].value) : GRN_CONTENT_JSON;
if (nvars == 4) {
grn_obj *table = grn_ctx_get(ctx,
- GRN_TEXT_VALUE(&vars[0].value),
- GRN_TEXT_LEN(&vars[0].value));
+ GRN_TEXT_VALUE(VAR(0)),
+ GRN_TEXT_LEN(VAR(0)));
if (table) {
- if (GRN_TEXT_LEN(&vars[1].value) && GRN_TEXT_LEN(&vars[3].value)) {
+ if (GRN_TEXT_LEN(VAR(1)) && GRN_TEXT_LEN(VAR(3))) {
ERR(GRN_INVALID_ARGUMENT, "both id and key are specified");
- } else if (GRN_TEXT_LEN(&vars[1].value)) {
- rc = grn_table_delete(ctx, table, GRN_TEXT_VALUE(&vars[1].value),
- GRN_TEXT_LEN(&vars[1].value));
- } else if (GRN_TEXT_LEN(&vars[3].value)) {
+ } else if (GRN_TEXT_LEN(VAR(1))) {
+ rc = grn_table_delete(ctx, table, GRN_TEXT_VALUE(VAR(1)),
+ GRN_TEXT_LEN(VAR(1)));
+ } else if (GRN_TEXT_LEN(VAR(3))) {
const char *end;
- grn_id id = grn_atoui(GRN_TEXT_VALUE(&vars[3].value),
- GRN_BULK_CURR(&vars[3].value), &end);
- if (end == GRN_BULK_CURR(&vars[3].value)) {
+ grn_id id = grn_atoui(GRN_TEXT_VALUE(VAR(3)),
+ GRN_BULK_CURR(VAR(3)), &end);
+ if (end == GRN_BULK_CURR(VAR(3))) {
rc = grn_table_delete_by_id(ctx, table, id);
} else {
ERR(GRN_INVALID_ARGUMENT, "invalid id");
@@ -1890,16 +1859,16 @@ proc_cache_limit(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_da
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
+
grn_obj *outbuf = ctx->impl->outbuf;
uint32_t *mp = grn_cach_max_nentries();
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 2) ? grn_get_ctype(&vars[1].value) : GRN_CONTENT_JSON;
+
grn_text_lltoa(ctx, outbuf, *mp);
- if (nvars == 2 && GRN_TEXT_LEN(&vars[0].value)) {
+ if (nvars == 2 && GRN_TEXT_LEN(VAR(0))) {
const char *rest;
- uint32_t max = grn_atoui(GRN_TEXT_VALUE(&vars[0].value),
- GRN_BULK_CURR(&vars[0].value), &rest);
+ uint32_t max = grn_atoui(GRN_TEXT_VALUE(VAR(0)),
+ GRN_BULK_CURR(VAR(0)), &rest);
*mp = max;
}
return NULL;
@@ -1910,12 +1879,12 @@ proc_register(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_expr_var *vars;
- grn_content_type ct;
+
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
- ct = (nvars >= 2) ? grn_get_ctype(&vars[1].value) : GRN_CONTENT_JSON;
- if (GRN_TEXT_LEN(&vars[0].value)) {
+
+ if (GRN_TEXT_LEN(VAR(0))) {
const char *name;
- name = GRN_TEXT_VALUE(&vars[0].value);
+ name = GRN_TEXT_VALUE(VAR(0));
grn_db_register_by_name(ctx, name);
}
return NULL;
Modified: lib/ql.h (+0 -5)
===================================================================
--- lib/ql.h 2010-06-13 09:10:38 +0000 (2f052db)
+++ lib/ql.h 2010-06-14 12:37:31 +0000 (1fe6bee)
@@ -157,11 +157,6 @@ typedef struct {
grn_loader_stat stat;
} grn_loader;
-typedef struct {
- uint32_t nvars;
- grn_expr_var *vars;
-} grn_expr_vars;
-
#define GRN_STACK_SIZE 1024
#define GRN_CTX_N_SEGMENTS 512