/* automatically generated by rust-bindgen */

#![allow(dead_code,
         non_camel_case_types,
         non_upper_case_globals,
         non_snake_case)]
pub type int8_t = i8;
pub type int16_t = i16;
pub type int32_t = i32;
pub type int64_t = i64;
pub type uint8_t = u8;
pub type uint16_t = u16;
pub type uint32_t = u32;
pub type uint64_t = u64;
pub type size_t = usize;
pub type __off_t = ::std::os::raw::c_long;
pub type off_t = __off_t;

pub type grn_id = ::std::os::raw::c_uint;
pub type grn_bool = uint8_t;
#[derive(Copy, Clone, PartialEq, Eq)]
#[repr(i32)]
#[derive(Debug)]
pub enum grn_rc {
    GRN_SUCCESS = 0,
    GRN_END_OF_DATA = 1,
    GRN_UNKNOWN_ERROR = -1,
    GRN_OPERATION_NOT_PERMITTED = -2,
    GRN_NO_SUCH_FILE_OR_DIRECTORY = -3,
    GRN_NO_SUCH_PROCESS = -4,
    GRN_INTERRUPTED_FUNCTION_CALL = -5,
    GRN_INPUT_OUTPUT_ERROR = -6,
    GRN_NO_SUCH_DEVICE_OR_ADDRESS = -7,
    GRN_ARG_LIST_TOO_LONG = -8,
    GRN_EXEC_FORMAT_ERROR = -9,
    GRN_BAD_FILE_DESCRIPTOR = -10,
    GRN_NO_CHILD_PROCESSES = -11,
    GRN_RESOURCE_TEMPORARILY_UNAVAILABLE = -12,
    GRN_NOT_ENOUGH_SPACE = -13,
    GRN_PERMISSION_DENIED = -14,
    GRN_BAD_ADDRESS = -15,
    GRN_RESOURCE_BUSY = -16,
    GRN_FILE_EXISTS = -17,
    GRN_IMPROPER_LINK = -18,
    GRN_NO_SUCH_DEVICE = -19,
    GRN_NOT_A_DIRECTORY = -20,
    GRN_IS_A_DIRECTORY = -21,
    GRN_INVALID_ARGUMENT = -22,
    GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM = -23,
    GRN_TOO_MANY_OPEN_FILES = -24,
    GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION = -25,
    GRN_FILE_TOO_LARGE = -26,
    GRN_NO_SPACE_LEFT_ON_DEVICE = -27,
    GRN_INVALID_SEEK = -28,
    GRN_READ_ONLY_FILE_SYSTEM = -29,
    GRN_TOO_MANY_LINKS = -30,
    GRN_BROKEN_PIPE = -31,
    GRN_DOMAIN_ERROR = -32,
    GRN_RESULT_TOO_LARGE = -33,
    GRN_RESOURCE_DEADLOCK_AVOIDED = -34,
    GRN_NO_MEMORY_AVAILABLE = -35,
    GRN_FILENAME_TOO_LONG = -36,
    GRN_NO_LOCKS_AVAILABLE = -37,
    GRN_FUNCTION_NOT_IMPLEMENTED = -38,
    GRN_DIRECTORY_NOT_EMPTY = -39,
    GRN_ILLEGAL_BYTE_SEQUENCE = -40,
    GRN_SOCKET_NOT_INITIALIZED = -41,
    GRN_OPERATION_WOULD_BLOCK = -42,
    GRN_ADDRESS_IS_NOT_AVAILABLE = -43,
    GRN_NETWORK_IS_DOWN = -44,
    GRN_NO_BUFFER = -45,
    GRN_SOCKET_IS_ALREADY_CONNECTED = -46,
    GRN_SOCKET_IS_NOT_CONNECTED = -47,
    GRN_SOCKET_IS_ALREADY_SHUTDOWNED = -48,
    GRN_OPERATION_TIMEOUT = -49,
    GRN_CONNECTION_REFUSED = -50,
    GRN_RANGE_ERROR = -51,
    GRN_TOKENIZER_ERROR = -52,
    GRN_FILE_CORRUPT = -53,
    GRN_INVALID_FORMAT = -54,
    GRN_OBJECT_CORRUPT = -55,
    GRN_TOO_MANY_SYMBOLIC_LINKS = -56,
    GRN_NOT_SOCKET = -57,
    GRN_OPERATION_NOT_SUPPORTED = -58,
    GRN_ADDRESS_IS_IN_USE = -59,
    GRN_ZLIB_ERROR = -60,
    GRN_LZ4_ERROR = -61,
    GRN_STACK_OVER_FLOW = -62,
    GRN_SYNTAX_ERROR = -63,
    GRN_RETRY_MAX = -64,
    GRN_INCOMPATIBLE_FILE_FORMAT = -65,
    GRN_UPDATE_NOT_ALLOWED = -66,
    GRN_TOO_SMALL_OFFSET = -67,
    GRN_TOO_LARGE_OFFSET = -68,
    GRN_TOO_SMALL_LIMIT = -69,
    GRN_CAS_ERROR = -70,
    GRN_UNSUPPORTED_COMMAND_VERSION = -71,
    GRN_NORMALIZER_ERROR = -72,
    GRN_TOKEN_FILTER_ERROR = -73,
    GRN_COMMAND_ERROR = -74,
    GRN_PLUGIN_ERROR = -75,
    GRN_SCORER_ERROR = -76,
    GRN_CANCEL = -77,
    GRN_WINDOW_FUNCTION_ERROR = -78,
}
#[derive(Copy, Clone, PartialEq, Eq)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_encoding {
    GRN_ENC_DEFAULT = 0,
    GRN_ENC_NONE = 1,
    GRN_ENC_EUC_JP = 2,
    GRN_ENC_UTF8 = 3,
    GRN_ENC_SJIS = 4,
    GRN_ENC_LATIN1 = 5,
    GRN_ENC_KOI8R = 6,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_command_version {
    GRN_COMMAND_VERSION_DEFAULT = 0,
    GRN_COMMAND_VERSION_1 = 1,
    GRN_COMMAND_VERSION_2 = 2,
    GRN_COMMAND_VERSION_3 = 3,
}
#[derive(Copy, Clone, PartialEq, Eq)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_log_level {
    GRN_LOG_NONE = 0,
    GRN_LOG_EMERG = 1,
    GRN_LOG_ALERT = 2,
    GRN_LOG_CRIT = 3,
    GRN_LOG_ERROR = 4,
    GRN_LOG_WARNING = 5,
    GRN_LOG_NOTICE = 6,
    GRN_LOG_INFO = 7,
    GRN_LOG_DEBUG = 8,
    GRN_LOG_DUMP = 9,
}
#[derive(Copy, Clone, PartialEq, Eq)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_content_type {
    GRN_CONTENT_NONE = 0,
    GRN_CONTENT_TSV = 1,
    GRN_CONTENT_JSON = 2,
    GRN_CONTENT_XML = 3,
    GRN_CONTENT_MSGPACK = 4,
    GRN_CONTENT_GROONGA_COMMAND_LIST = 5,
}
pub type grn_obj = _grn_obj;
pub type grn_ctx = _grn_ctx;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct grn_user_data {
    pub _bindgen_data_: [u64; 1usize],
}
impl grn_user_data {
    pub unsafe fn int_value(&mut self) -> *mut ::std::os::raw::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn id(&mut self) -> *mut grn_id {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn ptr(&mut self) -> *mut *mut ::std::os::raw::c_void {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::default::Default for grn_user_data {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_proc_func =
    ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                               nargs: ::std::os::raw::c_int,
                                               args: *mut *mut grn_obj,
                                               user_data: *mut grn_user_data)
                              -> *mut grn_obj>;
pub enum _grn_ctx_impl { }
#[repr(C)]
#[derive(Copy)]
pub struct _grn_ctx {
    pub rc: grn_rc,
    pub flags: ::std::os::raw::c_int,
    pub encoding: grn_encoding,
    pub ntrace: ::std::os::raw::c_uchar,
    pub errlvl: ::std::os::raw::c_uchar,
    pub stat: ::std::os::raw::c_uchar,
    pub seqno: ::std::os::raw::c_uint,
    pub subno: ::std::os::raw::c_uint,
    pub seqno2: ::std::os::raw::c_uint,
    pub errline: ::std::os::raw::c_uint,
    pub user_data: grn_user_data,
    pub prev: *mut grn_ctx,
    pub next: *mut grn_ctx,
    pub errfile: *const ::std::os::raw::c_char,
    pub errfunc: *const ::std::os::raw::c_char,
    pub impl_: *mut _grn_ctx_impl,
    pub trace: [*mut ::std::os::raw::c_void; 16usize],
    pub errbuf: [::std::os::raw::c_char; 128usize],
}
impl ::std::clone::Clone for _grn_ctx {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for _grn_ctx {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum _grn_cache { }
pub type grn_cache = _grn_cache;
pub type grn_obj_flags = uint16_t;
pub type grn_table_flags = uint32_t;
pub type grn_column_flags = uint32_t;
pub type grn_section = _grn_section;
pub type grn_obj_header = _grn_obj_header;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_section {
    pub offset: ::std::os::raw::c_uint,
    pub length: ::std::os::raw::c_uint,
    pub weight: ::std::os::raw::c_uint,
    pub domain: grn_id,
}
impl ::std::default::Default for _grn_section {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_obj_header {
    pub type_: ::std::os::raw::c_uchar,
    pub impl_flags: ::std::os::raw::c_uchar,
    pub flags: grn_obj_flags,
    pub domain: grn_id,
}
impl ::std::default::Default for _grn_obj_header {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_obj {
    pub header: grn_obj_header,
    pub u: Union_Unnamed3,
}
impl ::std::default::Default for _grn_obj {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Union_Unnamed3 {
    pub _bindgen_data_: [u64; 3usize],
}
impl Union_Unnamed3 {
    pub unsafe fn b(&mut self) -> *mut Struct_Unnamed4 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v(&mut self) -> *mut Struct_Unnamed5 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::default::Default for Union_Unnamed3 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed4 {
    pub head: *mut ::std::os::raw::c_char,
    pub curr: *mut ::std::os::raw::c_char,
    pub tail: *mut ::std::os::raw::c_char,
}
impl ::std::default::Default for Struct_Unnamed4 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed5 {
    pub body: *mut grn_obj,
    pub sections: *mut grn_section,
    pub n_sections: ::std::os::raw::c_int,
}
impl ::std::default::Default for Struct_Unnamed5 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[derive(Copy, Clone, PartialEq, Eq)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_builtin_type {
    GRN_DB_VOID = 0,
    GRN_DB_DB = 1,
    GRN_DB_OBJECT = 2,
    GRN_DB_BOOL = 3,
    GRN_DB_INT8 = 4,
    GRN_DB_UINT8 = 5,
    GRN_DB_INT16 = 6,
    GRN_DB_UINT16 = 7,
    GRN_DB_INT32 = 8,
    GRN_DB_UINT32 = 9,
    GRN_DB_INT64 = 10,
    GRN_DB_UINT64 = 11,
    GRN_DB_FLOAT = 12,
    GRN_DB_TIME = 13,
    GRN_DB_SHORT_TEXT = 14,
    GRN_DB_TEXT = 15,
    GRN_DB_LONG_TEXT = 16,
    GRN_DB_TOKYO_GEO_POINT = 17,
    GRN_DB_WGS84_GEO_POINT = 18,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_builtin_tokenizer {
    GRN_DB_MECAB = 64,
    GRN_DB_DELIMIT = 65,
    GRN_DB_UNIGRAM = 66,
    GRN_DB_BIGRAM = 67,
    GRN_DB_TRIGRAM = 68,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct grn_expr_var {
    pub name: *const ::std::os::raw::c_char,
    pub name_size: ::std::os::raw::c_uint,
    pub value: grn_obj,
}
impl ::std::default::Default for grn_expr_var {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_plugin_func =
    ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx) -> grn_rc>;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_proc_type {
    GRN_PROC_INVALID = 0,
    GRN_PROC_TOKENIZER = 1,
    GRN_PROC_COMMAND = 2,
    GRN_PROC_FUNCTION = 3,
    GRN_PROC_HOOK = 4,
    GRN_PROC_NORMALIZER = 5,
    GRN_PROC_TOKEN_FILTER = 6,
    GRN_PROC_SCORER = 7,
    GRN_PROC_WINDOW_FUNCTION = 8,
}
pub type grn_table_cursor = grn_obj;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct grn_posting {
    pub rid: grn_id,
    pub sid: uint32_t,
    pub pos: uint32_t,
    pub tf: uint32_t,
    pub weight: uint32_t,
    pub rest: uint32_t,
}
impl ::std::default::Default for grn_posting {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[derive(Copy, Clone, PartialEq, Eq)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_operator {
    GRN_OP_PUSH = 0,
    GRN_OP_POP = 1,
    GRN_OP_NOP = 2,
    GRN_OP_CALL = 3,
    GRN_OP_INTERN = 4,
    GRN_OP_GET_REF = 5,
    GRN_OP_GET_VALUE = 6,
    GRN_OP_AND = 7,
    GRN_OP_AND_NOT = 8,
    GRN_OP_OR = 9,
    GRN_OP_ASSIGN = 10,
    GRN_OP_STAR_ASSIGN = 11,
    GRN_OP_SLASH_ASSIGN = 12,
    GRN_OP_MOD_ASSIGN = 13,
    GRN_OP_PLUS_ASSIGN = 14,
    GRN_OP_MINUS_ASSIGN = 15,
    GRN_OP_SHIFTL_ASSIGN = 16,
    GRN_OP_SHIFTR_ASSIGN = 17,
    GRN_OP_SHIFTRR_ASSIGN = 18,
    GRN_OP_AND_ASSIGN = 19,
    GRN_OP_XOR_ASSIGN = 20,
    GRN_OP_OR_ASSIGN = 21,
    GRN_OP_JUMP = 22,
    GRN_OP_CJUMP = 23,
    GRN_OP_COMMA = 24,
    GRN_OP_BITWISE_OR = 25,
    GRN_OP_BITWISE_XOR = 26,
    GRN_OP_BITWISE_AND = 27,
    GRN_OP_BITWISE_NOT = 28,
    GRN_OP_EQUAL = 29,
    GRN_OP_NOT_EQUAL = 30,
    GRN_OP_LESS = 31,
    GRN_OP_GREATER = 32,
    GRN_OP_LESS_EQUAL = 33,
    GRN_OP_GREATER_EQUAL = 34,
    GRN_OP_IN = 35,
    GRN_OP_MATCH = 36,
    GRN_OP_NEAR = 37,
    GRN_OP_NEAR2 = 38,
    GRN_OP_SIMILAR = 39,
    GRN_OP_TERM_EXTRACT = 40,
    GRN_OP_SHIFTL = 41,
    GRN_OP_SHIFTR = 42,
    GRN_OP_SHIFTRR = 43,
    GRN_OP_PLUS = 44,
    GRN_OP_MINUS = 45,
    GRN_OP_STAR = 46,
    GRN_OP_SLASH = 47,
    GRN_OP_MOD = 48,
    GRN_OP_DELETE = 49,
    GRN_OP_INCR = 50,
    GRN_OP_DECR = 51,
    GRN_OP_INCR_POST = 52,
    GRN_OP_DECR_POST = 53,
    GRN_OP_NOT = 54,
    GRN_OP_ADJUST = 55,
    GRN_OP_EXACT = 56,
    GRN_OP_LCP = 57,
    GRN_OP_PARTIAL = 58,
    GRN_OP_UNSPLIT = 59,
    GRN_OP_PREFIX = 60,
    GRN_OP_SUFFIX = 61,
    GRN_OP_GEO_DISTANCE1 = 62,
    GRN_OP_GEO_DISTANCE2 = 63,
    GRN_OP_GEO_DISTANCE3 = 64,
    GRN_OP_GEO_DISTANCE4 = 65,
    GRN_OP_GEO_WITHINP5 = 66,
    GRN_OP_GEO_WITHINP6 = 67,
    GRN_OP_GEO_WITHINP8 = 68,
    GRN_OP_OBJ_SEARCH = 69,
    GRN_OP_EXPR_GET_VAR = 70,
    GRN_OP_TABLE_CREATE = 71,
    GRN_OP_TABLE_SELECT = 72,
    GRN_OP_TABLE_SORT = 73,
    GRN_OP_TABLE_GROUP = 74,
    GRN_OP_JSON_PUT = 75,
    GRN_OP_GET_MEMBER = 76,
    GRN_OP_REGEXP = 77,
    GRN_OP_FUZZY = 78,
}
#[derive(Copy, Clone, PartialEq, Eq)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_info_type {
    GRN_INFO_ENCODING = 0,
    GRN_INFO_SOURCE = 1,
    GRN_INFO_DEFAULT_TOKENIZER = 2,
    GRN_INFO_ELEMENT_SIZE = 3,
    GRN_INFO_CURR_MAX = 4,
    GRN_INFO_MAX_ELEMENT_SIZE = 5,
    GRN_INFO_SEG_SIZE = 6,
    GRN_INFO_CHUNK_SIZE = 7,
    GRN_INFO_MAX_SECTION = 8,
    GRN_INFO_HOOK_LOCAL_DATA = 9,
    GRN_INFO_ELEMENT_A = 10,
    GRN_INFO_ELEMENT_CHUNK = 11,
    GRN_INFO_ELEMENT_CHUNK_SIZE = 12,
    GRN_INFO_ELEMENT_BUFFER_FREE = 13,
    GRN_INFO_ELEMENT_NTERMS = 14,
    GRN_INFO_ELEMENT_NTERMS_VOID = 15,
    GRN_INFO_ELEMENT_SIZE_IN_CHUNK = 16,
    GRN_INFO_ELEMENT_POS_IN_CHUNK = 17,
    GRN_INFO_ELEMENT_SIZE_IN_BUFFER = 18,
    GRN_INFO_ELEMENT_POS_IN_BUFFER = 19,
    GRN_INFO_ELEMENT_ESTIMATE_SIZE = 20,
    GRN_INFO_NGRAM_UNIT_SIZE = 21,
    GRN_INFO_PARTIAL_MATCH_THRESHOLD = 22,
    GRN_INFO_II_SPLIT_THRESHOLD = 23,
    GRN_INFO_SUPPORT_ZLIB = 24,
    GRN_INFO_SUPPORT_LZ4 = 25,
    GRN_INFO_NORMALIZER = 26,
    GRN_INFO_TOKEN_FILTERS = 27,
}
pub type grn_fuzzy_search_optarg = _grn_fuzzy_search_optarg;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_fuzzy_search_optarg {
    pub max_distance: ::std::os::raw::c_uint,
    pub max_expansion: ::std::os::raw::c_uint,
    pub prefix_match_size: ::std::os::raw::c_uint,
    pub flags: ::std::os::raw::c_int,
}
impl ::std::default::Default for _grn_fuzzy_search_optarg {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_search_optarg = _grn_search_optarg;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_search_optarg {
    pub mode: grn_operator,
    pub similarity_threshold: ::std::os::raw::c_int,
    pub max_interval: ::std::os::raw::c_int,
    pub weight_vector: *mut ::std::os::raw::c_int,
    pub vector_size: ::std::os::raw::c_int,
    pub proc_: *mut grn_obj,
    pub max_size: ::std::os::raw::c_int,
    pub scorer: *mut grn_obj,
    pub scorer_args_expr: *mut grn_obj,
    pub scorer_args_expr_offset: ::std::os::raw::c_uint,
    pub fuzzy: grn_fuzzy_search_optarg,
}
impl ::std::default::Default for _grn_search_optarg {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_selector_func =
    ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                               table: *mut grn_obj,
                                               index: *mut grn_obj,
                                               nargs: ::std::os::raw::c_int,
                                               args: *mut *mut grn_obj,
                                               res: *mut grn_obj,
                                               op: grn_operator) -> grn_rc>;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_hook_entry {
    GRN_HOOK_SET = 0,
    GRN_HOOK_GET = 1,
    GRN_HOOK_INSERT = 2,
    GRN_HOOK_DELETE = 3,
    GRN_HOOK_SELECT = 4,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_index_datum {
    pub index: *mut grn_obj,
    pub section: ::std::os::raw::c_uint,
}
impl ::std::default::Default for _grn_index_datum {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_index_datum = _grn_index_datum;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct grn_geo_point {
    pub latitude: ::std::os::raw::c_int,
    pub longitude: ::std::os::raw::c_int,
}
impl ::std::default::Default for grn_geo_point {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_snip_mapping = _grn_snip_mapping;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_snip_mapping {
    pub dummy: *mut ::std::os::raw::c_void,
}
impl ::std::default::Default for _grn_snip_mapping {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_logger_info = _grn_logger_info;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_logger_info {
    pub max_level: grn_log_level,
    pub flags: ::std::os::raw::c_int,
    pub func: ::std::option::Option<unsafe extern "C" fn(arg1:
                                                             ::std::os::raw::c_int,
                                                         arg2:
                                                             *const ::std::os::raw::c_char,
                                                         arg3:
                                                             *const ::std::os::raw::c_char,
                                                         arg4:
                                                             *const ::std::os::raw::c_char,
                                                         arg5:
                                                             *const ::std::os::raw::c_char,
                                                         arg6:
                                                             *mut ::std::os::raw::c_void)>,
    pub func_arg: *mut ::std::os::raw::c_void,
}
impl ::std::default::Default for _grn_logger_info {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_logger = _grn_logger;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_logger {
    pub max_level: grn_log_level,
    pub flags: ::std::os::raw::c_int,
    pub user_data: *mut ::std::os::raw::c_void,
    pub log: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                                        level: grn_log_level,
                                                        timestamp:
                                                            *const ::std::os::raw::c_char,
                                                        title:
                                                            *const ::std::os::raw::c_char,
                                                        message:
                                                            *const ::std::os::raw::c_char,
                                                        location:
                                                            *const ::std::os::raw::c_char,
                                                        user_data:
                                                            *mut ::std::os::raw::c_void)>,
    pub reopen: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                                           user_data:
                                                               *mut ::std::os::raw::c_void)>,
    pub fin: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                                        user_data:
                                                            *mut ::std::os::raw::c_void)>,
}
impl ::std::default::Default for _grn_logger {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_query_logger = _grn_query_logger;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_query_logger {
    pub flags: ::std::os::raw::c_uint,
    pub user_data: *mut ::std::os::raw::c_void,
    pub log: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                                        flag:
                                                            ::std::os::raw::c_uint,
                                                        timestamp:
                                                            *const ::std::os::raw::c_char,
                                                        info:
                                                            *const ::std::os::raw::c_char,
                                                        message:
                                                            *const ::std::os::raw::c_char,
                                                        user_data:
                                                            *mut ::std::os::raw::c_void)>,
    pub reopen: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                                           user_data:
                                                               *mut ::std::os::raw::c_void)>,
    pub fin: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                                        user_data:
                                                            *mut ::std::os::raw::c_void)>,
}
impl ::std::default::Default for _grn_query_logger {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct grn_str {
    pub orig: *const ::std::os::raw::c_char,
    pub norm: *mut ::std::os::raw::c_char,
    pub checks: *mut ::std::os::raw::c_short,
    pub ctypes: *mut ::std::os::raw::c_uchar,
    pub flags: ::std::os::raw::c_int,
    pub orig_blen: ::std::os::raw::c_uint,
    pub norm_blen: ::std::os::raw::c_uint,
    pub length: ::std::os::raw::c_uint,
    pub encoding: grn_encoding,
}
impl ::std::default::Default for grn_str {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[derive(Copy, Clone, PartialEq, Eq)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_char_type {
    GRN_CHAR_NULL = 0,
    GRN_CHAR_ALPHA = 1,
    GRN_CHAR_DIGIT = 2,
    GRN_CHAR_SYMBOL = 3,
    GRN_CHAR_HIRAGANA = 4,
    GRN_CHAR_KATAKANA = 5,
    GRN_CHAR_KANJI = 6,
    GRN_CHAR_OTHERS = 7,
}
pub type grn_ctx_info = _grn_ctx_info;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_ctx_info {
    pub fd: ::std::os::raw::c_int,
    pub com_status: ::std::os::raw::c_uint,
    pub outbuf: *mut grn_obj,
    pub stat: ::std::os::raw::c_uchar,
}
impl ::std::default::Default for _grn_ctx_info {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_table_delete_optarg = _grn_table_delete_optarg;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_table_delete_optarg {
    pub flags: ::std::os::raw::c_int,
    pub func: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                                         arg1: *mut grn_obj,
                                                         arg2: grn_id,
                                                         arg3:
                                                             *mut ::std::os::raw::c_void)
                                        -> ::std::os::raw::c_int>,
    pub func_arg: *mut ::std::os::raw::c_void,
}
impl ::std::default::Default for _grn_table_delete_optarg {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_table_scan_hit {
    pub id: grn_id,
    pub offset: ::std::os::raw::c_uint,
    pub length: ::std::os::raw::c_uint,
}
impl ::std::default::Default for _grn_table_scan_hit {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct grn_timeval {
    pub tv_sec: int64_t,
    pub tv_nsec: int32_t,
}
impl ::std::default::Default for grn_timeval {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum _grn_array { }
pub type grn_array = _grn_array;
pub enum _grn_array_cursor { }
pub type grn_array_cursor = _grn_array_cursor;
pub enum _grn_dat { }
pub type grn_dat = _grn_dat;
pub enum _grn_dat_cursor { }
pub type grn_dat_cursor = _grn_dat_cursor;
pub type grn_dat_scan_hit = _grn_table_scan_hit;
pub type grn_db_create_optarg = _grn_db_create_optarg;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_db_create_optarg {
    pub builtin_type_names: *mut *mut ::std::os::raw::c_char,
    pub n_builtin_type_names: ::std::os::raw::c_int,
}
impl ::std::default::Default for _grn_db_create_optarg {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_expr_flags = ::std::os::raw::c_uint;
pub enum _grn_file_reader { }
pub type grn_file_reader = _grn_file_reader;
pub enum _grn_hash { }
pub type grn_hash = _grn_hash;
pub enum _grn_hash_cursor { }
pub type grn_hash_cursor = _grn_hash_cursor;
pub enum _grn_ii { }
pub type grn_ii = _grn_ii;
pub enum _grn_ii_buffer { }
pub type grn_ii_buffer = _grn_ii_buffer;
pub enum _grn_ii_cursor { }
pub type grn_ii_cursor = _grn_ii_cursor;
pub type grn_operator_exec_func =
    ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                               x: *mut grn_obj,
                                               y: *mut grn_obj) -> grn_bool>;
pub type grn_obj_format = _grn_obj_format;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_obj_format {
    pub columns: grn_obj,
    pub min: *const ::std::os::raw::c_void,
    pub max: *const ::std::os::raw::c_void,
    pub min_size: ::std::os::raw::c_uint,
    pub max_size: ::std::os::raw::c_uint,
    pub nhits: ::std::os::raw::c_int,
    pub offset: ::std::os::raw::c_int,
    pub limit: ::std::os::raw::c_int,
    pub hits_offset: ::std::os::raw::c_int,
    pub flags: ::std::os::raw::c_int,
    pub expression: *mut grn_obj,
}
impl ::std::default::Default for _grn_obj_format {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum _grn_pat { }
pub type grn_pat = _grn_pat;
pub enum _grn_pat_cursor { }
pub type grn_pat_cursor = _grn_pat_cursor;
pub type grn_pat_scan_hit = _grn_table_scan_hit;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_request_timer {
    pub user_data: *mut ::std::os::raw::c_void,
    pub register_func: ::std::option::Option<unsafe extern "C" fn(request_id:
                                                                      *const ::std::os::raw::c_char,
                                                                  request_id_size:
                                                                      ::std::os::raw::c_uint,
                                                                  timeout:
                                                                      f64,
                                                                  user_data:
                                                                      *mut ::std::os::raw::c_void)
                                                 ->
                                                     *mut ::std::os::raw::c_void>,
    pub unregister_func: ::std::option::Option<unsafe extern "C" fn(timer_id:
                                                                        *mut ::std::os::raw::c_void,
                                                                    user_data:
                                                                        *mut ::std::os::raw::c_void)>,
    pub fin_func: ::std::option::Option<unsafe extern "C" fn(user_data:
                                                                 *mut ::std::os::raw::c_void)>,
}
impl ::std::default::Default for _grn_request_timer {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_request_timer = _grn_request_timer;
pub type grn_table_sort_key = _grn_table_sort_key;
pub type grn_table_sort_flags = ::std::os::raw::c_uchar;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_table_sort_key {
    pub key: *mut grn_obj,
    pub flags: grn_table_sort_flags,
    pub offset: ::std::os::raw::c_int,
}
impl ::std::default::Default for _grn_table_sort_key {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_table_group_result = _grn_table_group_result;
pub type grn_table_group_flags = uint32_t;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_table_group_result {
    pub table: *mut grn_obj,
    pub key_begin: ::std::os::raw::c_uchar,
    pub key_end: ::std::os::raw::c_uchar,
    pub limit: ::std::os::raw::c_int,
    pub flags: grn_table_group_flags,
    pub op: grn_operator,
    pub max_n_subrecs: ::std::os::raw::c_uint,
    pub calc_target: *mut grn_obj,
}
impl ::std::default::Default for _grn_table_group_result {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_thread_get_limit_func =
    ::std::option::Option<unsafe extern "C" fn(data:
                                                   *mut ::std::os::raw::c_void)
                              -> uint32_t>;
pub type grn_thread_set_limit_func =
    ::std::option::Option<unsafe extern "C" fn(new_limit: uint32_t,
                                               data:
                                                   *mut ::std::os::raw::c_void)>;
pub enum sigevent { }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum grn_window_direction {
    GRN_WINDOW_DIRECTION_ASCENDING = 0,
    GRN_WINDOW_DIRECTION_DESCENDING = 1,
}
pub enum _grn_window { }
pub type grn_window = _grn_window;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _grn_window_definition {
    pub sort_keys: *mut grn_table_sort_key,
    pub n_sort_keys: size_t,
}
impl ::std::default::Default for _grn_window_definition {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type grn_window_definition = _grn_window_definition;
pub type grn_window_function_func =
    ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
                                               output_column: *mut grn_obj,
                                               window: *mut grn_window,
                                               args: *mut grn_obj,
                                               n_args: ::std::os::raw::c_int)
                              -> grn_rc>;
#[link(name = "groonga", kind = "dylib")]
extern "C" {
    pub fn grn_init() -> grn_rc;
    pub fn grn_fin() -> grn_rc;
    pub fn grn_get_global_error_message() -> *const ::std::os::raw::c_char;
    pub fn grn_log_level_to_string(level: grn_log_level)
     -> *const ::std::os::raw::c_char;
    pub fn grn_log_level_parse(string: *const ::std::os::raw::c_char,
                               level: *mut grn_log_level) -> grn_bool;
    pub fn grn_ctx_init(ctx: *mut grn_ctx, flags: ::std::os::raw::c_int)
     -> grn_rc;
    pub fn grn_ctx_fin(ctx: *mut grn_ctx) -> grn_rc;
    pub fn grn_ctx_open(flags: ::std::os::raw::c_int) -> *mut grn_ctx;
    pub fn grn_ctx_close(ctx: *mut grn_ctx) -> grn_rc;
    pub fn grn_ctx_set_finalizer(ctx: *mut grn_ctx, func: grn_proc_func)
     -> grn_rc;
    pub fn grn_get_default_encoding() -> grn_encoding;
    pub fn grn_set_default_encoding(encoding: grn_encoding) -> grn_rc;
    pub fn grn_get_version() -> *const ::std::os::raw::c_char;
    pub fn grn_get_package() -> *const ::std::os::raw::c_char;
    pub fn grn_get_package_label() -> *const ::std::os::raw::c_char;
    pub fn grn_get_default_command_version() -> grn_command_version;
    pub fn grn_set_default_command_version(version: grn_command_version)
     -> grn_rc;
    pub fn grn_ctx_get_command_version(ctx: *mut grn_ctx)
     -> grn_command_version;
    pub fn grn_ctx_set_command_version(ctx: *mut grn_ctx,
                                       version: grn_command_version)
     -> grn_rc;
    pub fn grn_ctx_get_match_escalation_threshold(ctx: *mut grn_ctx)
     -> ::std::os::raw::c_longlong;
    pub fn grn_ctx_set_match_escalation_threshold(ctx: *mut grn_ctx,
                                                  threshold:
                                                      ::std::os::raw::c_longlong)
     -> grn_rc;
    pub fn grn_get_default_match_escalation_threshold()
     -> ::std::os::raw::c_longlong;
    pub fn grn_set_default_match_escalation_threshold(threshold:
                                                          ::std::os::raw::c_longlong)
     -> grn_rc;
    pub fn grn_get_lock_timeout() -> ::std::os::raw::c_int;
    pub fn grn_set_lock_timeout(timeout: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_cache_open(ctx: *mut grn_ctx) -> *mut grn_cache;
    pub fn grn_cache_close(ctx: *mut grn_ctx, cache: *mut grn_cache)
     -> grn_rc;
    pub fn grn_cache_current_set(ctx: *mut grn_ctx, cache: *mut grn_cache)
     -> grn_rc;
    pub fn grn_cache_current_get(ctx: *mut grn_ctx) -> *mut grn_cache;
    pub fn grn_cache_set_max_n_entries(ctx: *mut grn_ctx,
                                       cache: *mut grn_cache,
                                       n: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_cache_get_max_n_entries(ctx: *mut grn_ctx,
                                       cache: *mut grn_cache)
     -> ::std::os::raw::c_uint;
    pub fn grn_encoding_to_string(encoding: grn_encoding)
     -> *const ::std::os::raw::c_char;
    pub fn grn_encoding_parse(name: *const ::std::os::raw::c_char)
     -> grn_encoding;
    pub fn grn_ctx_use(ctx: *mut grn_ctx, db: *mut grn_obj) -> grn_rc;
    pub fn grn_ctx_db(ctx: *mut grn_ctx) -> *mut grn_obj;
    pub fn grn_ctx_get(ctx: *mut grn_ctx, name: *const ::std::os::raw::c_char,
                       name_size: ::std::os::raw::c_int) -> *mut grn_obj;
    pub fn grn_ctx_get_all_tables(ctx: *mut grn_ctx,
                                  tables_buffer: *mut grn_obj) -> grn_rc;
    pub fn grn_ctx_get_all_types(ctx: *mut grn_ctx,
                                 types_buffer: *mut grn_obj) -> grn_rc;
    pub fn grn_ctx_get_all_tokenizers(ctx: *mut grn_ctx,
                                      tokenizers_buffer: *mut grn_obj)
     -> grn_rc;
    pub fn grn_ctx_get_all_normalizers(ctx: *mut grn_ctx,
                                       normalizers_buffer: *mut grn_obj)
     -> grn_rc;
    pub fn grn_ctx_get_all_token_filters(ctx: *mut grn_ctx,
                                         token_filters_buffer: *mut grn_obj)
     -> grn_rc;
    pub fn grn_ctx_at(ctx: *mut grn_ctx, id: grn_id) -> *mut grn_obj;
    pub fn grn_ctx_is_opened(ctx: *mut grn_ctx, id: grn_id) -> grn_bool;
    pub fn grn_plugin_register(ctx: *mut grn_ctx,
                               name: *const ::std::os::raw::c_char) -> grn_rc;
    pub fn grn_plugin_unregister(ctx: *mut grn_ctx,
                                 name: *const ::std::os::raw::c_char)
     -> grn_rc;
    pub fn grn_plugin_register_by_path(ctx: *mut grn_ctx,
                                       path: *const ::std::os::raw::c_char)
     -> grn_rc;
    pub fn grn_plugin_unregister_by_path(ctx: *mut grn_ctx,
                                         path: *const ::std::os::raw::c_char)
     -> grn_rc;
    pub fn grn_plugin_get_system_plugins_dir()
     -> *const ::std::os::raw::c_char;
    pub fn grn_plugin_get_suffix() -> *const ::std::os::raw::c_char;
    pub fn grn_plugin_get_ruby_suffix() -> *const ::std::os::raw::c_char;
    pub fn grn_plugin_get_names(ctx: *mut grn_ctx, names: *mut grn_obj)
     -> grn_rc;
    pub fn grn_proc_create(ctx: *mut grn_ctx,
                           name: *const ::std::os::raw::c_char,
                           name_size: ::std::os::raw::c_int,
                           type_: grn_proc_type, init: grn_proc_func,
                           next: grn_proc_func, fin: grn_proc_func,
                           nvars: ::std::os::raw::c_uint,
                           vars: *mut grn_expr_var) -> *mut grn_obj;
    pub fn grn_proc_get_info(ctx: *mut grn_ctx, user_data: *mut grn_user_data,
                             vars: *mut *mut grn_expr_var,
                             nvars: *mut ::std::os::raw::c_uint,
                             caller: *mut *mut grn_obj) -> *mut grn_obj;
    pub fn grn_proc_get_type(ctx: *mut grn_ctx, proc_: *mut grn_obj)
     -> grn_proc_type;
    pub fn grn_obj_column(ctx: *mut grn_ctx, table: *mut grn_obj,
                          name: *const ::std::os::raw::c_char,
                          name_size: ::std::os::raw::c_uint) -> *mut grn_obj;
    pub fn grn_column_create(ctx: *mut grn_ctx, table: *mut grn_obj,
                             name: *const ::std::os::raw::c_char,
                             name_size: ::std::os::raw::c_uint,
                             path: *const ::std::os::raw::c_char,
                             flags: grn_column_flags, type_: *mut grn_obj)
     -> *mut grn_obj;
    pub fn grn_column_index_update(ctx: *mut grn_ctx, column: *mut grn_obj,
                                   id: grn_id,
                                   section: ::std::os::raw::c_uint,
                                   oldvalue: *mut grn_obj,
                                   newvalue: *mut grn_obj) -> grn_rc;
    pub fn grn_column_table(ctx: *mut grn_ctx, column: *mut grn_obj)
     -> *mut grn_obj;
    pub fn grn_column_truncate(ctx: *mut grn_ctx, column: *mut grn_obj)
     -> grn_rc;
    pub fn grn_obj_get_info(ctx: *mut grn_ctx, obj: *mut grn_obj,
                            type_: grn_info_type, valuebuf: *mut grn_obj)
     -> *mut grn_obj;
    pub fn grn_obj_set_info(ctx: *mut grn_ctx, obj: *mut grn_obj,
                            type_: grn_info_type, value: *mut grn_obj)
     -> grn_rc;
    pub fn grn_obj_get_element_info(ctx: *mut grn_ctx, obj: *mut grn_obj,
                                    id: grn_id, type_: grn_info_type,
                                    value: *mut grn_obj) -> *mut grn_obj;
    pub fn grn_obj_set_element_info(ctx: *mut grn_ctx, obj: *mut grn_obj,
                                    id: grn_id, type_: grn_info_type,
                                    value: *mut grn_obj) -> grn_rc;
    pub fn grn_obj_get_value(ctx: *mut grn_ctx, obj: *mut grn_obj, id: grn_id,
                             value: *mut grn_obj) -> *mut grn_obj;
    pub fn grn_obj_get_values(ctx: *mut grn_ctx, obj: *mut grn_obj,
                              offset: grn_id,
                              values: *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_obj_set_value(ctx: *mut grn_ctx, obj: *mut grn_obj, id: grn_id,
                             value: *mut grn_obj,
                             flags: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_obj_remove(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
    pub fn grn_obj_remove_dependent(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_rc;
    pub fn grn_obj_remove_force(ctx: *mut grn_ctx,
                                name: *const ::std::os::raw::c_char,
                                name_size: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_obj_rename(ctx: *mut grn_ctx, obj: *mut grn_obj,
                          name: *const ::std::os::raw::c_char,
                          name_size: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_table_rename(ctx: *mut grn_ctx, table: *mut grn_obj,
                            name: *const ::std::os::raw::c_char,
                            name_size: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_column_rename(ctx: *mut grn_ctx, column: *mut grn_obj,
                             name: *const ::std::os::raw::c_char,
                             name_size: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_obj_close(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
    pub fn grn_obj_reinit(ctx: *mut grn_ctx, obj: *mut grn_obj,
                          domain: grn_id, flags: ::std::os::raw::c_uchar)
     -> grn_rc;
    pub fn grn_obj_unlink(ctx: *mut grn_ctx, obj: *mut grn_obj);
    pub fn grn_obj_user_data(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> *mut grn_user_data;
    pub fn grn_obj_set_finalizer(ctx: *mut grn_ctx, obj: *mut grn_obj,
                                 func: grn_proc_func) -> grn_rc;
    pub fn grn_obj_path(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> *const ::std::os::raw::c_char;
    pub fn grn_obj_name(ctx: *mut grn_ctx, obj: *mut grn_obj,
                        namebuf: *mut ::std::os::raw::c_char,
                        buf_size: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_column_name(ctx: *mut grn_ctx, obj: *mut grn_obj,
                           namebuf: *mut ::std::os::raw::c_char,
                           buf_size: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_obj_get_range(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_id;
    pub fn grn_obj_expire(ctx: *mut grn_ctx, obj: *mut grn_obj,
                          threshold: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_obj_check(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> ::std::os::raw::c_int;
    pub fn grn_obj_lock(ctx: *mut grn_ctx, obj: *mut grn_obj, id: grn_id,
                        timeout: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_obj_unlock(ctx: *mut grn_ctx, obj: *mut grn_obj, id: grn_id)
     -> grn_rc;
    pub fn grn_obj_clear_lock(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
    pub fn grn_obj_is_locked(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> ::std::os::raw::c_uint;
    pub fn grn_obj_flush(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
    pub fn grn_obj_flush_recursive(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_rc;
    pub fn grn_obj_defrag(ctx: *mut grn_ctx, obj: *mut grn_obj,
                          threshold: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_obj_db(ctx: *mut grn_ctx, obj: *mut grn_obj) -> *mut grn_obj;
    pub fn grn_obj_id(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_id;
    pub fn grn_obj_search(ctx: *mut grn_ctx, obj: *mut grn_obj,
                          query: *mut grn_obj, res: *mut grn_obj,
                          op: grn_operator, optarg: *mut grn_search_optarg)
     -> grn_rc;
    pub fn grn_proc_set_selector(ctx: *mut grn_ctx, proc_: *mut grn_obj,
                                 selector: grn_selector_func) -> grn_rc;
    pub fn grn_proc_set_selector_operator(ctx: *mut grn_ctx,
                                          proc_: *mut grn_obj,
                                          selector_op: grn_operator)
     -> grn_rc;
    pub fn grn_proc_get_selector_operator(ctx: *mut grn_ctx,
                                          proc_: *mut grn_obj)
     -> grn_operator;
    pub fn grn_vector_size(ctx: *mut grn_ctx, vector: *mut grn_obj)
     -> ::std::os::raw::c_uint;
    pub fn grn_vector_add_element(ctx: *mut grn_ctx, vector: *mut grn_obj,
                                  str: *const ::std::os::raw::c_char,
                                  str_len: ::std::os::raw::c_uint,
                                  weight: ::std::os::raw::c_uint,
                                  domain: grn_id) -> grn_rc;
    pub fn grn_vector_get_element(ctx: *mut grn_ctx, vector: *mut grn_obj,
                                  offset: ::std::os::raw::c_uint,
                                  str: *mut *const ::std::os::raw::c_char,
                                  weight: *mut ::std::os::raw::c_uint,
                                  domain: *mut grn_id)
     -> ::std::os::raw::c_uint;
    pub fn grn_vector_pop_element(ctx: *mut grn_ctx, vector: *mut grn_obj,
                                  str: *mut *const ::std::os::raw::c_char,
                                  weight: *mut ::std::os::raw::c_uint,
                                  domain: *mut grn_id)
     -> ::std::os::raw::c_uint;
    pub fn grn_uvector_size(ctx: *mut grn_ctx, uvector: *mut grn_obj)
     -> ::std::os::raw::c_uint;
    pub fn grn_uvector_element_size(ctx: *mut grn_ctx, uvector: *mut grn_obj)
     -> ::std::os::raw::c_uint;
    pub fn grn_uvector_add_element(ctx: *mut grn_ctx, vector: *mut grn_obj,
                                   id: grn_id, weight: ::std::os::raw::c_uint)
     -> grn_rc;
    pub fn grn_uvector_get_element(ctx: *mut grn_ctx, uvector: *mut grn_obj,
                                   offset: ::std::os::raw::c_uint,
                                   weight: *mut ::std::os::raw::c_uint)
     -> grn_id;
    pub fn grn_proc_call_next(ctx: *mut grn_ctx, exec_info: *mut grn_obj,
                              in_: *mut grn_obj, out: *mut grn_obj)
     -> ::std::os::raw::c_int;
    pub fn grn_proc_get_ctx_local_data(ctx: *mut grn_ctx,
                                       exec_info: *mut grn_obj)
     -> *mut ::std::os::raw::c_void;
    pub fn grn_proc_get_hook_local_data(ctx: *mut grn_ctx,
                                        exec_info: *mut grn_obj)
     -> *mut ::std::os::raw::c_void;
    pub fn grn_obj_add_hook(ctx: *mut grn_ctx, obj: *mut grn_obj,
                            entry: grn_hook_entry,
                            offset: ::std::os::raw::c_int,
                            proc_: *mut grn_obj, data: *mut grn_obj)
     -> grn_rc;
    pub fn grn_obj_get_nhooks(ctx: *mut grn_ctx, obj: *mut grn_obj,
                              entry: grn_hook_entry) -> ::std::os::raw::c_int;
    pub fn grn_obj_get_hook(ctx: *mut grn_ctx, obj: *mut grn_obj,
                            entry: grn_hook_entry,
                            offset: ::std::os::raw::c_int, data: *mut grn_obj)
     -> *mut grn_obj;
    pub fn grn_obj_delete_hook(ctx: *mut grn_ctx, obj: *mut grn_obj,
                               entry: grn_hook_entry,
                               offset: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_obj_open(ctx: *mut grn_ctx, type_: ::std::os::raw::c_uchar,
                        flags: grn_obj_flags, domain: grn_id) -> *mut grn_obj;
    pub fn grn_column_index(ctx: *mut grn_ctx, column: *mut grn_obj,
                            op: grn_operator, indexbuf: *mut *mut grn_obj,
                            buf_size: ::std::os::raw::c_int,
                            section: *mut ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_column_find_index_data(ctx: *mut grn_ctx, column: *mut grn_obj,
                                      op: grn_operator,
                                      index_data: *mut grn_index_datum,
                                      n_index_data: ::std::os::raw::c_uint)
     -> ::std::os::raw::c_uint;
    pub fn grn_column_get_all_index_data(ctx: *mut grn_ctx,
                                         column: *mut grn_obj,
                                         index_data: *mut grn_index_datum,
                                         n_index_data: uint32_t) -> uint32_t;
    pub fn grn_obj_delete_by_id(ctx: *mut grn_ctx, db: *mut grn_obj,
                                id: grn_id, removep: grn_bool) -> grn_rc;
    pub fn grn_obj_path_by_id(ctx: *mut grn_ctx, db: *mut grn_obj, id: grn_id,
                              buffer: *mut ::std::os::raw::c_char) -> grn_rc;
    pub fn grn_geo_select_in_rectangle(ctx: *mut grn_ctx, index: *mut grn_obj,
                                       top_left_point: *mut grn_obj,
                                       bottom_right_point: *mut grn_obj,
                                       res: *mut grn_obj, op: grn_operator)
     -> grn_rc;
    pub fn grn_geo_estimate_size_in_rectangle(ctx: *mut grn_ctx,
                                              index: *mut grn_obj,
                                              top_left_point: *mut grn_obj,
                                              bottom_right_point:
                                                  *mut grn_obj)
     -> ::std::os::raw::c_uint;
    pub fn grn_geo_estimate_in_rectangle(ctx: *mut grn_ctx,
                                         index: *mut grn_obj,
                                         top_left_point: *mut grn_obj,
                                         bottom_right_point: *mut grn_obj)
     -> ::std::os::raw::c_int;
    pub fn grn_geo_cursor_open_in_rectangle(ctx: *mut grn_ctx,
                                            index: *mut grn_obj,
                                            top_left_point: *mut grn_obj,
                                            bottom_right_point: *mut grn_obj,
                                            offset: ::std::os::raw::c_int,
                                            limit: ::std::os::raw::c_int)
     -> *mut grn_obj;
    pub fn grn_geo_cursor_next(ctx: *mut grn_ctx, cursor: *mut grn_obj)
     -> *mut grn_posting;
    pub fn grn_snip_open(ctx: *mut grn_ctx, flags: ::std::os::raw::c_int,
                         width: ::std::os::raw::c_uint,
                         max_results: ::std::os::raw::c_uint,
                         defaultopentag: *const ::std::os::raw::c_char,
                         defaultopentag_len: ::std::os::raw::c_uint,
                         defaultclosetag: *const ::std::os::raw::c_char,
                         defaultclosetag_len: ::std::os::raw::c_uint,
                         mapping: *mut grn_snip_mapping) -> *mut grn_obj;
    pub fn grn_snip_add_cond(ctx: *mut grn_ctx, snip: *mut grn_obj,
                             keyword: *const ::std::os::raw::c_char,
                             keyword_len: ::std::os::raw::c_uint,
                             opentag: *const ::std::os::raw::c_char,
                             opentag_len: ::std::os::raw::c_uint,
                             closetag: *const ::std::os::raw::c_char,
                             closetag_len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_snip_set_normalizer(ctx: *mut grn_ctx, snip: *mut grn_obj,
                                   normalizer: *mut grn_obj) -> grn_rc;
    pub fn grn_snip_get_normalizer(ctx: *mut grn_ctx, snip: *mut grn_obj)
     -> *mut grn_obj;
    pub fn grn_snip_exec(ctx: *mut grn_ctx, snip: *mut grn_obj,
                         string: *const ::std::os::raw::c_char,
                         string_len: ::std::os::raw::c_uint,
                         nresults: *mut ::std::os::raw::c_uint,
                         max_tagged_len: *mut ::std::os::raw::c_uint)
     -> grn_rc;
    pub fn grn_snip_get_result(ctx: *mut grn_ctx, snip: *mut grn_obj,
                               index: ::std::os::raw::c_uint,
                               result: *mut ::std::os::raw::c_char,
                               result_len: *mut ::std::os::raw::c_uint)
     -> grn_rc;
    pub fn grn_logger_info_set(ctx: *mut grn_ctx,
                               info: *const grn_logger_info) -> grn_rc;
    pub fn grn_logger_set(ctx: *mut grn_ctx, logger: *const grn_logger)
     -> grn_rc;
    pub fn grn_logger_set_max_level(ctx: *mut grn_ctx,
                                    max_level: grn_log_level);
    pub fn grn_logger_get_max_level(ctx: *mut grn_ctx) -> grn_log_level;
    pub fn grn_logger_put(ctx: *mut grn_ctx, level: grn_log_level,
                          file: *const ::std::os::raw::c_char,
                          line: ::std::os::raw::c_int,
                          func: *const ::std::os::raw::c_char,
                          fmt: *const ::std::os::raw::c_char, ...);
    // pub fn grn_logger_putv(ctx: *mut grn_ctx, level: grn_log_level,
    //                        file: *const ::std::os::raw::c_char,
    //                        line: ::std::os::raw::c_int,
    //                        func: *const ::std::os::raw::c_char,
    //                        fmt: *const ::std::os::raw::c_char, ap: va_list);
    pub fn grn_logger_reopen(ctx: *mut grn_ctx);
    pub fn grn_logger_pass(ctx: *mut grn_ctx, level: grn_log_level)
     -> grn_bool;
    pub fn grn_default_logger_set_max_level(level: grn_log_level);
    pub fn grn_default_logger_get_max_level() -> grn_log_level;
    pub fn grn_default_logger_set_path(path: *const ::std::os::raw::c_char);
    pub fn grn_default_logger_get_path() -> *const ::std::os::raw::c_char;
    pub fn grn_default_logger_set_rotate_threshold_size(threshold: off_t);
    pub fn grn_default_logger_get_rotate_threshold_size() -> off_t;
    pub fn grn_query_logger_set(ctx: *mut grn_ctx,
                                logger: *const grn_query_logger) -> grn_rc;
    pub fn grn_query_logger_put(ctx: *mut grn_ctx,
                                flag: ::std::os::raw::c_uint,
                                mark: *const ::std::os::raw::c_char,
                                format: *const ::std::os::raw::c_char, ...);
    pub fn grn_query_logger_reopen(ctx: *mut grn_ctx);
    pub fn grn_query_logger_pass(ctx: *mut grn_ctx,
                                 flag: ::std::os::raw::c_uint) -> grn_bool;
    pub fn grn_default_query_logger_set_flags(flags: ::std::os::raw::c_uint);
    pub fn grn_default_query_logger_get_flags() -> ::std::os::raw::c_uint;
    pub fn grn_default_query_logger_set_path(path:
                                                 *const ::std::os::raw::c_char);
    pub fn grn_default_query_logger_get_path()
     -> *const ::std::os::raw::c_char;
    pub fn grn_default_query_logger_set_rotate_threshold_size(threshold:
                                                                  off_t);
    pub fn grn_default_query_logger_get_rotate_threshold_size() -> off_t;
    pub fn grn_bulk_reinit(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                           size: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_bulk_resize(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                           newsize: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_bulk_write(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                          str: *const ::std::os::raw::c_char,
                          len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_bulk_write_from(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                               str: *const ::std::os::raw::c_char,
                               from: ::std::os::raw::c_uint,
                               len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_bulk_reserve(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                            len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_bulk_space(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                          len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_bulk_truncate(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                             len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_bulk_fin(ctx: *mut grn_ctx, bulk: *mut grn_obj) -> grn_rc;
    pub fn grn_text_itoa(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                         i: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_text_itoa_padded(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                                i: ::std::os::raw::c_int,
                                ch: ::std::os::raw::c_char,
                                len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_text_lltoa(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                          i: ::std::os::raw::c_longlong) -> grn_rc;
    pub fn grn_text_ftoa(ctx: *mut grn_ctx, bulk: *mut grn_obj, d: f64)
     -> grn_rc;
    pub fn grn_text_itoh(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                         i: ::std::os::raw::c_int,
                         len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_text_itob(ctx: *mut grn_ctx, bulk: *mut grn_obj, id: grn_id)
     -> grn_rc;
    pub fn grn_text_lltob32h(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                             i: ::std::os::raw::c_longlong) -> grn_rc;
    pub fn grn_text_benc(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                         v: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_text_esc(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                        s: *const ::std::os::raw::c_char,
                        len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_text_urlenc(ctx: *mut grn_ctx, buf: *mut grn_obj,
                           str: *const ::std::os::raw::c_char,
                           len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_text_urldec(ctx: *mut grn_ctx, buf: *mut grn_obj,
                           s: *const ::std::os::raw::c_char,
                           e: *const ::std::os::raw::c_char,
                           d: ::std::os::raw::c_char)
     -> *const ::std::os::raw::c_char;
    pub fn grn_text_escape_xml(ctx: *mut grn_ctx, buf: *mut grn_obj,
                               s: *const ::std::os::raw::c_char,
                               len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_text_time2rfc1123(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                                 sec: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_text_printf(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                           format: *const ::std::os::raw::c_char, ...)
     -> grn_rc;
    // pub fn grn_text_vprintf(ctx: *mut grn_ctx, bulk: *mut grn_obj,
    //                         format: *const ::std::os::raw::c_char,
    //                         args: va_list) -> grn_rc;
    pub fn grn_ctx_recv_handler_set(arg1: *mut grn_ctx,
                                    func:
                                        ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                       *mut grn_ctx,
                                                                                   arg2:
                                                                                       ::std::os::raw::c_int,
                                                                                   arg3:
                                                                                       *mut ::std::os::raw::c_void)>,
                                    func_arg: *mut ::std::os::raw::c_void);
    pub fn grn_str_open(ctx: *mut grn_ctx, str: *const ::std::os::raw::c_char,
                        str_len: ::std::os::raw::c_uint,
                        flags: ::std::os::raw::c_int) -> *mut grn_str;
    pub fn grn_str_close(ctx: *mut grn_ctx, nstr: *mut grn_str) -> grn_rc;
    pub fn grn_string_open(ctx: *mut grn_ctx,
                           string: *const ::std::os::raw::c_char,
                           length_in_bytes: ::std::os::raw::c_uint,
                           normalizer: *mut grn_obj,
                           flags: ::std::os::raw::c_int) -> *mut grn_obj;
    pub fn grn_string_get_original(ctx: *mut grn_ctx, string: *mut grn_obj,
                                   original:
                                       *mut *const ::std::os::raw::c_char,
                                   length_in_bytes:
                                       *mut ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_string_get_flags(ctx: *mut grn_ctx, string: *mut grn_obj)
     -> ::std::os::raw::c_int;
    pub fn grn_string_get_normalized(ctx: *mut grn_ctx, string: *mut grn_obj,
                                     normalized:
                                         *mut *const ::std::os::raw::c_char,
                                     length_in_bytes:
                                         *mut ::std::os::raw::c_uint,
                                     n_characters:
                                         *mut ::std::os::raw::c_uint)
     -> grn_rc;
    pub fn grn_string_set_normalized(ctx: *mut grn_ctx, string: *mut grn_obj,
                                     normalized: *mut ::std::os::raw::c_char,
                                     length_in_bytes: ::std::os::raw::c_uint,
                                     n_characters: ::std::os::raw::c_uint)
     -> grn_rc;
    pub fn grn_string_get_checks(ctx: *mut grn_ctx, string: *mut grn_obj)
     -> *const ::std::os::raw::c_short;
    pub fn grn_string_set_checks(ctx: *mut grn_ctx, string: *mut grn_obj,
                                 checks: *mut ::std::os::raw::c_short)
     -> grn_rc;
    pub fn grn_string_get_types(ctx: *mut grn_ctx, string: *mut grn_obj)
     -> *const ::std::os::raw::c_uchar;
    pub fn grn_string_set_types(ctx: *mut grn_ctx, string: *mut grn_obj,
                                types: *mut ::std::os::raw::c_uchar)
     -> grn_rc;
    pub fn grn_string_get_encoding(ctx: *mut grn_ctx, string: *mut grn_obj)
     -> grn_encoding;
    pub fn grn_charlen(ctx: *mut grn_ctx, str: *const ::std::os::raw::c_char,
                       end: *const ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn grn_ctx_push(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
    pub fn grn_ctx_pop(ctx: *mut grn_ctx) -> *mut grn_obj;
    pub fn grn_obj_columns(ctx: *mut grn_ctx, table: *mut grn_obj,
                           str: *const ::std::os::raw::c_char,
                           str_size: ::std::os::raw::c_uint,
                           res: *mut grn_obj) -> ::std::os::raw::c_int;
    pub fn grn_load(ctx: *mut grn_ctx, input_type: grn_content_type,
                    table: *const ::std::os::raw::c_char,
                    table_len: ::std::os::raw::c_uint,
                    columns: *const ::std::os::raw::c_char,
                    columns_len: ::std::os::raw::c_uint,
                    values: *const ::std::os::raw::c_char,
                    values_len: ::std::os::raw::c_uint,
                    ifexists: *const ::std::os::raw::c_char,
                    ifexists_len: ::std::os::raw::c_uint,
                    each: *const ::std::os::raw::c_char,
                    each_len: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_ctx_connect(ctx: *mut grn_ctx,
                           host: *const ::std::os::raw::c_char,
                           port: ::std::os::raw::c_int,
                           flags: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_ctx_send(ctx: *mut grn_ctx, str: *const ::std::os::raw::c_char,
                        str_len: ::std::os::raw::c_uint,
                        flags: ::std::os::raw::c_int)
     -> ::std::os::raw::c_uint;
    pub fn grn_ctx_recv(ctx: *mut grn_ctx,
                        str: *mut *mut ::std::os::raw::c_char,
                        str_len: *mut ::std::os::raw::c_uint,
                        flags: *mut ::std::os::raw::c_int)
     -> ::std::os::raw::c_uint;
    pub fn grn_ctx_info_get(ctx: *mut grn_ctx, info: *mut grn_ctx_info)
     -> grn_rc;
    pub fn grn_set_segv_handler() -> grn_rc;
    pub fn grn_set_int_handler() -> grn_rc;
    pub fn grn_set_term_handler() -> grn_rc;
    pub fn grn_array_create(ctx: *mut grn_ctx,
                            path: *const ::std::os::raw::c_char,
                            value_size: ::std::os::raw::c_uint,
                            flags: ::std::os::raw::c_uint) -> *mut grn_array;
    pub fn grn_array_open(ctx: *mut grn_ctx,
                          path: *const ::std::os::raw::c_char)
     -> *mut grn_array;
    pub fn grn_array_close(ctx: *mut grn_ctx, array: *mut grn_array)
     -> grn_rc;
    pub fn grn_array_add(ctx: *mut grn_ctx, array: *mut grn_array,
                         value: *mut *mut ::std::os::raw::c_void) -> grn_id;
    pub fn grn_array_push(ctx: *mut grn_ctx, array: *mut grn_array,
                          func:
                              ::std::option::Option<unsafe extern "C" fn(ctx:
                                                                             *mut grn_ctx,
                                                                         array:
                                                                             *mut grn_array,
                                                                         id:
                                                                             grn_id,
                                                                         func_arg:
                                                                             *mut ::std::os::raw::c_void)>,
                          func_arg: *mut ::std::os::raw::c_void) -> grn_id;
    pub fn grn_array_pull(ctx: *mut grn_ctx, array: *mut grn_array,
                          blockp: grn_bool,
                          func:
                              ::std::option::Option<unsafe extern "C" fn(ctx:
                                                                             *mut grn_ctx,
                                                                         array:
                                                                             *mut grn_array,
                                                                         id:
                                                                             grn_id,
                                                                         func_arg:
                                                                             *mut ::std::os::raw::c_void)>,
                          func_arg: *mut ::std::os::raw::c_void) -> grn_id;
    pub fn grn_array_unblock(ctx: *mut grn_ctx, array: *mut grn_array);
    pub fn grn_array_get_value(ctx: *mut grn_ctx, array: *mut grn_array,
                               id: grn_id,
                               valuebuf: *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_array_set_value(ctx: *mut grn_ctx, array: *mut grn_array,
                               id: grn_id,
                               value: *const ::std::os::raw::c_void,
                               flags: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_array_cursor_open(ctx: *mut grn_ctx, array: *mut grn_array,
                                 min: grn_id, max: grn_id,
                                 offset: ::std::os::raw::c_int,
                                 limit: ::std::os::raw::c_int,
                                 flags: ::std::os::raw::c_int)
     -> *mut grn_array_cursor;
    pub fn grn_array_cursor_next(ctx: *mut grn_ctx,
                                 cursor: *mut grn_array_cursor) -> grn_id;
    pub fn grn_array_cursor_get_value(ctx: *mut grn_ctx,
                                      cursor: *mut grn_array_cursor,
                                      value: *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_array_cursor_set_value(ctx: *mut grn_ctx,
                                      cursor: *mut grn_array_cursor,
                                      value: *const ::std::os::raw::c_void,
                                      flags: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_array_cursor_delete(ctx: *mut grn_ctx,
                                   cursor: *mut grn_array_cursor,
                                   optarg: *mut grn_table_delete_optarg)
     -> grn_rc;
    pub fn grn_array_cursor_close(ctx: *mut grn_ctx,
                                  cursor: *mut grn_array_cursor);
    pub fn grn_array_delete_by_id(ctx: *mut grn_ctx, array: *mut grn_array,
                                  id: grn_id,
                                  optarg: *mut grn_table_delete_optarg)
     -> grn_rc;
    pub fn grn_array_next(ctx: *mut grn_ctx, array: *mut grn_array,
                          id: grn_id) -> grn_id;
    pub fn _grn_array_get_value(ctx: *mut grn_ctx, array: *mut grn_array,
                                id: grn_id) -> *mut ::std::os::raw::c_void;
    pub fn grn_column_get_flags(ctx: *mut grn_ctx, column: *mut grn_obj)
     -> grn_column_flags;
    pub fn grn_config_set(ctx: *mut grn_ctx,
                          key: *const ::std::os::raw::c_char,
                          key_size: int32_t,
                          value: *const ::std::os::raw::c_char,
                          value_size: int32_t) -> grn_rc;
    pub fn grn_config_get(ctx: *mut grn_ctx,
                          key: *const ::std::os::raw::c_char,
                          key_size: int32_t,
                          value: *mut *const ::std::os::raw::c_char,
                          value_size: *mut uint32_t) -> grn_rc;
    pub fn grn_config_delete(ctx: *mut grn_ctx,
                             key: *const ::std::os::raw::c_char,
                             key_size: int32_t) -> grn_rc;
    pub fn grn_config_cursor_open(ctx: *mut grn_ctx) -> *mut grn_obj;
    pub fn grn_config_cursor_next(ctx: *mut grn_ctx, cursor: *mut grn_obj)
     -> grn_bool;
    pub fn grn_config_cursor_get_key(ctx: *mut grn_ctx, cursor: *mut grn_obj,
                                     key: *mut *const ::std::os::raw::c_char)
     -> uint32_t;
    pub fn grn_config_cursor_get_value(ctx: *mut grn_ctx,
                                       cursor: *mut grn_obj,
                                       value:
                                           *mut *const ::std::os::raw::c_char)
     -> uint32_t;
    pub fn grn_conf_set(ctx: *mut grn_ctx, key: *const ::std::os::raw::c_char,
                        key_size: int32_t,
                        value: *const ::std::os::raw::c_char,
                        value_size: int32_t) -> grn_rc;
    pub fn grn_conf_get(ctx: *mut grn_ctx, key: *const ::std::os::raw::c_char,
                        key_size: int32_t,
                        value: *mut *const ::std::os::raw::c_char,
                        value_size: *mut uint32_t) -> grn_rc;
    pub fn grn_dat_scan(ctx: *mut grn_ctx, dat: *mut grn_dat,
                        str: *const ::std::os::raw::c_char,
                        str_size: ::std::os::raw::c_uint,
                        scan_hits: *mut grn_dat_scan_hit,
                        max_num_scan_hits: ::std::os::raw::c_uint,
                        str_rest: *mut *const ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn grn_dat_lcp_search(ctx: *mut grn_ctx, dat: *mut grn_dat,
                              key: *const ::std::os::raw::c_void,
                              key_size: ::std::os::raw::c_uint) -> grn_id;
    pub fn grn_dat_create(ctx: *mut grn_ctx,
                          path: *const ::std::os::raw::c_char,
                          key_size: ::std::os::raw::c_uint,
                          value_size: ::std::os::raw::c_uint,
                          flags: ::std::os::raw::c_uint) -> *mut grn_dat;
    pub fn grn_dat_open(ctx: *mut grn_ctx,
                        path: *const ::std::os::raw::c_char) -> *mut grn_dat;
    pub fn grn_dat_close(ctx: *mut grn_ctx, dat: *mut grn_dat) -> grn_rc;
    pub fn grn_dat_remove(ctx: *mut grn_ctx,
                          path: *const ::std::os::raw::c_char) -> grn_rc;
    pub fn grn_dat_get(ctx: *mut grn_ctx, dat: *mut grn_dat,
                       key: *const ::std::os::raw::c_void,
                       key_size: ::std::os::raw::c_uint,
                       value: *mut *mut ::std::os::raw::c_void) -> grn_id;
    pub fn grn_dat_add(ctx: *mut grn_ctx, dat: *mut grn_dat,
                       key: *const ::std::os::raw::c_void,
                       key_size: ::std::os::raw::c_uint,
                       value: *mut *mut ::std::os::raw::c_void,
                       added: *mut ::std::os::raw::c_int) -> grn_id;
    pub fn grn_dat_get_key(ctx: *mut grn_ctx, dat: *mut grn_dat, id: grn_id,
                           keybuf: *mut ::std::os::raw::c_void,
                           bufsize: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_dat_get_key2(ctx: *mut grn_ctx, dat: *mut grn_dat, id: grn_id,
                            bulk: *mut grn_obj) -> ::std::os::raw::c_int;
    pub fn grn_dat_delete_by_id(ctx: *mut grn_ctx, dat: *mut grn_dat,
                                id: grn_id,
                                optarg: *mut grn_table_delete_optarg)
     -> grn_rc;
    pub fn grn_dat_delete(ctx: *mut grn_ctx, dat: *mut grn_dat,
                          key: *const ::std::os::raw::c_void,
                          key_size: ::std::os::raw::c_uint,
                          optarg: *mut grn_table_delete_optarg) -> grn_rc;
    pub fn grn_dat_update_by_id(ctx: *mut grn_ctx, dat: *mut grn_dat,
                                src_key_id: grn_id,
                                dest_key: *const ::std::os::raw::c_void,
                                dest_key_size: ::std::os::raw::c_uint)
     -> grn_rc;
    pub fn grn_dat_update(ctx: *mut grn_ctx, dat: *mut grn_dat,
                          src_key: *const ::std::os::raw::c_void,
                          src_key_size: ::std::os::raw::c_uint,
                          dest_key: *const ::std::os::raw::c_void,
                          dest_key_size: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_dat_size(ctx: *mut grn_ctx, dat: *mut grn_dat)
     -> ::std::os::raw::c_uint;
    pub fn grn_dat_cursor_open(ctx: *mut grn_ctx, dat: *mut grn_dat,
                               min: *const ::std::os::raw::c_void,
                               min_size: ::std::os::raw::c_uint,
                               max: *const ::std::os::raw::c_void,
                               max_size: ::std::os::raw::c_uint,
                               offset: ::std::os::raw::c_int,
                               limit: ::std::os::raw::c_int,
                               flags: ::std::os::raw::c_int)
     -> *mut grn_dat_cursor;
    pub fn grn_dat_cursor_next(ctx: *mut grn_ctx, c: *mut grn_dat_cursor)
     -> grn_id;
    pub fn grn_dat_cursor_close(ctx: *mut grn_ctx, c: *mut grn_dat_cursor);
    pub fn grn_dat_cursor_get_key(ctx: *mut grn_ctx, c: *mut grn_dat_cursor,
                                  key: *mut *const ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_dat_cursor_delete(ctx: *mut grn_ctx, c: *mut grn_dat_cursor,
                                 optarg: *mut grn_table_delete_optarg)
     -> grn_rc;
    pub fn grn_db_create(ctx: *mut grn_ctx,
                         path: *const ::std::os::raw::c_char,
                         optarg: *mut grn_db_create_optarg) -> *mut grn_obj;
    pub fn grn_db_open(ctx: *mut grn_ctx, path: *const ::std::os::raw::c_char)
     -> *mut grn_obj;
    pub fn grn_db_touch(ctx: *mut grn_ctx, db: *mut grn_obj);
    pub fn grn_db_recover(ctx: *mut grn_ctx, db: *mut grn_obj) -> grn_rc;
    pub fn grn_db_unmap(ctx: *mut grn_ctx, db: *mut grn_obj) -> grn_rc;
    pub fn grn_db_get_last_modified(ctx: *mut grn_ctx, db: *mut grn_obj)
     -> uint32_t;
    pub fn grn_db_is_dirty(ctx: *mut grn_ctx, db: *mut grn_obj) -> grn_bool;
    pub fn grn_dump_table_create_flags(ctx: *mut grn_ctx,
                                       flags: grn_table_flags,
                                       buffer: *mut grn_obj) -> grn_rc;
    pub fn grn_dump_column_create_flags(ctx: *mut grn_ctx,
                                        flags: grn_column_flags,
                                        buffer: *mut grn_obj) -> grn_rc;
    pub fn grn_rc_to_string(rc: grn_rc) -> *const ::std::os::raw::c_char;
    pub fn grn_expr_create(ctx: *mut grn_ctx,
                           name: *const ::std::os::raw::c_char,
                           name_size: ::std::os::raw::c_uint) -> *mut grn_obj;
    pub fn grn_expr_close(ctx: *mut grn_ctx, expr: *mut grn_obj) -> grn_rc;
    pub fn grn_expr_add_var(ctx: *mut grn_ctx, expr: *mut grn_obj,
                            name: *const ::std::os::raw::c_char,
                            name_size: ::std::os::raw::c_uint)
     -> *mut grn_obj;
    pub fn grn_expr_get_var(ctx: *mut grn_ctx, expr: *mut grn_obj,
                            name: *const ::std::os::raw::c_char,
                            name_size: ::std::os::raw::c_uint)
     -> *mut grn_obj;
    pub fn grn_expr_get_var_by_offset(ctx: *mut grn_ctx, expr: *mut grn_obj,
                                      offset: ::std::os::raw::c_uint)
     -> *mut grn_obj;
    pub fn grn_expr_clear_vars(ctx: *mut grn_ctx, expr: *mut grn_obj)
     -> grn_rc;
    pub fn grn_expr_take_obj(ctx: *mut grn_ctx, expr: *mut grn_obj,
                             obj: *mut grn_obj);
    pub fn grn_expr_append_obj(ctx: *mut grn_ctx, expr: *mut grn_obj,
                               obj: *mut grn_obj, op: grn_operator,
                               nargs: ::std::os::raw::c_int) -> *mut grn_obj;
    pub fn grn_expr_append_const(ctx: *mut grn_ctx, expr: *mut grn_obj,
                                 obj: *mut grn_obj, op: grn_operator,
                                 nargs: ::std::os::raw::c_int)
     -> *mut grn_obj;
    pub fn grn_expr_append_const_str(ctx: *mut grn_ctx, expr: *mut grn_obj,
                                     str: *const ::std::os::raw::c_char,
                                     str_size: ::std::os::raw::c_uint,
                                     op: grn_operator,
                                     nargs: ::std::os::raw::c_int)
     -> *mut grn_obj;
    pub fn grn_expr_append_const_int(ctx: *mut grn_ctx, expr: *mut grn_obj,
                                     i: ::std::os::raw::c_int,
                                     op: grn_operator,
                                     nargs: ::std::os::raw::c_int)
     -> *mut grn_obj;
    pub fn grn_expr_append_op(ctx: *mut grn_ctx, expr: *mut grn_obj,
                              op: grn_operator, nargs: ::std::os::raw::c_int)
     -> grn_rc;
    pub fn grn_expr_get_keywords(ctx: *mut grn_ctx, expr: *mut grn_obj,
                                 keywords: *mut grn_obj) -> grn_rc;
    pub fn grn_expr_syntax_escape(ctx: *mut grn_ctx,
                                  query: *const ::std::os::raw::c_char,
                                  query_size: ::std::os::raw::c_int,
                                  target_characters:
                                      *const ::std::os::raw::c_char,
                                  escape_character: ::std::os::raw::c_char,
                                  escaped_query: *mut grn_obj) -> grn_rc;
    pub fn grn_expr_syntax_escape_query(ctx: *mut grn_ctx,
                                        query: *const ::std::os::raw::c_char,
                                        query_size: ::std::os::raw::c_int,
                                        escaped_query: *mut grn_obj)
     -> grn_rc;
    pub fn grn_expr_syntax_expand_query(ctx: *mut grn_ctx,
                                        query: *const ::std::os::raw::c_char,
                                        query_size: ::std::os::raw::c_int,
                                        flags: grn_expr_flags,
                                        expander: *mut grn_obj,
                                        expanded_query: *mut grn_obj)
     -> grn_rc;
    pub fn grn_expr_compile(ctx: *mut grn_ctx, expr: *mut grn_obj) -> grn_rc;
    pub fn grn_expr_rewrite(ctx: *mut grn_ctx, expr: *mut grn_obj)
     -> *mut grn_obj;
    pub fn grn_expr_dump_plan(ctx: *mut grn_ctx, expr: *mut grn_obj,
                              buffer: *mut grn_obj) -> grn_rc;
    pub fn grn_expr_exec(ctx: *mut grn_ctx, expr: *mut grn_obj,
                         nargs: ::std::os::raw::c_int) -> *mut grn_obj;
    pub fn grn_expr_alloc(ctx: *mut grn_ctx, expr: *mut grn_obj,
                          domain: grn_id, flags: ::std::os::raw::c_uchar)
     -> *mut grn_obj;
    pub fn grn_expr_parse(ctx: *mut grn_ctx, expr: *mut grn_obj,
                          str: *const ::std::os::raw::c_char,
                          str_size: ::std::os::raw::c_uint,
                          default_column: *mut grn_obj,
                          default_mode: grn_operator,
                          default_op: grn_operator, flags: grn_expr_flags)
     -> grn_rc;
    pub fn grn_expr_snip(ctx: *mut grn_ctx, expr: *mut grn_obj,
                         flags: ::std::os::raw::c_int,
                         width: ::std::os::raw::c_uint,
                         max_results: ::std::os::raw::c_uint,
                         n_tags: ::std::os::raw::c_uint,
                         opentags: *mut *const ::std::os::raw::c_char,
                         opentag_lens: *mut ::std::os::raw::c_uint,
                         closetags: *mut *const ::std::os::raw::c_char,
                         closetag_lens: *mut ::std::os::raw::c_uint,
                         mapping: *mut grn_snip_mapping) -> *mut grn_obj;
    pub fn grn_expr_snip_add_conditions(ctx: *mut grn_ctx, expr: *mut grn_obj,
                                        snip: *mut grn_obj,
                                        n_tags: ::std::os::raw::c_uint,
                                        opentags:
                                            *mut *const ::std::os::raw::c_char,
                                        opentag_lens:
                                            *mut ::std::os::raw::c_uint,
                                        closetags:
                                            *mut *const ::std::os::raw::c_char,
                                        closetag_lens:
                                            *mut ::std::os::raw::c_uint)
     -> grn_rc;
    pub fn grn_expr_estimate_size(ctx: *mut grn_ctx, expr: *mut grn_obj)
     -> ::std::os::raw::c_uint;
    pub fn grn_file_reader_open(ctx: *mut grn_ctx,
                                path: *const ::std::os::raw::c_char)
     -> *mut grn_file_reader;
    pub fn grn_file_reader_close(ctx: *mut grn_ctx,
                                 reader: *mut grn_file_reader);
    pub fn grn_file_reader_read_line(ctx: *mut grn_ctx,
                                     reader: *mut grn_file_reader,
                                     buffer: *mut grn_obj) -> grn_rc;
    pub fn grn_geo_table_sort(ctx: *mut grn_ctx, table: *mut grn_obj,
                              offset: ::std::os::raw::c_int,
                              limit: ::std::os::raw::c_int,
                              result: *mut grn_obj, column: *mut grn_obj,
                              geo_point: *mut grn_obj)
     -> ::std::os::raw::c_int;
    pub fn grn_hash_create(ctx: *mut grn_ctx,
                           path: *const ::std::os::raw::c_char,
                           key_size: ::std::os::raw::c_uint,
                           value_size: ::std::os::raw::c_uint,
                           flags: ::std::os::raw::c_uint) -> *mut grn_hash;
    pub fn grn_hash_open(ctx: *mut grn_ctx,
                         path: *const ::std::os::raw::c_char)
     -> *mut grn_hash;
    pub fn grn_hash_close(ctx: *mut grn_ctx, hash: *mut grn_hash) -> grn_rc;
    pub fn grn_hash_add(ctx: *mut grn_ctx, hash: *mut grn_hash,
                        key: *const ::std::os::raw::c_void,
                        key_size: ::std::os::raw::c_uint,
                        value: *mut *mut ::std::os::raw::c_void,
                        added: *mut ::std::os::raw::c_int) -> grn_id;
    pub fn grn_hash_get(ctx: *mut grn_ctx, hash: *mut grn_hash,
                        key: *const ::std::os::raw::c_void,
                        key_size: ::std::os::raw::c_uint,
                        value: *mut *mut ::std::os::raw::c_void) -> grn_id;
    pub fn grn_hash_get_key(ctx: *mut grn_ctx, hash: *mut grn_hash,
                            id: grn_id, keybuf: *mut ::std::os::raw::c_void,
                            bufsize: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_hash_get_key2(ctx: *mut grn_ctx, hash: *mut grn_hash,
                             id: grn_id, bulk: *mut grn_obj)
     -> ::std::os::raw::c_int;
    pub fn grn_hash_get_value(ctx: *mut grn_ctx, hash: *mut grn_hash,
                              id: grn_id,
                              valuebuf: *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_hash_set_value(ctx: *mut grn_ctx, hash: *mut grn_hash,
                              id: grn_id,
                              value: *const ::std::os::raw::c_void,
                              flags: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_hash_delete_by_id(ctx: *mut grn_ctx, hash: *mut grn_hash,
                                 id: grn_id,
                                 optarg: *mut grn_table_delete_optarg)
     -> grn_rc;
    pub fn grn_hash_delete(ctx: *mut grn_ctx, hash: *mut grn_hash,
                           key: *const ::std::os::raw::c_void,
                           key_size: ::std::os::raw::c_uint,
                           optarg: *mut grn_table_delete_optarg) -> grn_rc;
    pub fn grn_hash_size(ctx: *mut grn_ctx, hash: *mut grn_hash) -> uint32_t;
    pub fn grn_hash_cursor_open(ctx: *mut grn_ctx, hash: *mut grn_hash,
                                min: *const ::std::os::raw::c_void,
                                min_size: ::std::os::raw::c_uint,
                                max: *const ::std::os::raw::c_void,
                                max_size: ::std::os::raw::c_uint,
                                offset: ::std::os::raw::c_int,
                                limit: ::std::os::raw::c_int,
                                flags: ::std::os::raw::c_int)
     -> *mut grn_hash_cursor;
    pub fn grn_hash_cursor_next(ctx: *mut grn_ctx, c: *mut grn_hash_cursor)
     -> grn_id;
    pub fn grn_hash_cursor_close(ctx: *mut grn_ctx, c: *mut grn_hash_cursor);
    pub fn grn_hash_cursor_get_key(ctx: *mut grn_ctx, c: *mut grn_hash_cursor,
                                   key: *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_hash_cursor_get_value(ctx: *mut grn_ctx,
                                     c: *mut grn_hash_cursor,
                                     value: *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_hash_cursor_set_value(ctx: *mut grn_ctx,
                                     c: *mut grn_hash_cursor,
                                     value: *const ::std::os::raw::c_void,
                                     flags: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_hash_cursor_get_key_value(ctx: *mut grn_ctx,
                                         c: *mut grn_hash_cursor,
                                         key:
                                             *mut *mut ::std::os::raw::c_void,
                                         key_size:
                                             *mut ::std::os::raw::c_uint,
                                         value:
                                             *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_hash_cursor_delete(ctx: *mut grn_ctx, c: *mut grn_hash_cursor,
                                  optarg: *mut grn_table_delete_optarg)
     -> grn_rc;
    pub fn grn_id_is_builtin(ctx: *mut grn_ctx, id: grn_id) -> grn_bool;
    pub fn grn_ii_estimate_size(ctx: *mut grn_ctx, ii: *mut grn_ii,
                                tid: grn_id) -> uint32_t;
    pub fn grn_ii_estimate_size_for_query(ctx: *mut grn_ctx, ii: *mut grn_ii,
                                          query:
                                              *const ::std::os::raw::c_char,
                                          query_len: ::std::os::raw::c_uint,
                                          optarg: *mut grn_search_optarg)
     -> uint32_t;
    pub fn grn_ii_estimate_size_for_lexicon_cursor(ctx: *mut grn_ctx,
                                                   ii: *mut grn_ii,
                                                   lexicon_cursor:
                                                       *mut grn_table_cursor)
     -> uint32_t;
    pub fn grn_ii_buffer_open(ctx: *mut grn_ctx, ii: *mut grn_ii,
                              update_buffer_size: ::std::os::raw::c_ulonglong)
     -> *mut grn_ii_buffer;
    pub fn grn_ii_buffer_append(ctx: *mut grn_ctx,
                                ii_buffer: *mut grn_ii_buffer, rid: grn_id,
                                section: ::std::os::raw::c_uint,
                                value: *mut grn_obj) -> grn_rc;
    pub fn grn_ii_buffer_commit(ctx: *mut grn_ctx,
                                ii_buffer: *mut grn_ii_buffer) -> grn_rc;
    pub fn grn_ii_buffer_close(ctx: *mut grn_ctx,
                               ii_buffer: *mut grn_ii_buffer) -> grn_rc;
    pub fn grn_ii_cursor_open(ctx: *mut grn_ctx, ii: *mut grn_ii, tid: grn_id,
                              min: grn_id, max: grn_id,
                              nelements: ::std::os::raw::c_int,
                              flags: ::std::os::raw::c_int)
     -> *mut grn_ii_cursor;
    pub fn grn_ii_cursor_next(ctx: *mut grn_ctx, c: *mut grn_ii_cursor)
     -> *mut grn_posting;
    pub fn grn_ii_cursor_close(ctx: *mut grn_ctx, c: *mut grn_ii_cursor)
     -> grn_rc;
    pub fn grn_obj_is_true(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
    pub fn grn_obj_is_builtin(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_table(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
    pub fn grn_obj_is_column(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_reference_column(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_index_column(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_accessor(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_key_accessor(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_type(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
    pub fn grn_obj_is_text_family_type(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_proc(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
    pub fn grn_obj_is_tokenizer_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_function_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_selector_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_selector_only_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_normalizer_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_token_filter_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_scorer_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> grn_bool;
    pub fn grn_obj_is_window_function_proc(ctx: *mut grn_ctx,
                                           obj: *mut grn_obj) -> grn_bool;
    pub fn grn_obj_cast(ctx: *mut grn_ctx, src: *mut grn_obj,
                        dest: *mut grn_obj, add_record_if_not_exist: grn_bool)
     -> grn_rc;
    pub fn grn_obj_reindex(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
    pub fn grn_obj_touch(ctx: *mut grn_ctx, obj: *mut grn_obj,
                         tv: *mut grn_timeval);
    pub fn grn_obj_get_last_modified(ctx: *mut grn_ctx, obj: *mut grn_obj)
     -> uint32_t;
    pub fn grn_obj_is_dirty(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
    pub fn grn_obj_type_to_string(type_: uint8_t)
     -> *const ::std::os::raw::c_char;
    pub fn grn_obj_name_is_column(ctx: *mut grn_ctx,
                                  name: *const ::std::os::raw::c_char,
                                  name_len: ::std::os::raw::c_int)
     -> grn_bool;
    pub fn grn_operator_to_string(op: grn_operator)
     -> *const ::std::os::raw::c_char;
    pub fn grn_operator_exec_equal(ctx: *mut grn_ctx, x: *mut grn_obj,
                                   y: *mut grn_obj) -> grn_bool;
    pub fn grn_operator_exec_not_equal(ctx: *mut grn_ctx, x: *mut grn_obj,
                                       y: *mut grn_obj) -> grn_bool;
    pub fn grn_operator_exec_less(ctx: *mut grn_ctx, x: *mut grn_obj,
                                  y: *mut grn_obj) -> grn_bool;
    pub fn grn_operator_exec_greater(ctx: *mut grn_ctx, x: *mut grn_obj,
                                     y: *mut grn_obj) -> grn_bool;
    pub fn grn_operator_exec_less_equal(ctx: *mut grn_ctx, x: *mut grn_obj,
                                        y: *mut grn_obj) -> grn_bool;
    pub fn grn_operator_exec_greater_equal(ctx: *mut grn_ctx, x: *mut grn_obj,
                                           y: *mut grn_obj) -> grn_bool;
    pub fn grn_operator_exec_match(ctx: *mut grn_ctx, target: *mut grn_obj,
                                   sub_text: *mut grn_obj) -> grn_bool;
    pub fn grn_operator_exec_prefix(ctx: *mut grn_ctx, target: *mut grn_obj,
                                    prefix: *mut grn_obj) -> grn_bool;
    pub fn grn_operator_exec_regexp(ctx: *mut grn_ctx, target: *mut grn_obj,
                                    pattern: *mut grn_obj) -> grn_bool;
    pub fn grn_output_obj(ctx: *mut grn_ctx, outbuf: *mut grn_obj,
                          output_type: grn_content_type, obj: *mut grn_obj,
                          format: *mut grn_obj_format);
    pub fn grn_output_envelope(ctx: *mut grn_ctx, rc: grn_rc,
                               head: *mut grn_obj, body: *mut grn_obj,
                               foot: *mut grn_obj,
                               file: *const ::std::os::raw::c_char,
                               line: ::std::os::raw::c_int);
    pub fn grn_ctx_output_flush(ctx: *mut grn_ctx,
                                flags: ::std::os::raw::c_int);
    pub fn grn_ctx_output_array_open(ctx: *mut grn_ctx,
                                     name: *const ::std::os::raw::c_char,
                                     nelements: ::std::os::raw::c_int);
    pub fn grn_ctx_output_array_close(ctx: *mut grn_ctx);
    pub fn grn_ctx_output_map_open(ctx: *mut grn_ctx,
                                   name: *const ::std::os::raw::c_char,
                                   nelements: ::std::os::raw::c_int);
    pub fn grn_ctx_output_map_close(ctx: *mut grn_ctx);
    pub fn grn_ctx_output_null(ctx: *mut grn_ctx);
    pub fn grn_ctx_output_int32(ctx: *mut grn_ctx,
                                value: ::std::os::raw::c_int);
    pub fn grn_ctx_output_int64(ctx: *mut grn_ctx, value: int64_t);
    pub fn grn_ctx_output_uint64(ctx: *mut grn_ctx, value: uint64_t);
    pub fn grn_ctx_output_float(ctx: *mut grn_ctx, value: f64);
    pub fn grn_ctx_output_cstr(ctx: *mut grn_ctx,
                               value: *const ::std::os::raw::c_char);
    pub fn grn_ctx_output_str(ctx: *mut grn_ctx,
                              value: *const ::std::os::raw::c_char,
                              value_len: ::std::os::raw::c_uint);
    pub fn grn_ctx_output_bool(ctx: *mut grn_ctx, value: grn_bool);
    pub fn grn_ctx_output_obj(ctx: *mut grn_ctx, value: *mut grn_obj,
                              format: *mut grn_obj_format);
    pub fn grn_ctx_output_result_set_open(ctx: *mut grn_ctx,
                                          result_set: *mut grn_obj,
                                          format: *mut grn_obj_format,
                                          n_additional_elements: uint32_t);
    pub fn grn_ctx_output_result_set_close(ctx: *mut grn_ctx,
                                           result_set: *mut grn_obj,
                                           format: *mut grn_obj_format);
    pub fn grn_ctx_output_result_set(ctx: *mut grn_ctx,
                                     result_set: *mut grn_obj,
                                     format: *mut grn_obj_format);
    pub fn grn_ctx_output_table_columns(ctx: *mut grn_ctx,
                                        table: *mut grn_obj,
                                        format: *mut grn_obj_format);
    pub fn grn_ctx_output_table_records(ctx: *mut grn_ctx,
                                        table: *mut grn_obj,
                                        format: *mut grn_obj_format);
    pub fn grn_ctx_get_output_type(ctx: *mut grn_ctx) -> grn_content_type;
    pub fn grn_ctx_set_output_type(ctx: *mut grn_ctx, type_: grn_content_type)
     -> grn_rc;
    pub fn grn_ctx_get_mime_type(ctx: *mut grn_ctx)
     -> *const ::std::os::raw::c_char;
    pub fn grn_text_otoj(ctx: *mut grn_ctx, bulk: *mut grn_obj,
                         obj: *mut grn_obj, format: *mut grn_obj_format)
     -> grn_rc;
    pub fn grn_pat_create(ctx: *mut grn_ctx,
                          path: *const ::std::os::raw::c_char,
                          key_size: ::std::os::raw::c_uint,
                          value_size: ::std::os::raw::c_uint,
                          flags: ::std::os::raw::c_uint) -> *mut grn_pat;
    pub fn grn_pat_open(ctx: *mut grn_ctx,
                        path: *const ::std::os::raw::c_char) -> *mut grn_pat;
    pub fn grn_pat_close(ctx: *mut grn_ctx, pat: *mut grn_pat) -> grn_rc;
    pub fn grn_pat_remove(ctx: *mut grn_ctx,
                          path: *const ::std::os::raw::c_char) -> grn_rc;
    pub fn grn_pat_get(ctx: *mut grn_ctx, pat: *mut grn_pat,
                       key: *const ::std::os::raw::c_void,
                       key_size: ::std::os::raw::c_uint,
                       value: *mut *mut ::std::os::raw::c_void) -> grn_id;
    pub fn grn_pat_add(ctx: *mut grn_ctx, pat: *mut grn_pat,
                       key: *const ::std::os::raw::c_void,
                       key_size: ::std::os::raw::c_uint,
                       value: *mut *mut ::std::os::raw::c_void,
                       added: *mut ::std::os::raw::c_int) -> grn_id;
    pub fn grn_pat_get_key(ctx: *mut grn_ctx, pat: *mut grn_pat, id: grn_id,
                           keybuf: *mut ::std::os::raw::c_void,
                           bufsize: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_pat_get_key2(ctx: *mut grn_ctx, pat: *mut grn_pat, id: grn_id,
                            bulk: *mut grn_obj) -> ::std::os::raw::c_int;
    pub fn grn_pat_get_value(ctx: *mut grn_ctx, pat: *mut grn_pat, id: grn_id,
                             valuebuf: *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_pat_set_value(ctx: *mut grn_ctx, pat: *mut grn_pat, id: grn_id,
                             value: *const ::std::os::raw::c_void,
                             flags: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_pat_delete_by_id(ctx: *mut grn_ctx, pat: *mut grn_pat,
                                id: grn_id,
                                optarg: *mut grn_table_delete_optarg)
     -> grn_rc;
    pub fn grn_pat_delete(ctx: *mut grn_ctx, pat: *mut grn_pat,
                          key: *const ::std::os::raw::c_void,
                          key_size: ::std::os::raw::c_uint,
                          optarg: *mut grn_table_delete_optarg) -> grn_rc;
    pub fn grn_pat_delete_with_sis(ctx: *mut grn_ctx, pat: *mut grn_pat,
                                   id: grn_id,
                                   optarg: *mut grn_table_delete_optarg)
     -> ::std::os::raw::c_int;
    pub fn grn_pat_scan(ctx: *mut grn_ctx, pat: *mut grn_pat,
                        str: *const ::std::os::raw::c_char,
                        str_len: ::std::os::raw::c_uint,
                        sh: *mut grn_pat_scan_hit,
                        sh_size: ::std::os::raw::c_uint,
                        rest: *mut *const ::std::os::raw::c_char)
     -> ::std::os::raw::c_int;
    pub fn grn_pat_prefix_search(ctx: *mut grn_ctx, pat: *mut grn_pat,
                                 key: *const ::std::os::raw::c_void,
                                 key_size: ::std::os::raw::c_uint,
                                 h: *mut grn_hash) -> grn_rc;
    pub fn grn_pat_suffix_search(ctx: *mut grn_ctx, pat: *mut grn_pat,
                                 key: *const ::std::os::raw::c_void,
                                 key_size: ::std::os::raw::c_uint,
                                 h: *mut grn_hash) -> grn_rc;
    pub fn grn_pat_lcp_search(ctx: *mut grn_ctx, pat: *mut grn_pat,
                              key: *const ::std::os::raw::c_void,
                              key_size: ::std::os::raw::c_uint) -> grn_id;
    pub fn grn_pat_size(ctx: *mut grn_ctx, pat: *mut grn_pat)
     -> ::std::os::raw::c_uint;
    pub fn grn_pat_cursor_open(ctx: *mut grn_ctx, pat: *mut grn_pat,
                               min: *const ::std::os::raw::c_void,
                               min_size: ::std::os::raw::c_uint,
                               max: *const ::std::os::raw::c_void,
                               max_size: ::std::os::raw::c_uint,
                               offset: ::std::os::raw::c_int,
                               limit: ::std::os::raw::c_int,
                               flags: ::std::os::raw::c_int)
     -> *mut grn_pat_cursor;
    pub fn grn_pat_cursor_next(ctx: *mut grn_ctx, c: *mut grn_pat_cursor)
     -> grn_id;
    pub fn grn_pat_cursor_close(ctx: *mut grn_ctx, c: *mut grn_pat_cursor);
    pub fn grn_pat_cursor_get_key(ctx: *mut grn_ctx, c: *mut grn_pat_cursor,
                                  key: *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_pat_cursor_get_value(ctx: *mut grn_ctx, c: *mut grn_pat_cursor,
                                    value: *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_pat_cursor_get_key_value(ctx: *mut grn_ctx,
                                        c: *mut grn_pat_cursor,
                                        key: *mut *mut ::std::os::raw::c_void,
                                        key_size: *mut ::std::os::raw::c_uint,
                                        value:
                                            *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_pat_cursor_set_value(ctx: *mut grn_ctx, c: *mut grn_pat_cursor,
                                    value: *const ::std::os::raw::c_void,
                                    flags: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_pat_cursor_delete(ctx: *mut grn_ctx, c: *mut grn_pat_cursor,
                                 optarg: *mut grn_table_delete_optarg)
     -> grn_rc;
    pub fn grn_request_canceler_register(ctx: *mut grn_ctx,
                                         request_id:
                                             *const ::std::os::raw::c_char,
                                         size: ::std::os::raw::c_uint);
    pub fn grn_request_canceler_unregister(ctx: *mut grn_ctx,
                                           request_id:
                                               *const ::std::os::raw::c_char,
                                           size: ::std::os::raw::c_uint);
    pub fn grn_request_canceler_cancel(request_id:
                                           *const ::std::os::raw::c_char,
                                       size: ::std::os::raw::c_uint)
     -> grn_bool;
    pub fn grn_request_canceler_cancel_all() -> grn_bool;
    pub fn grn_request_timer_set(timer: *mut grn_request_timer);
    pub fn grn_request_timer_register(request_id:
                                          *const ::std::os::raw::c_char,
                                      request_id_size: ::std::os::raw::c_uint,
                                      timeout: f64)
     -> *mut ::std::os::raw::c_void;
    pub fn grn_request_timer_unregister(timer_id:
                                            *mut ::std::os::raw::c_void);
    pub fn grn_get_default_request_timeout() -> f64;
    pub fn grn_set_default_request_timeout(timeout: f64);
    pub fn grn_table_create(ctx: *mut grn_ctx,
                            name: *const ::std::os::raw::c_char,
                            name_size: ::std::os::raw::c_uint,
                            path: *const ::std::os::raw::c_char,
                            flags: grn_table_flags, key_type: *mut grn_obj,
                            value_type: *mut grn_obj) -> *mut grn_obj;
    pub fn grn_table_add(ctx: *mut grn_ctx, table: *mut grn_obj,
                         key: *const ::std::os::raw::c_void,
                         key_size: ::std::os::raw::c_uint,
                         added: *mut ::std::os::raw::c_int) -> grn_id;
    pub fn grn_table_get(ctx: *mut grn_ctx, table: *mut grn_obj,
                         key: *const ::std::os::raw::c_void,
                         key_size: ::std::os::raw::c_uint) -> grn_id;
    pub fn grn_table_at(ctx: *mut grn_ctx, table: *mut grn_obj, id: grn_id)
     -> grn_id;
    pub fn grn_table_lcp_search(ctx: *mut grn_ctx, table: *mut grn_obj,
                                key: *const ::std::os::raw::c_void,
                                key_size: ::std::os::raw::c_uint) -> grn_id;
    pub fn grn_table_get_key(ctx: *mut grn_ctx, table: *mut grn_obj,
                             id: grn_id, keybuf: *mut ::std::os::raw::c_void,
                             buf_size: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_table_delete(ctx: *mut grn_ctx, table: *mut grn_obj,
                            key: *const ::std::os::raw::c_void,
                            key_size: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_table_delete_by_id(ctx: *mut grn_ctx, table: *mut grn_obj,
                                  id: grn_id) -> grn_rc;
    pub fn grn_table_update_by_id(ctx: *mut grn_ctx, table: *mut grn_obj,
                                  id: grn_id,
                                  dest_key: *const ::std::os::raw::c_void,
                                  dest_key_size: ::std::os::raw::c_uint)
     -> grn_rc;
    pub fn grn_table_update(ctx: *mut grn_ctx, table: *mut grn_obj,
                            src_key: *const ::std::os::raw::c_void,
                            src_key_size: ::std::os::raw::c_uint,
                            dest_key: *const ::std::os::raw::c_void,
                            dest_key_size: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_table_truncate(ctx: *mut grn_ctx, table: *mut grn_obj)
     -> grn_rc;
    pub fn grn_table_cursor_open(ctx: *mut grn_ctx, table: *mut grn_obj,
                                 min: *const ::std::os::raw::c_void,
                                 min_size: ::std::os::raw::c_uint,
                                 max: *const ::std::os::raw::c_void,
                                 max_size: ::std::os::raw::c_uint,
                                 offset: ::std::os::raw::c_int,
                                 limit: ::std::os::raw::c_int,
                                 flags: ::std::os::raw::c_int)
     -> *mut grn_table_cursor;
    pub fn grn_table_cursor_close(ctx: *mut grn_ctx,
                                  tc: *mut grn_table_cursor) -> grn_rc;
    pub fn grn_table_cursor_next(ctx: *mut grn_ctx, tc: *mut grn_table_cursor)
     -> grn_id;
    pub fn grn_table_cursor_get_key(ctx: *mut grn_ctx,
                                    tc: *mut grn_table_cursor,
                                    key: *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_table_cursor_get_value(ctx: *mut grn_ctx,
                                      tc: *mut grn_table_cursor,
                                      value: *mut *mut ::std::os::raw::c_void)
     -> ::std::os::raw::c_int;
    pub fn grn_table_cursor_set_value(ctx: *mut grn_ctx,
                                      tc: *mut grn_table_cursor,
                                      value: *const ::std::os::raw::c_void,
                                      flags: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_table_cursor_delete(ctx: *mut grn_ctx,
                                   tc: *mut grn_table_cursor) -> grn_rc;
    pub fn grn_table_cursor_table(ctx: *mut grn_ctx,
                                  tc: *mut grn_table_cursor) -> *mut grn_obj;
    pub fn grn_index_cursor_open(ctx: *mut grn_ctx, tc: *mut grn_table_cursor,
                                 index: *mut grn_obj, rid_min: grn_id,
                                 rid_max: grn_id,
                                 flags: ::std::os::raw::c_int)
     -> *mut grn_obj;
    pub fn grn_index_cursor_next(ctx: *mut grn_ctx, ic: *mut grn_obj,
                                 tid: *mut grn_id) -> *mut grn_posting;
    pub fn grn_table_sort(ctx: *mut grn_ctx, table: *mut grn_obj,
                          offset: ::std::os::raw::c_int,
                          limit: ::std::os::raw::c_int, result: *mut grn_obj,
                          keys: *mut grn_table_sort_key,
                          n_keys: ::std::os::raw::c_int)
     -> ::std::os::raw::c_int;
    pub fn grn_table_group(ctx: *mut grn_ctx, table: *mut grn_obj,
                           keys: *mut grn_table_sort_key,
                           n_keys: ::std::os::raw::c_int,
                           results: *mut grn_table_group_result,
                           n_results: ::std::os::raw::c_int) -> grn_rc;
    pub fn grn_table_setoperation(ctx: *mut grn_ctx, table1: *mut grn_obj,
                                  table2: *mut grn_obj, res: *mut grn_obj,
                                  op: grn_operator) -> grn_rc;
    pub fn grn_table_difference(ctx: *mut grn_ctx, table1: *mut grn_obj,
                                table2: *mut grn_obj, res1: *mut grn_obj,
                                res2: *mut grn_obj) -> grn_rc;
    pub fn grn_table_columns(ctx: *mut grn_ctx, table: *mut grn_obj,
                             name: *const ::std::os::raw::c_char,
                             name_size: ::std::os::raw::c_uint,
                             res: *mut grn_obj) -> ::std::os::raw::c_int;
    pub fn grn_table_size(ctx: *mut grn_ctx, table: *mut grn_obj)
     -> ::std::os::raw::c_uint;
    pub fn grn_table_select(ctx: *mut grn_ctx, table: *mut grn_obj,
                            expr: *mut grn_obj, res: *mut grn_obj,
                            op: grn_operator) -> *mut grn_obj;
    pub fn grn_table_sort_key_from_str(ctx: *mut grn_ctx,
                                       str: *const ::std::os::raw::c_char,
                                       str_size: ::std::os::raw::c_uint,
                                       table: *mut grn_obj,
                                       nkeys: *mut ::std::os::raw::c_uint)
     -> *mut grn_table_sort_key;
    pub fn grn_table_sort_key_close(ctx: *mut grn_ctx,
                                    keys: *mut grn_table_sort_key,
                                    nkeys: ::std::os::raw::c_uint) -> grn_rc;
    pub fn grn_table_is_grouped(ctx: *mut grn_ctx, table: *mut grn_obj)
     -> grn_bool;
    pub fn grn_table_max_n_subrecs(ctx: *mut grn_ctx, table: *mut grn_obj)
     -> ::std::os::raw::c_uint;
    pub fn grn_table_create_for_group(ctx: *mut grn_ctx,
                                      name: *const ::std::os::raw::c_char,
                                      name_size: ::std::os::raw::c_uint,
                                      path: *const ::std::os::raw::c_char,
                                      group_key: *mut grn_obj,
                                      value_type: *mut grn_obj,
                                      max_n_subrecs: ::std::os::raw::c_uint)
     -> *mut grn_obj;
    pub fn grn_table_get_subrecs(ctx: *mut grn_ctx, table: *mut grn_obj,
                                 id: grn_id, subrecbuf: *mut grn_id,
                                 scorebuf: *mut ::std::os::raw::c_int,
                                 buf_size: ::std::os::raw::c_int)
     -> ::std::os::raw::c_uint;
    pub fn grn_table_tokenize(ctx: *mut grn_ctx, table: *mut grn_obj,
                              str: *const ::std::os::raw::c_char,
                              str_len: ::std::os::raw::c_uint,
                              buf: *mut grn_obj, addp: grn_bool)
     -> *mut grn_obj;
    pub fn grn_thread_get_limit() -> uint32_t;
    pub fn grn_thread_set_limit(new_limit: uint32_t);
    pub fn grn_thread_set_get_limit_func(func: grn_thread_get_limit_func,
                                         data: *mut ::std::os::raw::c_void);
    pub fn grn_thread_set_set_limit_func(func: grn_thread_set_limit_func,
                                         data: *mut ::std::os::raw::c_void);
    // pub fn grn_timeval_now(ctx: *mut grn_ctx, tv: *mut grn_timeval) -> grn_rc;
    // pub fn grn_time_now(ctx: *mut grn_ctx, obj: *mut grn_obj);
    // pub fn grn_time_to_tm(ctx: *mut grn_ctx, time: int64_t, tm: *mut tm)
    //  -> grn_bool;
    // pub fn grn_time_from_tm(ctx: *mut grn_ctx, time: *mut int64_t,
    //                         tm: *mut tm) -> grn_bool;
    pub fn grn_type_id_is_builtin(ctx: *mut grn_ctx, id: grn_id) -> grn_bool;
    pub fn grn_type_id_is_number_family(ctx: *mut grn_ctx, id: grn_id)
     -> grn_bool;
    pub fn grn_type_id_is_text_family(ctx: *mut grn_ctx, id: grn_id)
     -> grn_bool;
    pub fn grn_type_create(ctx: *mut grn_ctx,
                           name: *const ::std::os::raw::c_char,
                           name_size: ::std::os::raw::c_uint,
                           flags: grn_obj_flags, size: ::std::os::raw::c_uint)
     -> *mut grn_obj;
    pub fn grn_type_size(ctx: *mut grn_ctx, type_: *mut grn_obj) -> uint32_t;
    pub fn grn_inspect(ctx: *mut grn_ctx, buffer: *mut grn_obj,
                       obj: *mut grn_obj) -> *mut grn_obj;
    pub fn grn_inspect_indented(ctx: *mut grn_ctx, buffer: *mut grn_obj,
                                obj: *mut grn_obj,
                                indent: *const ::std::os::raw::c_char)
     -> *mut grn_obj;
    pub fn grn_inspect_name(ctx: *mut grn_ctx, buffer: *mut grn_obj,
                            obj: *mut grn_obj) -> *mut grn_obj;
    pub fn grn_inspect_encoding(ctx: *mut grn_ctx, buffer: *mut grn_obj,
                                encoding: grn_encoding) -> *mut grn_obj;
    pub fn grn_inspect_type(ctx: *mut grn_ctx, buffer: *mut grn_obj,
                            type_: ::std::os::raw::c_uchar) -> *mut grn_obj;
    pub fn grn_p(ctx: *mut grn_ctx, obj: *mut grn_obj);
    pub fn grn_p_geo_point(ctx: *mut grn_ctx, point: *mut grn_geo_point);
    pub fn grn_p_ii_values(ctx: *mut grn_ctx, obj: *mut grn_obj);
    pub fn grn_window_next(ctx: *mut grn_ctx, window: *mut grn_window)
     -> grn_id;
    pub fn grn_window_rewind(ctx: *mut grn_ctx, window: *mut grn_window)
     -> grn_rc;
    pub fn grn_window_set_direction(ctx: *mut grn_ctx,
                                    window: *mut grn_window,
                                    direction: grn_window_direction)
     -> grn_rc;
    pub fn grn_window_get_table(ctx: *mut grn_ctx, window: *mut grn_window)
     -> *mut grn_obj;
    pub fn grn_window_function_create(ctx: *mut grn_ctx,
                                      name: *const ::std::os::raw::c_char,
                                      name_size: ::std::os::raw::c_int,
                                      func: grn_window_function_func)
     -> *mut grn_obj;
    pub fn grn_table_apply_window_function(ctx: *mut grn_ctx,
                                           table: *mut grn_obj,
                                           output_column: *mut grn_obj,
                                           definition:
                                               *mut grn_window_definition,
                                           window_function_call: *mut grn_obj)
     -> grn_rc;
    pub fn grn_windows_event_logger_set(ctx: *mut grn_ctx,
                                        event_source_name:
                                            *const ::std::os::raw::c_char)
     -> grn_rc;
}