mrb_value grn_mrb_load(grn_ctx *ctx, const char *path) { grn_mrb_data *data = &(ctx->impl->mrb); mrb_state *mrb = data->state; char expanded_path[PATH_MAX]; FILE *file; mrb_value result; struct mrb_parser_state *parser; if (!mrb) { return mrb_nil_value(); } if (!grn_mrb_expand_script_path(ctx, path, expanded_path, PATH_MAX)) { return mrb_nil_value(); } file = grn_fopen(expanded_path, "r"); if (!file) { mrb_value exception; SERR("fopen: failed to open mruby script file: <%s>", expanded_path); exception = mrb_exc_new(mrb, E_LOAD_ERROR, ctx->errbuf, strlen(ctx->errbuf)); mrb->exc = mrb_obj_ptr(exception); return mrb_nil_value(); } { char current_base_directory[PATH_MAX]; char *last_directory; grn_strcpy(current_base_directory, PATH_MAX, data->base_directory); grn_strcpy(data->base_directory, PATH_MAX, expanded_path); last_directory = strrchr(data->base_directory, '/'); if (last_directory) { last_directory[0] = '\0'; } parser = mrb_parser_new(mrb); mrb_parser_set_filename(parser, expanded_path); parser->s = parser->send = NULL; parser->f = file; mrb_parser_parse(parser, NULL); fclose(file); { struct RProc *proc; proc = mrb_generate_code(mrb, parser); result = mrb_toplevel_run(mrb, proc); } mrb_parser_free(parser); grn_strcpy(data->base_directory, PATH_MAX, current_base_directory); } return result; }
void grn_ctx_impl_set_current_error_message(grn_ctx *ctx) { if (!ctx->impl) { return; } grn_ctx_impl_clear_n_same_error_messagges(ctx); grn_strcpy(ctx->impl->previous_errbuf, GRN_CTX_MSGSIZE, ctx->errbuf); }
static grn_bool grn_mrb_expand_script_path(grn_ctx *ctx, const char *path, char *expanded_path, size_t expanded_path_size) { const char *ruby_scripts_dir; char dir_last_char; int path_length, max_path_length; if (grn_mrb_is_absolute_path(path)) { expanded_path[0] = '\0'; } else if (path[0] == '.' && path[1] == '/') { grn_strcpy(expanded_path, expanded_path_size, ctx->impl->mrb.base_directory); grn_strcat(expanded_path, expanded_path_size, "/"); } else { ruby_scripts_dir = grn_mrb_get_system_ruby_scripts_dir(ctx); grn_strcpy(expanded_path, expanded_path_size, ruby_scripts_dir); dir_last_char = ruby_scripts_dir[strlen(expanded_path) - 1]; if (dir_last_char != '/') { grn_strcat(expanded_path, expanded_path_size, "/"); } } path_length = strlen(path); max_path_length = PATH_MAX - strlen(expanded_path) - 1; if (path_length > max_path_length) { ERR(GRN_INVALID_ARGUMENT, "script path is too long: %d (max: %d) <%s%s>", path_length, max_path_length, expanded_path, path); return GRN_FALSE; } grn_strcat(expanded_path, expanded_path_size, path); return GRN_TRUE; }
const char * get_system_synonyms_file(void) { if (win32_synonyms_file[0] == '\0') { const char *base_dir; const char *relative_path = GRN_QUERY_EXPANDER_TSV_RELATIVE_SYNONYMS_FILE; size_t base_dir_length; base_dir = grn_plugin_windows_base_dir(); base_dir_length = strlen(base_dir); grn_strcpy(win32_synonyms_file, MAX_PATH, base_dir); grn_strcat(win32_synonyms_file, MAX_PATH, "/"); grn_strcat(win32_synonyms_file, MAX_PATH, relative_path); } return win32_synonyms_file; }
static const char * grn_mrb_get_default_system_ruby_scripts_dir(void) { if (!windows_ruby_scripts_dir) { const char *base_dir; const char *relative_path = GRN_RELATIVE_RUBY_SCRIPTS_DIR; size_t base_dir_length; base_dir = grn_windows_base_dir(); base_dir_length = strlen(base_dir); grn_strcpy(windows_ruby_scripts_dir_buffer, PATH_MAX, base_dir); grn_strcat(windows_ruby_scripts_dir_buffer, PATH_MAX, "/"); grn_strcat(windows_ruby_scripts_dir_buffer, PATH_MAX, relative_path); windows_ruby_scripts_dir = windows_ruby_scripts_dir_buffer; } return windows_ruby_scripts_dir; }
mrb_value grn_mrb_value_from_bulk(mrb_state *mrb, grn_obj *bulk) { mrb_value mrb_value_; grn_ctx *ctx = (grn_ctx *)mrb->ud; switch (bulk->header.domain) { case GRN_DB_INT32 : { int32_t value; value = GRN_INT32_VALUE(bulk); mrb_value_ = mrb_fixnum_value(value); } break; case GRN_DB_UINT32 : { int64_t value; value = GRN_UINT32_VALUE(bulk); if (!FIXABLE(value)) { mrb_raisef(mrb, E_RANGE_ERROR, "can't handle large number: <%S>: max: <%S>", mrb_fixnum_value(value), /* TODO: This will cause overflow */ mrb_fixnum_value(MRB_INT_MAX)); } mrb_value_ = mrb_fixnum_value(value); } break; case GRN_DB_TIME : { int64_t value; int32_t sec; int32_t usec; value = GRN_TIME_VALUE(bulk); GRN_TIME_UNPACK(value, sec, usec); mrb_value_ = mrb_funcall(mrb, mrb_obj_value(ctx->impl->mrb.builtin.time_class), "at", 2, mrb_fixnum_value(sec), mrb_fixnum_value(usec)); } break; case GRN_DB_SHORT_TEXT : case GRN_DB_TEXT : case GRN_DB_LONG_TEXT : mrb_value_ = mrb_str_new(mrb, GRN_TEXT_VALUE(bulk), GRN_TEXT_LEN(bulk)); break; default : { grn_obj *domain; grn_bool is_record = GRN_FALSE; domain = grn_ctx_at(ctx, bulk->header.domain); if (domain) { switch (domain->header.type) { case GRN_TABLE_HASH_KEY : case GRN_TABLE_PAT_KEY : case GRN_TABLE_DAT_KEY : case GRN_TABLE_NO_KEY : is_record = GRN_TRUE; break; default : break; } } if (is_record) { mrb_value_ = mrb_fixnum_value(GRN_RECORD_VALUE(bulk)); grn_obj_unlink(ctx, domain); } else { #define MESSAGE_SIZE 4096 char message[MESSAGE_SIZE]; char domain_name[GRN_TABLE_MAX_KEY_SIZE]; int domain_name_size; if (domain) { domain_name_size = grn_obj_name(ctx, domain, domain_name, GRN_TABLE_MAX_KEY_SIZE); grn_obj_unlink(ctx, domain); } else { grn_strcpy(domain_name, GRN_TABLE_MAX_KEY_SIZE, "unknown"); domain_name_size = strlen(domain_name); } grn_snprintf(message, MESSAGE_SIZE, MESSAGE_SIZE, "unsupported bulk value type: <%d>(%.*s)", bulk->header.domain, domain_name_size, domain_name); mrb_raise(mrb, E_RANGE_ERROR, message); } #undef MESSAGE_SIZE } break; } return mrb_value_; }
static void grn_loader_save_error(grn_ctx *ctx, grn_loader *loader) { loader->rc = ctx->rc; grn_strcpy(loader->errbuf, GRN_CTX_MSGSIZE, ctx->errbuf); }
static void command_schema_column_command_collect_arguments(grn_ctx *ctx, grn_obj *table, grn_obj *column, grn_obj *arguments) { #define ADD(name_, value_) \ grn_vector_add_element(ctx, arguments, \ name_, strlen(name_), \ 0, GRN_DB_TEXT); \ grn_vector_add_element(ctx, arguments, \ value_, strlen(value_), \ 0, GRN_DB_TEXT) #define ADD_OBJECT_NAME(name_, object_) do { \ char object_name[GRN_TABLE_MAX_KEY_SIZE]; \ unsigned int object_name_size; \ object_name_size = grn_obj_name(ctx, object_, \ object_name, \ GRN_TABLE_MAX_KEY_SIZE); \ object_name[object_name_size] = '\0'; \ ADD(name_, object_name); \ } while (GRN_FALSE) ADD_OBJECT_NAME("table", table); { char column_name[GRN_TABLE_MAX_KEY_SIZE]; unsigned int column_name_size; column_name_size = grn_column_name(ctx, column, column_name, GRN_TABLE_MAX_KEY_SIZE); column_name[column_name_size] = '\0'; ADD("name", column_name); } { grn_obj flags; GRN_TEXT_INIT(&flags, 0); grn_dump_column_create_flags(ctx, column->header.flags & ~GRN_OBJ_PERSISTENT, &flags); GRN_TEXT_PUTC(ctx, &flags, '\0'); ADD("flags", GRN_TEXT_VALUE(&flags)); GRN_OBJ_FIN(ctx, &flags); } { grn_obj *value_type; value_type = grn_ctx_at(ctx, grn_obj_get_range(ctx, column)); ADD_OBJECT_NAME("type", value_type); } if (column->header.type == GRN_COLUMN_INDEX) { grn_obj source_ids; unsigned int n_ids; GRN_RECORD_INIT(&source_ids, GRN_OBJ_VECTOR, GRN_ID_NIL); grn_obj_get_info(ctx, column, GRN_INFO_SOURCE, &source_ids); n_ids = GRN_BULK_VSIZE(&source_ids) / sizeof(grn_id); if (n_ids > 0) { grn_obj sources; unsigned int i; GRN_TEXT_INIT(&sources, 0); for (i = 0; i < n_ids; i++) { grn_id source_id; grn_obj *source; char name[GRN_TABLE_MAX_KEY_SIZE]; unsigned int name_size; source_id = GRN_RECORD_VALUE_AT(&source_ids, i); source = grn_ctx_at(ctx, source_id); if (grn_obj_is_table(ctx, source)) { grn_strcpy(name, GRN_TABLE_MAX_KEY_SIZE, "_key"); name_size = strlen(name); } else { name_size = grn_column_name(ctx, source, name, GRN_TABLE_MAX_KEY_SIZE); } if (i > 0) { GRN_TEXT_PUTC(ctx, &sources, ','); } GRN_TEXT_PUT(ctx, &sources, name, name_size); } GRN_TEXT_PUTC(ctx, &sources, '\0'); ADD("sources", GRN_TEXT_VALUE(&sources)); GRN_OBJ_FIN(ctx, &sources); } GRN_OBJ_FIN(ctx, &source_ids); } #undef ADD_OBJECT_NAME #undef ADD }