void
test_is_normalizer_proc(gconstpointer data)
{
const gchar *name;
grn_obj *object;
name = gcut_data_get_string(data, "name");
object = grn_ctx_get(context, name, strlen(name));
if (gcut_data_get_string(data, "expected")) {
cut_assert_true(grn_obj_is_normalizer_proc(context, object));
} else {
cut_assert_false(grn_obj_is_normalizer_proc(context, object));
}
}
static grn_obj *
func_highlight_create_keywords_table(grn_ctx *ctx,
grn_user_data *user_data,
const char *normalizer_name,
unsigned int normalizer_name_length)
{
grn_obj *keywords;
keywords = grn_table_create(ctx, NULL, 0, NULL,
GRN_OBJ_TABLE_PAT_KEY,
grn_ctx_at(ctx, GRN_DB_SHORT_TEXT),
NULL);
if (normalizer_name_length > 0) {
grn_obj *normalizer;
normalizer = grn_ctx_get(ctx,
normalizer_name,
normalizer_name_length);
if (!grn_obj_is_normalizer_proc(ctx, normalizer)) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, normalizer);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"highlight_full() not normalizer: <%.*s>",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
grn_obj_unlink(ctx, normalizer);
grn_obj_unlink(ctx, keywords);
return NULL;
}
grn_obj_set_info(ctx, keywords, GRN_INFO_NORMALIZER, normalizer);
grn_obj_unlink(ctx, normalizer);
}
return keywords;
}
/* TODO: support caching for the same parameter. */
static grn_obj *
func_snippet(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
grn_obj *snippets = NULL;
#define N_REQUIRED_ARGS 1
#define KEYWORD_SET_SIZE 3
if (nargs > N_REQUIRED_ARGS) {
grn_obj *text = args[0];
grn_obj *end_arg = args[nargs - 1];
grn_obj *snip = NULL;
unsigned int width = 200;
unsigned int max_n_results = 3;
grn_snip_mapping *mapping = NULL;
int flags = GRN_SNIP_SKIP_LEADING_SPACES;
const char *prefix = NULL;
int prefix_length = 0;
const char *suffix = NULL;
int suffix_length = 0;
const char *normalizer_name = NULL;
int normalizer_name_length = 0;
const char *default_open_tag = NULL;
int default_open_tag_length = 0;
const char *default_close_tag = NULL;
int default_close_tag_length = 0;
int n_args_without_option = nargs;
if (end_arg->header.type == GRN_TABLE_HASH_KEY) {
grn_obj *options = end_arg;
grn_hash_cursor *cursor;
void *key;
int key_size;
grn_obj *value;
n_args_without_option--;
cursor = grn_hash_cursor_open(ctx, (grn_hash *)options,
NULL, 0, NULL, 0,
0, -1, 0);
if (!cursor) {
GRN_PLUGIN_ERROR(ctx, GRN_NO_MEMORY_AVAILABLE,
"snippet(): couldn't open cursor");
goto exit;
}
while (grn_hash_cursor_next(ctx, cursor) != GRN_ID_NIL) {
grn_hash_cursor_get_key_value(ctx, cursor,
&key, &key_size,
(void **)&value);
if (key_size == 5 && !memcmp(key, "width", 5)) {
width = GRN_UINT32_VALUE(value);
} else if (key_size == 13 && !memcmp(key, "max_n_results", 13)) {
max_n_results = GRN_UINT32_VALUE(value);
} else if (key_size == 19 && !memcmp(key, "skip_leading_spaces", 19)) {
if (GRN_BOOL_VALUE(value) == GRN_FALSE) {
flags &= ~GRN_SNIP_SKIP_LEADING_SPACES;
}
} else if (key_size == 11 && !memcmp(key, "html_escape", 11)) {
if (GRN_BOOL_VALUE(value)) {
mapping = GRN_SNIP_MAPPING_HTML_ESCAPE;
}
} else if (key_size == 6 && !memcmp(key, "prefix", 6)) {
prefix = GRN_TEXT_VALUE(value);
prefix_length = GRN_TEXT_LEN(value);
} else if (key_size == 6 && !memcmp(key, "suffix", 6)) {
suffix = GRN_TEXT_VALUE(value);
suffix_length = GRN_TEXT_LEN(value);
} else if (key_size == 10 && !memcmp(key, "normalizer", 10)) {
normalizer_name = GRN_TEXT_VALUE(value);
normalizer_name_length = GRN_TEXT_LEN(value);
} else if (key_size == 16 && !memcmp(key, "default_open_tag", 16)) {
default_open_tag = GRN_TEXT_VALUE(value);
default_open_tag_length = GRN_TEXT_LEN(value);
} else if (key_size == 17 && !memcmp(key, "default_close_tag", 17)) {
default_close_tag = GRN_TEXT_VALUE(value);
default_close_tag_length = GRN_TEXT_LEN(value);
} else {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"invalid option name: <%.*s>",
key_size, (char *)key);
grn_hash_cursor_close(ctx, cursor);
goto exit;
}
}
grn_hash_cursor_close(ctx, cursor);
}
snip = grn_snip_open(ctx, flags, width, max_n_results,
default_open_tag, default_open_tag_length,
default_close_tag, default_close_tag_length, mapping);
if (snip) {
grn_rc rc;
unsigned int i;
if (!normalizer_name) {
grn_snip_set_normalizer(ctx, snip, GRN_NORMALIZER_AUTO);
} else if (normalizer_name_length > 0) {
grn_obj *normalizer;
normalizer = grn_ctx_get(ctx, normalizer_name, normalizer_name_length);
if (!grn_obj_is_normalizer_proc(ctx, normalizer)) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, normalizer);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"snippet(): not normalizer: <%.*s>",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
grn_obj_unlink(ctx, normalizer);
goto exit;
}
grn_snip_set_normalizer(ctx, snip, normalizer);
grn_obj_unlink(ctx, normalizer);
}
if (default_open_tag_length == 0 && default_close_tag_length == 0) {
unsigned int n_keyword_sets =
(n_args_without_option - N_REQUIRED_ARGS) / KEYWORD_SET_SIZE;
grn_obj **keyword_set_args = args + N_REQUIRED_ARGS;
for (i = 0; i < n_keyword_sets; i++) {
rc = grn_snip_add_cond(ctx, snip,
GRN_TEXT_VALUE(keyword_set_args[i * KEYWORD_SET_SIZE]),
GRN_TEXT_LEN(keyword_set_args[i * KEYWORD_SET_SIZE]),
GRN_TEXT_VALUE(keyword_set_args[i * KEYWORD_SET_SIZE + 1]),
GRN_TEXT_LEN(keyword_set_args[i * KEYWORD_SET_SIZE + 1]),
GRN_TEXT_VALUE(keyword_set_args[i * KEYWORD_SET_SIZE + 2]),
GRN_TEXT_LEN(keyword_set_args[i * KEYWORD_SET_SIZE + 2]));
}
} else {
unsigned int n_keywords = n_args_without_option - N_REQUIRED_ARGS;
grn_obj **keyword_args = args + N_REQUIRED_ARGS;
for (i = 0; i < n_keywords; i++) {
rc = grn_snip_add_cond(ctx, snip,
GRN_TEXT_VALUE(keyword_args[i]),
GRN_TEXT_LEN(keyword_args[i]),
NULL, 0,
NULL, 0);
}
}
snippets = snippet_exec(ctx, snip, text, user_data,
prefix, prefix_length,
suffix, suffix_length);
}
}
#undef KEYWORD_SET_SIZE
#undef N_REQUIRED_ARGS
exit :
if (!snippets) {
snippets = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_VOID, 0);
}
return snippets;
}
static grn_obj *
create_lexicon_for_tokenize(grn_ctx *ctx,
grn_obj *tokenizer_name,
grn_obj *normalizer_name,
grn_obj *token_filter_names)
{
grn_obj *lexicon;
grn_obj *tokenizer;
grn_obj *normalizer = NULL;
tokenizer = grn_ctx_get(ctx,
GRN_TEXT_VALUE(tokenizer_name),
GRN_TEXT_LEN(tokenizer_name));
if (!tokenizer) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[tokenize] nonexistent tokenizer: <%.*s>",
(int)GRN_TEXT_LEN(tokenizer_name),
GRN_TEXT_VALUE(tokenizer_name));
return NULL;
}
if (!grn_obj_is_tokenizer_proc(ctx, tokenizer)) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, tokenizer);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[tokenize] not tokenizer: %.*s",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
grn_obj_unlink(ctx, tokenizer);
return NULL;
}
if (GRN_TEXT_LEN(normalizer_name) > 0) {
normalizer = grn_ctx_get(ctx,
GRN_TEXT_VALUE(normalizer_name),
GRN_TEXT_LEN(normalizer_name));
if (!normalizer) {
grn_obj_unlink(ctx, tokenizer);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[tokenize] nonexistent normalizer: <%.*s>",
(int)GRN_TEXT_LEN(normalizer_name),
GRN_TEXT_VALUE(normalizer_name));
return NULL;
}
if (!grn_obj_is_normalizer_proc(ctx, normalizer)) {
grn_obj inspected;
grn_obj_unlink(ctx, tokenizer);
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, normalizer);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[tokenize] not normalizer: %.*s",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
grn_obj_unlink(ctx, normalizer);
return NULL;
}
}
lexicon = grn_table_create(ctx, NULL, 0,
NULL,
GRN_OBJ_TABLE_HASH_KEY,
grn_ctx_at(ctx, GRN_DB_SHORT_TEXT),
NULL);
grn_obj_set_info(ctx, lexicon,
GRN_INFO_DEFAULT_TOKENIZER, tokenizer);
grn_obj_unlink(ctx, tokenizer);
if (normalizer) {
grn_obj_set_info(ctx, lexicon,
GRN_INFO_NORMALIZER, normalizer);
grn_obj_unlink(ctx, normalizer);
}
grn_proc_table_set_token_filters(ctx, lexicon, token_filter_names);
return lexicon;
}
