1 /*
2   Copyright(C) 2009-2018  Brazil
3   Copyright(C) 2018-2021  Sutou Kouhei <kou@clear-code.com>
4 
5   This library is free software; you can redistribute it and/or
6   modify it under the terms of the GNU Lesser General Public
7   License as published by the Free Software Foundation; either
8   version 2.1 of the License, or (at your option) any later version.
9 
10   This library is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13   Lesser General Public License for more details.
14 
15   You should have received a copy of the GNU Lesser General Public
16   License along with this library; if not, write to the Free Software
17   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18 */
19 module groonga_d.groonga;
20 
21 
22 private static import core.stdc.config;
23 private static import core.stdc.stdarg;
24 private static import core.sys.posix.sys.types;
25 
26 extern(C):
27 nothrow @nogc:
28 
29 //ToDo: temp
30 version (Windows) {
31 	alias off_t = core.stdc.config.c_ulong;
32 } else {
33 	alias off_t = core.sys.posix.sys.types.off_t;
34 }
35 
36 /+
37 #ifndef GRN_API
38 # if defined(_WIN32) || defined(_WIN64)
39 #  define GRN_API __declspec(dllimport)
40 # else
41 #  define GRN_API
42 # endif /* defined(_WIN32) || defined(_WIN64) */
43 #endif /* GRN_API */
44 +/
45 
46 alias grn_id = uint;
47 /* Deprecated since 9.0.2. Use bool directly. */
48 deprecated alias grn_bool = bool;
49 
50 enum GRN_ID_NIL = 0x00;
51 enum GRN_ID_MAX = 0x3FFFFFFF;
52 
53 enum GRN_TRUE = true;
54 enum GRN_FALSE = false;
55 
56 enum grn_rc
57 {
58 	GRN_SUCCESS = 0,
59 	GRN_END_OF_DATA = 1,
60 	GRN_UNKNOWN_ERROR = -1,
61 	GRN_OPERATION_NOT_PERMITTED = -2,
62 	GRN_NO_SUCH_FILE_OR_DIRECTORY = -3,
63 	GRN_NO_SUCH_PROCESS = -4,
64 	GRN_INTERRUPTED_FUNCTION_CALL = -5,
65 	GRN_INPUT_OUTPUT_ERROR = -6,
66 	GRN_NO_SUCH_DEVICE_OR_ADDRESS = -7,
67 	GRN_ARG_LIST_TOO_LONG = -8,
68 	GRN_EXEC_FORMAT_ERROR = -9,
69 	GRN_BAD_FILE_DESCRIPTOR = -10,
70 	GRN_NO_CHILD_PROCESSES = -11,
71 	GRN_RESOURCE_TEMPORARILY_UNAVAILABLE = -12,
72 	GRN_NOT_ENOUGH_SPACE = -13,
73 	GRN_PERMISSION_DENIED = -14,
74 	GRN_BAD_ADDRESS = -15,
75 	GRN_RESOURCE_BUSY = -16,
76 	GRN_FILE_EXISTS = -17,
77 	GRN_IMPROPER_LINK = -18,
78 	GRN_NO_SUCH_DEVICE = -19,
79 	GRN_NOT_A_DIRECTORY = -20,
80 	GRN_IS_A_DIRECTORY = -21,
81 	GRN_INVALID_ARGUMENT = -22,
82 	GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM = -23,
83 	GRN_TOO_MANY_OPEN_FILES = -24,
84 	GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION = -25,
85 	GRN_FILE_TOO_LARGE = -26,
86 	GRN_NO_SPACE_LEFT_ON_DEVICE = -27,
87 	GRN_INVALID_SEEK = -28,
88 	GRN_READ_ONLY_FILE_SYSTEM = -29,
89 	GRN_TOO_MANY_LINKS = -30,
90 	GRN_BROKEN_PIPE = -31,
91 	GRN_DOMAIN_ERROR = -32,
92 	GRN_RESULT_TOO_LARGE = -33,
93 	GRN_RESOURCE_DEADLOCK_AVOIDED = -34,
94 	GRN_NO_MEMORY_AVAILABLE = -35,
95 	GRN_FILENAME_TOO_LONG = -36,
96 	GRN_NO_LOCKS_AVAILABLE = -37,
97 	GRN_FUNCTION_NOT_IMPLEMENTED = -38,
98 	GRN_DIRECTORY_NOT_EMPTY = -39,
99 	GRN_ILLEGAL_BYTE_SEQUENCE = -40,
100 	GRN_SOCKET_NOT_INITIALIZED = -41,
101 	GRN_OPERATION_WOULD_BLOCK = -42,
102 	GRN_ADDRESS_IS_NOT_AVAILABLE = -43,
103 	GRN_NETWORK_IS_DOWN = -44,
104 	GRN_NO_BUFFER = -45,
105 	GRN_SOCKET_IS_ALREADY_CONNECTED = -46,
106 	GRN_SOCKET_IS_NOT_CONNECTED = -47,
107 	GRN_SOCKET_IS_ALREADY_SHUTDOWNED = -48,
108 	GRN_OPERATION_TIMEOUT = -49,
109 	GRN_CONNECTION_REFUSED = -50,
110 	GRN_RANGE_ERROR = -51,
111 	GRN_TOKENIZER_ERROR = -52,
112 	GRN_FILE_CORRUPT = -53,
113 	GRN_INVALID_FORMAT = -54,
114 	GRN_OBJECT_CORRUPT = -55,
115 	GRN_TOO_MANY_SYMBOLIC_LINKS = -56,
116 	GRN_NOT_SOCKET = -57,
117 	GRN_OPERATION_NOT_SUPPORTED = -58,
118 	GRN_ADDRESS_IS_IN_USE = -59,
119 	GRN_ZLIB_ERROR = -60,
120 	GRN_LZ4_ERROR = -61,
121 
122 	/**
123 	 * Just for backward compatibility. We'll remove it at 5.0.0.
124 	 */
125 	GRN_LZO_ERROR = GRN_LZ4_ERROR,
126 
127 	GRN_STACK_OVER_FLOW = -62,
128 	GRN_SYNTAX_ERROR = -63,
129 	GRN_RETRY_MAX = -64,
130 	GRN_INCOMPATIBLE_FILE_FORMAT = -65,
131 	GRN_UPDATE_NOT_ALLOWED = -66,
132 	GRN_TOO_SMALL_OFFSET = -67,
133 	GRN_TOO_LARGE_OFFSET = -68,
134 	GRN_TOO_SMALL_LIMIT = -69,
135 	GRN_CAS_ERROR = -70,
136 	GRN_UNSUPPORTED_COMMAND_VERSION = -71,
137 	GRN_NORMALIZER_ERROR = -72,
138 	GRN_TOKEN_FILTER_ERROR = -73,
139 	GRN_COMMAND_ERROR = -74,
140 	GRN_PLUGIN_ERROR = -75,
141 	GRN_SCORER_ERROR = -76,
142 	GRN_CANCEL = -77,
143 	GRN_WINDOW_FUNCTION_ERROR = -78,
144 	GRN_ZSTD_ERROR = -79,
145 	GRN_CONNECTION_RESET = -80,
146 }
147 
148 //Declaration name in C language
149 enum
150 {
151 	GRN_SUCCESS = .grn_rc.GRN_SUCCESS,
152 	GRN_END_OF_DATA = .grn_rc.GRN_END_OF_DATA,
153 	GRN_UNKNOWN_ERROR = .grn_rc.GRN_UNKNOWN_ERROR,
154 	GRN_OPERATION_NOT_PERMITTED = .grn_rc.GRN_OPERATION_NOT_PERMITTED,
155 	GRN_NO_SUCH_FILE_OR_DIRECTORY = .grn_rc.GRN_NO_SUCH_FILE_OR_DIRECTORY,
156 	GRN_NO_SUCH_PROCESS = .grn_rc.GRN_NO_SUCH_PROCESS,
157 	GRN_INTERRUPTED_FUNCTION_CALL = .grn_rc.GRN_INTERRUPTED_FUNCTION_CALL,
158 	GRN_INPUT_OUTPUT_ERROR = .grn_rc.GRN_INPUT_OUTPUT_ERROR,
159 	GRN_NO_SUCH_DEVICE_OR_ADDRESS = .grn_rc.GRN_NO_SUCH_DEVICE_OR_ADDRESS,
160 	GRN_ARG_LIST_TOO_LONG = .grn_rc.GRN_ARG_LIST_TOO_LONG,
161 	GRN_EXEC_FORMAT_ERROR = .grn_rc.GRN_EXEC_FORMAT_ERROR,
162 	GRN_BAD_FILE_DESCRIPTOR = .grn_rc.GRN_BAD_FILE_DESCRIPTOR,
163 	GRN_NO_CHILD_PROCESSES = .grn_rc.GRN_NO_CHILD_PROCESSES,
164 	GRN_RESOURCE_TEMPORARILY_UNAVAILABLE = .grn_rc.GRN_RESOURCE_TEMPORARILY_UNAVAILABLE,
165 	GRN_NOT_ENOUGH_SPACE = .grn_rc.GRN_NOT_ENOUGH_SPACE,
166 	GRN_PERMISSION_DENIED = .grn_rc.GRN_PERMISSION_DENIED,
167 	GRN_BAD_ADDRESS = .grn_rc.GRN_BAD_ADDRESS,
168 	GRN_RESOURCE_BUSY = .grn_rc.GRN_RESOURCE_BUSY,
169 	GRN_FILE_EXISTS = .grn_rc.GRN_FILE_EXISTS,
170 	GRN_IMPROPER_LINK = .grn_rc.GRN_IMPROPER_LINK,
171 	GRN_NO_SUCH_DEVICE = .grn_rc.GRN_NO_SUCH_DEVICE,
172 	GRN_NOT_A_DIRECTORY = .grn_rc.GRN_NOT_A_DIRECTORY,
173 	GRN_IS_A_DIRECTORY = .grn_rc.GRN_IS_A_DIRECTORY,
174 	GRN_INVALID_ARGUMENT = .grn_rc.GRN_INVALID_ARGUMENT,
175 	GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM = .grn_rc.GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM,
176 	GRN_TOO_MANY_OPEN_FILES = .grn_rc.GRN_TOO_MANY_OPEN_FILES,
177 	GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION = .grn_rc.GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION,
178 	GRN_FILE_TOO_LARGE = .grn_rc.GRN_FILE_TOO_LARGE,
179 	GRN_NO_SPACE_LEFT_ON_DEVICE = .grn_rc.GRN_NO_SPACE_LEFT_ON_DEVICE,
180 	GRN_INVALID_SEEK = .grn_rc.GRN_INVALID_SEEK,
181 	GRN_READ_ONLY_FILE_SYSTEM = .grn_rc.GRN_READ_ONLY_FILE_SYSTEM,
182 	GRN_TOO_MANY_LINKS = .grn_rc.GRN_TOO_MANY_LINKS,
183 	GRN_BROKEN_PIPE = .grn_rc.GRN_BROKEN_PIPE,
184 	GRN_DOMAIN_ERROR = .grn_rc.GRN_DOMAIN_ERROR,
185 	GRN_RESULT_TOO_LARGE = .grn_rc.GRN_RESULT_TOO_LARGE,
186 	GRN_RESOURCE_DEADLOCK_AVOIDED = .grn_rc.GRN_RESOURCE_DEADLOCK_AVOIDED,
187 	GRN_NO_MEMORY_AVAILABLE = .grn_rc.GRN_NO_MEMORY_AVAILABLE,
188 	GRN_FILENAME_TOO_LONG = .grn_rc.GRN_FILENAME_TOO_LONG,
189 	GRN_NO_LOCKS_AVAILABLE = .grn_rc.GRN_NO_LOCKS_AVAILABLE,
190 	GRN_FUNCTION_NOT_IMPLEMENTED = .grn_rc.GRN_FUNCTION_NOT_IMPLEMENTED,
191 	GRN_DIRECTORY_NOT_EMPTY = .grn_rc.GRN_DIRECTORY_NOT_EMPTY,
192 	GRN_ILLEGAL_BYTE_SEQUENCE = .grn_rc.GRN_ILLEGAL_BYTE_SEQUENCE,
193 	GRN_SOCKET_NOT_INITIALIZED = .grn_rc.GRN_SOCKET_NOT_INITIALIZED,
194 	GRN_OPERATION_WOULD_BLOCK = .grn_rc.GRN_OPERATION_WOULD_BLOCK,
195 	GRN_ADDRESS_IS_NOT_AVAILABLE = .grn_rc.GRN_ADDRESS_IS_NOT_AVAILABLE,
196 	GRN_NETWORK_IS_DOWN = .grn_rc.GRN_NETWORK_IS_DOWN,
197 	GRN_NO_BUFFER = .grn_rc.GRN_NO_BUFFER,
198 	GRN_SOCKET_IS_ALREADY_CONNECTED = .grn_rc.GRN_SOCKET_IS_ALREADY_CONNECTED,
199 	GRN_SOCKET_IS_NOT_CONNECTED = .grn_rc.GRN_SOCKET_IS_NOT_CONNECTED,
200 	GRN_SOCKET_IS_ALREADY_SHUTDOWNED = .grn_rc.GRN_SOCKET_IS_ALREADY_SHUTDOWNED,
201 	GRN_OPERATION_TIMEOUT = .grn_rc.GRN_OPERATION_TIMEOUT,
202 	GRN_CONNECTION_REFUSED = .grn_rc.GRN_CONNECTION_REFUSED,
203 	GRN_RANGE_ERROR = .grn_rc.GRN_RANGE_ERROR,
204 	GRN_TOKENIZER_ERROR = .grn_rc.GRN_TOKENIZER_ERROR,
205 	GRN_FILE_CORRUPT = .grn_rc.GRN_FILE_CORRUPT,
206 	GRN_INVALID_FORMAT = .grn_rc.GRN_INVALID_FORMAT,
207 	GRN_OBJECT_CORRUPT = .grn_rc.GRN_OBJECT_CORRUPT,
208 	GRN_TOO_MANY_SYMBOLIC_LINKS = .grn_rc.GRN_TOO_MANY_SYMBOLIC_LINKS,
209 	GRN_NOT_SOCKET = .grn_rc.GRN_NOT_SOCKET,
210 	GRN_OPERATION_NOT_SUPPORTED = .grn_rc.GRN_OPERATION_NOT_SUPPORTED,
211 	GRN_ADDRESS_IS_IN_USE = .grn_rc.GRN_ADDRESS_IS_IN_USE,
212 	GRN_ZLIB_ERROR = .grn_rc.GRN_ZLIB_ERROR,
213 	GRN_LZ4_ERROR = .grn_rc.GRN_LZ4_ERROR,
214 	GRN_LZO_ERROR = .grn_rc.GRN_LZO_ERROR,
215 	GRN_STACK_OVER_FLOW = .grn_rc.GRN_STACK_OVER_FLOW,
216 	GRN_SYNTAX_ERROR = .grn_rc.GRN_SYNTAX_ERROR,
217 	GRN_RETRY_MAX = .grn_rc.GRN_RETRY_MAX,
218 	GRN_INCOMPATIBLE_FILE_FORMAT = .grn_rc.GRN_INCOMPATIBLE_FILE_FORMAT,
219 	GRN_UPDATE_NOT_ALLOWED = .grn_rc.GRN_UPDATE_NOT_ALLOWED,
220 	GRN_TOO_SMALL_OFFSET = .grn_rc.GRN_TOO_SMALL_OFFSET,
221 	GRN_TOO_LARGE_OFFSET = .grn_rc.GRN_TOO_LARGE_OFFSET,
222 	GRN_TOO_SMALL_LIMIT = .grn_rc.GRN_TOO_SMALL_LIMIT,
223 	GRN_CAS_ERROR = .grn_rc.GRN_CAS_ERROR,
224 	GRN_UNSUPPORTED_COMMAND_VERSION = .grn_rc.GRN_UNSUPPORTED_COMMAND_VERSION,
225 	GRN_NORMALIZER_ERROR = .grn_rc.GRN_NORMALIZER_ERROR,
226 	GRN_TOKEN_FILTER_ERROR = .grn_rc.GRN_TOKEN_FILTER_ERROR,
227 	GRN_COMMAND_ERROR = .grn_rc.GRN_COMMAND_ERROR,
228 	GRN_PLUGIN_ERROR = .grn_rc.GRN_PLUGIN_ERROR,
229 	GRN_SCORER_ERROR = .grn_rc.GRN_SCORER_ERROR,
230 	GRN_CANCEL = .grn_rc.GRN_CANCEL,
231 	GRN_WINDOW_FUNCTION_ERROR = .grn_rc.GRN_WINDOW_FUNCTION_ERROR,
232 	GRN_ZSTD_ERROR = .grn_rc.GRN_ZSTD_ERROR,
233 	GRN_CONNECTION_RESET = .grn_rc.GRN_CONNECTION_RESET,
234 }
235 
236 //GRN_API
237 .grn_rc grn_init();
238 
239 //GRN_API
240 .grn_rc grn_fin();
241 
242 //GRN_API
243 const (char)* grn_get_global_error_message();
244 
245 enum grn_encoding
246 {
247 	GRN_ENC_DEFAULT = 0,
248 	GRN_ENC_NONE,
249 	GRN_ENC_EUC_JP,
250 	GRN_ENC_UTF8,
251 	GRN_ENC_SJIS,
252 	GRN_ENC_LATIN1,
253 	GRN_ENC_KOI8R,
254 }
255 
256 //Declaration name in C language
257 enum
258 {
259 	GRN_ENC_DEFAULT = .grn_encoding.GRN_ENC_DEFAULT,
260 	GRN_ENC_NONE = .grn_encoding.GRN_ENC_NONE,
261 	GRN_ENC_EUC_JP = .grn_encoding.GRN_ENC_EUC_JP,
262 	GRN_ENC_UTF8 = .grn_encoding.GRN_ENC_UTF8,
263 	GRN_ENC_SJIS = .grn_encoding.GRN_ENC_SJIS,
264 	GRN_ENC_LATIN1 = .grn_encoding.GRN_ENC_LATIN1,
265 	GRN_ENC_KOI8R = .grn_encoding.GRN_ENC_KOI8R,
266 }
267 
268 enum grn_command_version
269 {
270 	GRN_COMMAND_VERSION_DEFAULT = 0,
271 	GRN_COMMAND_VERSION_1,
272 	GRN_COMMAND_VERSION_2,
273 	GRN_COMMAND_VERSION_3,
274 }
275 
276 //Declaration name in C language
277 enum
278 {
279 	GRN_COMMAND_VERSION_DEFAULT = .grn_command_version.GRN_COMMAND_VERSION_DEFAULT,
280 	GRN_COMMAND_VERSION_1 = .grn_command_version.GRN_COMMAND_VERSION_1,
281 	GRN_COMMAND_VERSION_2 = .grn_command_version.GRN_COMMAND_VERSION_2,
282 	GRN_COMMAND_VERSION_3 = .grn_command_version.GRN_COMMAND_VERSION_3,
283 }
284 
285 enum GRN_COMMAND_VERSION_MIN = .grn_command_version.GRN_COMMAND_VERSION_1;
286 enum GRN_COMMAND_VERSION_STABLE = .grn_command_version.GRN_COMMAND_VERSION_1;
287 enum GRN_COMMAND_VERSION_MAX = .grn_command_version.GRN_COMMAND_VERSION_3;
288 
289 enum grn_log_level
290 {
291 	GRN_LOG_NONE = 0,
292 	GRN_LOG_EMERG,
293 	GRN_LOG_ALERT,
294 	GRN_LOG_CRIT,
295 	GRN_LOG_ERROR,
296 	GRN_LOG_WARNING,
297 	GRN_LOG_NOTICE,
298 	GRN_LOG_INFO,
299 	GRN_LOG_DEBUG,
300 	GRN_LOG_DUMP,
301 }
302 
303 //Declaration name in C language
304 enum
305 {
306 	//GRN_LOG_NONE = .grn_log_level.GRN_LOG_NONE,
307 	GRN_LOG_EMERG = .grn_log_level.GRN_LOG_EMERG,
308 	GRN_LOG_ALERT = .grn_log_level.GRN_LOG_ALERT,
309 	GRN_LOG_CRIT = .grn_log_level.GRN_LOG_CRIT,
310 	GRN_LOG_ERROR = .grn_log_level.GRN_LOG_ERROR,
311 	GRN_LOG_WARNING = .grn_log_level.GRN_LOG_WARNING,
312 	GRN_LOG_NOTICE = .grn_log_level.GRN_LOG_NOTICE,
313 	GRN_LOG_INFO = .grn_log_level.GRN_LOG_INFO,
314 	GRN_LOG_DEBUG = .grn_log_level.GRN_LOG_DEBUG,
315 	GRN_LOG_DUMP = .grn_log_level.GRN_LOG_DUMP,
316 }
317 
318 //GRN_API
319 const (char)* grn_log_level_to_string(.grn_log_level level);
320 
321 //GRN_API
322 .grn_bool grn_log_level_parse(const (char)* string_, .grn_log_level* level);
323 
324 /* query log flags */
325 enum GRN_QUERY_LOG_NONE = 0x00;
326 enum GRN_QUERY_LOG_COMMAND = 0x01 << 0;
327 enum GRN_QUERY_LOG_RESULT_CODE = 0x01 << 1;
328 enum GRN_QUERY_LOG_DESTINATION = 0x01 << 2;
329 enum GRN_QUERY_LOG_CACHE = 0x01 << 3;
330 enum GRN_QUERY_LOG_SIZE = 0x01 << 4;
331 enum GRN_QUERY_LOG_SCORE = 0x01 << 5;
332 enum GRN_QUERY_LOG_ALL = .GRN_QUERY_LOG_COMMAND | .GRN_QUERY_LOG_RESULT_CODE | .GRN_QUERY_LOG_DESTINATION | .GRN_QUERY_LOG_CACHE | .GRN_QUERY_LOG_SIZE | .GRN_QUERY_LOG_SCORE;
333 enum GRN_QUERY_LOG_DEFAULT = .GRN_QUERY_LOG_ALL;
334 
335 enum grn_content_type
336 {
337 	GRN_CONTENT_NONE = 0,
338 	GRN_CONTENT_TSV,
339 	GRN_CONTENT_JSON,
340 	GRN_CONTENT_XML,
341 	GRN_CONTENT_MSGPACK,
342 	GRN_CONTENT_GROONGA_COMMAND_LIST,
343 	GRN_CONTENT_APACHE_ARROW,
344 }
345 
346 //Declaration name in C language
347 enum
348 {
349 	GRN_CONTENT_NONE = .grn_content_type.GRN_CONTENT_NONE,
350 	GRN_CONTENT_TSV = .grn_content_type.GRN_CONTENT_TSV,
351 	GRN_CONTENT_JSON = .grn_content_type.GRN_CONTENT_JSON,
352 	GRN_CONTENT_XML = .grn_content_type.GRN_CONTENT_XML,
353 	GRN_CONTENT_MSGPACK = .grn_content_type.GRN_CONTENT_MSGPACK,
354 	GRN_CONTENT_GROONGA_COMMAND_LIST = .grn_content_type.GRN_CONTENT_GROONGA_COMMAND_LIST,
355 	GRN_CONTENT_APACHE_ARROW = .grn_content_type.GRN_CONTENT_APACHE_ARROW,
356 }
357 
358 enum GRN_CTX_MSGSIZE = 0x80;
359 enum GRN_CTX_FIN = 0xFF;
360 
361 alias grn_close_func = extern (C) void function (.grn_ctx* ctx, void* data);
362 
363 union grn_user_data
364 {
365 	int int_value;
366 	.grn_id id;
367 	void* ptr_;
368 
369 	deprecated
370 	alias ptr = ptr_;
371 }
372 
373 alias grn_proc_func = extern (C) .grn_obj* function(.grn_ctx* ctx, int nargs, .grn_obj** args, grn_user_data* user_data);
374 
375 extern struct _grn_ctx_impl;
376 
377 struct _grn_ctx
378 {
379 	.grn_rc rc;
380 	int flags;
381 	.grn_encoding encoding;
382 	ubyte ntrace;
383 	ubyte errlvl;
384 	ubyte stat;
385 	uint seqno;
386 	uint subno;
387 	uint seqno2;
388 	uint errline;
389 	grn_user_data user_data;
390 	.grn_ctx* prev;
391 	.grn_ctx* next;
392 	const (char)* errfile;
393 	const (char)* errfunc;
394 	._grn_ctx_impl* impl;
395 
396 	//ToDo: Check
397 	void*[16] trace;
398 
399 	char[.GRN_CTX_MSGSIZE] errbuf = '\0';
400 }
401 
402 alias grn_ctx = ._grn_ctx;
403 
404 pragma(inline, true)
405 pure nothrow @trusted @nogc @live
406 grn_user_data* GRN_CTX_USER_DATA(return scope .grn_ctx* ctx)
407 
408 	in
409 	{
410 		assert(ctx != null);
411 	}
412 
413 	do
414 	{
415 		return &(ctx.user_data);
416 	}
417 
418 /* Deprecated since 4.0.3. Don't use it. */
419 enum GRN_CTX_USE_QL = 0x03;
420 /* Deprecated since 4.0.3. Don't use it. */
421 enum GRN_CTX_BATCH_MODE = 0x04;
422 enum GRN_CTX_PER_DB = 0x08;
423 
424 //GRN_API
425 .grn_rc grn_ctx_init(.grn_ctx* ctx, int flags);
426 
427 //GRN_API
428 .grn_rc grn_ctx_fin(.grn_ctx* ctx);
429 
430 //GRN_API
431 .grn_ctx* grn_ctx_open(int flags);
432 
433 //GRN_API
434 .grn_rc grn_ctx_close(.grn_ctx* ctx);
435 
436 //GRN_API
437 .grn_rc grn_ctx_set_finalizer(.grn_ctx* ctx, grn_proc_func* func);
438 
439 //GRN_API
440 .grn_rc grn_ctx_push_temporary_open_space(.grn_ctx* ctx);
441 
442 //GRN_API
443 .grn_rc grn_ctx_pop_temporary_open_space(.grn_ctx* ctx);
444 
445 //GRN_API
446 .grn_rc grn_ctx_merge_temporary_open_space(.grn_ctx* ctx);
447 
448 //GRN_API
449 .grn_encoding grn_get_default_encoding();
450 
451 //GRN_API
452 .grn_rc grn_set_default_encoding(.grn_encoding encoding);
453 
454 pragma(inline, true)
455 pure nothrow @trusted @nogc @live
456 .grn_encoding GRN_CTX_GET_ENCODING(scope const .grn_ctx* ctx)
457 
458 	in
459 	{
460 		assert(ctx != null);
461 	}
462 
463 	do
464 	{
465 		return ctx.encoding;
466 	}
467 
468 pragma(inline, true)
469 void GRN_CTX_SET_ENCODING(scope .grn_ctx* ctx, .grn_encoding enc)
470 
471 	in
472 	{
473 		assert(ctx != null);
474 	}
475 
476 	do
477 	{
478 		ctx.encoding = (enc == .grn_encoding.GRN_ENC_DEFAULT) ? (.grn_get_default_encoding()) : (enc);
479 	}
480 
481 //GRN_API
482 const (char)* grn_get_version();
483 
484 //GRN_API
485 uint grn_get_version_major();
486 
487 //GRN_API
488 uint grn_get_version_minor();
489 
490 //GRN_API
491 uint grn_get_version_micro();
492 
493 //GRN_API
494 const (char)* grn_get_package();
495 
496 //GRN_API
497 const (char)* grn_get_package_label();
498 
499 //GRN_API
500 .grn_command_version grn_get_default_command_version();
501 
502 //GRN_API
503 .grn_rc grn_set_default_command_version(.grn_command_version input_version);
504 
505 //GRN_API
506 .grn_command_version grn_ctx_get_command_version(.grn_ctx* ctx);
507 
508 //GRN_API
509 .grn_rc grn_ctx_set_command_version(.grn_ctx* ctx, .grn_command_version input_version);
510 
511 //GRN_API
512 long grn_ctx_get_match_escalation_threshold(.grn_ctx* ctx);
513 
514 //GRN_API
515 .grn_rc grn_ctx_set_match_escalation_threshold(.grn_ctx* ctx, long threshold);
516 
517 //GRN_API
518 .grn_bool grn_ctx_get_force_match_escalation(.grn_ctx* ctx);
519 
520 //GRN_API
521 .grn_rc grn_ctx_set_force_match_escalation(.grn_ctx* ctx, .grn_bool force);
522 
523 //GRN_API
524 long grn_get_default_match_escalation_threshold();
525 
526 //GRN_API
527 .grn_rc grn_set_default_match_escalation_threshold(long threshold);
528 
529 //GRN_API
530 grn_rc grn_ctx_set_variable(.grn_ctx* ctx, const (char)* name, int name_size, void* data, .grn_close_func close_func);
531 
532 //GRN_API
533 void* grn_ctx_get_variable(.grn_ctx* ctx, const (char)* name, int name_size);
534 
535 //GRN_API
536 grn_rc grn_unset_variable(const (char)* name, int name_size);
537 
538 //GRN_API
539 int grn_get_lock_timeout();
540 
541 //GRN_API
542 .grn_rc grn_set_lock_timeout(int timeout);
543 
544 /* .grn_encoding */
545 
546 //GRN_API
547 const (char)* grn_encoding_to_string(.grn_encoding encoding);
548 
549 //GRN_API
550 .grn_encoding grn_encoding_parse(const (char)* name);
551 
552 /* obj */
553 
554 alias grn_obj_flags = ushort;
555 alias grn_table_flags = uint;
556 alias grn_column_flags = uint;
557 
558 /* flags for grn_obj_flags and grn_table_flags */
559 
560 enum GRN_OBJ_FLAGS_MASK = 0xFFFF;
561 
562 enum GRN_OBJ_TABLE_TYPE_MASK = 0x07;
563 enum GRN_OBJ_TABLE_HASH_KEY = 0x00;
564 enum GRN_OBJ_TABLE_PAT_KEY = 0x01;
565 enum GRN_OBJ_TABLE_DAT_KEY = 0x02;
566 enum GRN_OBJ_TABLE_NO_KEY = 0x03;
567 
568 enum GRN_OBJ_KEY_MASK = 0x07 << 3;
569 enum GRN_OBJ_KEY_UINT = 0x00 << 3;
570 enum GRN_OBJ_KEY_INT = 0x01 << 3;
571 enum GRN_OBJ_KEY_FLOAT = 0x02 << 3;
572 enum GRN_OBJ_KEY_GEO_POINT = 0x03 << 3;
573 
574 enum GRN_OBJ_KEY_WITH_SIS = 0x01 << 6;
575 enum GRN_OBJ_KEY_NORMALIZE = 0x01 << 7;
576 
577 /* flags for grn_obj_flags and grn_column_flags */
578 
579 enum GRN_OBJ_COLUMN_TYPE_MASK = 0x07;
580 enum GRN_OBJ_COLUMN_SCALAR = 0x00;
581 enum GRN_OBJ_COLUMN_VECTOR = 0x01;
582 enum GRN_OBJ_COLUMN_INDEX = 0x02;
583 
584 enum GRN_OBJ_COMPRESS_MASK = 0x07 << 4;
585 enum GRN_OBJ_COMPRESS_NONE = 0x00 << 4;
586 enum GRN_OBJ_COMPRESS_ZLIB = 0x01 << 4;
587 enum GRN_OBJ_COMPRESS_LZ4 = 0x02 << 4;
588 /* Just for backward compatibility. We'll remove it at 5.0.0. */
589 enum GRN_OBJ_COMPRESS_LZO = .GRN_OBJ_COMPRESS_LZ4;
590 enum GRN_OBJ_COMPRESS_ZSTD = 0x03 << 4;
591 
592 enum GRN_OBJ_WITH_SECTION = 0x01 << 7;
593 enum GRN_OBJ_WITH_WEIGHT = 0x01 << 8;
594 enum GRN_OBJ_WITH_POSITION = 0x01 << 9;
595 enum GRN_OBJ_RING_BUFFER = 0x01 << 10;
596 
597 enum GRN_OBJ_UNIT_MASK = 0x0F << 8;
598 enum GRN_OBJ_UNIT_DOCUMENT_NONE = 0x00 << 8;
599 enum GRN_OBJ_UNIT_DOCUMENT_SECTION = 0x01 << 8;
600 enum GRN_OBJ_UNIT_DOCUMENT_POSITION = 0x02 << 8;
601 enum GRN_OBJ_UNIT_SECTION_NONE = 0x03 << 8;
602 enum GRN_OBJ_UNIT_SECTION_POSITION = 0x04 << 8;
603 enum GRN_OBJ_UNIT_POSITION_NONE = 0x05 << 8;
604 enum GRN_OBJ_UNIT_USERDEF_DOCUMENT = 0x06 << 8;
605 enum GRN_OBJ_UNIT_USERDEF_SECTION = 0x07 << 8;
606 enum GRN_OBJ_UNIT_USERDEF_POSITION = 0x08 << 8;
607 
608 /* Don't use (0x01<<12) because it's used internally. */
609 
610 enum GRN_OBJ_NO_SUBREC = 0x00 << 13;
611 enum GRN_OBJ_WITH_SUBREC = 0x01 << 13;
612 
613 enum GRN_OBJ_KEY_VAR_SIZE = 0x01 << 14;
614 
615 enum GRN_OBJ_TEMPORARY = 0x00 << 15;
616 enum GRN_OBJ_PERSISTENT = 0x01 << 15;
617 
618 /* flags only for grn_table_flags */
619 
620 enum GRN_OBJ_KEY_LARGE = 0x01 << 16;
621 
622 /* flags only for grn_column_flags */
623 
624 enum GRN_OBJ_INDEX_SMALL = 0x01 << 16;
625 enum GRN_OBJ_INDEX_MEDIUM = 0x01 << 17;
626 enum GRN_OBJ_INDEX_LARGE = 0x01 << 18;
627 enum GRN_OBJ_WEIGHT_FLOAT32 = 0x01 << 19;
628 
629 /* flags only for grn_table_flags and grn_column_flags */
630 
631 /* GRN_COLUMN_INDEX only uses this for now */
632 enum GRN_OBJ_VISIBLE = cast(uint)(0x00 << 31);
633 enum GRN_OBJ_INVISIBLE = cast(uint)(0x01 << 31);
634 
635 /* obj types */
636 
637 enum GRN_VOID = 0x00;
638 enum GRN_BULK = 0x02;
639 enum GRN_PTR = 0x03;
640 
641 /* vector of fixed size data especially grn_id */
642 enum GRN_UVECTOR = 0x04;
643 
644 /* vector of .grn_obj* */
645 enum GRN_PVECTOR = 0x05;
646 
647 /* vector of arbitrary data */
648 enum GRN_VECTOR = 0x06;
649 
650 enum GRN_MSG = 0x07;
651 enum GRN_QUERY = 0x08;
652 enum GRN_ACCESSOR = 0x09;
653 enum GRN_SNIP = 0x0B;
654 enum GRN_PATSNIP = 0x0C;
655 enum GRN_STRING = 0x0D;
656 enum GRN_HIGHLIGHTER = 0x0E;
657 enum GRN_CURSOR_TABLE_HASH_KEY = 0x10;
658 enum GRN_CURSOR_TABLE_PAT_KEY = 0x11;
659 enum GRN_CURSOR_TABLE_DAT_KEY = 0x12;
660 enum GRN_CURSOR_TABLE_NO_KEY = 0x13;
661 enum GRN_CURSOR_COLUMN_INDEX = 0x18;
662 enum GRN_CURSOR_COLUMN_GEO_INDEX = 0x1A;
663 enum GRN_CURSOR_CONFIG = 0x1F;
664 enum GRN_TYPE = 0x20;
665 enum GRN_PROC = 0x21;
666 enum GRN_EXPR = 0x22;
667 enum GRN_TABLE_HASH_KEY = 0x30;
668 enum GRN_TABLE_PAT_KEY = 0x31;
669 enum GRN_TABLE_DAT_KEY = 0x32;
670 enum GRN_TABLE_NO_KEY = 0x33;
671 enum GRN_DB = 0x37;
672 enum GRN_COLUMN_FIX_SIZE = 0x40;
673 enum GRN_COLUMN_VAR_SIZE = 0x41;
674 enum GRN_COLUMN_INDEX = 0x48;
675 
676 struct _grn_section
677 {
678 	uint offset;
679 	uint length;
680 	float weight = 0;
681 	.grn_id domain;
682 }
683 
684 alias grn_section = ._grn_section;
685 
686 struct _grn_obj_header
687 {
688 	ubyte type;
689 	ubyte impl_flags;
690 	.grn_obj_flags flags;
691 	.grn_id domain;
692 }
693 
694 alias grn_obj_header = ._grn_obj_header;
695 
696 struct _grn_obj
697 {
698 	.grn_obj_header header;
699 
700 	union u_
701 	{
702 		struct b_
703 		{
704 			char* head;
705 			char* curr;
706 			char* tail;
707 		}
708 
709 		b_ b;
710 
711 		struct v_
712 		{
713 			.grn_obj* body_;
714 			.grn_section* sections;
715 			uint n_sections;
716 		}
717 
718 		v_ v;
719 	}
720 
721 	u_ u;
722 }
723 
724 alias grn_obj = ._grn_obj;
725 
726 enum GRN_OBJ_REFER = 0x01 << 0;
727 enum GRN_OBJ_OUTPLACE = 0x01 << 1;
728 enum GRN_OBJ_OWN = 0x01 << 5;
729 
730 pragma(inline, true)
731 pure nothrow @trusted @nogc @live
732 void GRN_OBJ_INIT(scope .grn_obj* obj, ubyte obj_type, ubyte obj_flags, .grn_id obj_domain)
733 
734 	in
735 	{
736 		assert(obj != null);
737 	}
738 
739 	do
740 	{
741 		obj.header.type = obj_type;
742 		obj.header.impl_flags = obj_flags;
743 		obj.header.flags = 0;
744 		obj.header.domain = obj_domain;
745 		obj.u.b.head = null;
746 		obj.u.b.curr = null;
747 		obj.u.b.tail = null;
748 	}
749 
750 alias GRN_OBJ_FIN = grn_obj_close;
751 
752 //GRN_API
753 .grn_rc grn_ctx_use(.grn_ctx* ctx, .grn_obj* db);
754 
755 //GRN_API
756 .grn_obj* grn_ctx_db(.grn_ctx* ctx);
757 
758 //GRN_API
759 .grn_obj* grn_ctx_get(.grn_ctx* ctx, const (char)* name, int name_size);
760 
761 //GRN_API
762 .grn_rc grn_ctx_get_all_tables(.grn_ctx* ctx, .grn_obj* tables_buffer);
763 
764 //GRN_API
765 .grn_rc grn_ctx_get_all_types(.grn_ctx* ctx, .grn_obj* types_buffer);
766 
767 //GRN_API
768 .grn_rc grn_ctx_get_all_tokenizers(.grn_ctx* ctx, .grn_obj* tokenizers_buffer);
769 
770 //GRN_API
771 .grn_rc grn_ctx_get_all_normalizers(.grn_ctx* ctx, .grn_obj* normalizers_buffer);
772 
773 //GRN_API
774 .grn_rc grn_ctx_get_all_token_filters(.grn_ctx* ctx, .grn_obj* token_filters_buffer);
775 
776 enum grn_builtin_type
777 {
778 	GRN_DB_VOID = 0,
779 	GRN_DB_DB,
780 	GRN_DB_OBJECT,
781 	GRN_DB_BOOL,
782 	GRN_DB_INT8,
783 	GRN_DB_UINT8,
784 	GRN_DB_INT16,
785 	GRN_DB_UINT16,
786 	GRN_DB_INT32,
787 	GRN_DB_UINT32,
788 	GRN_DB_INT64,
789 	GRN_DB_UINT64,
790 	GRN_DB_FLOAT,
791 	GRN_DB_TIME,
792 	GRN_DB_SHORT_TEXT,
793 	GRN_DB_TEXT,
794 	GRN_DB_LONG_TEXT,
795 	GRN_DB_TOKYO_GEO_POINT,
796 	GRN_DB_WGS84_GEO_POINT,
797 	GRN_DB_FLOAT32,
798 }
799 
800 //Declaration name in C language
801 enum
802 {
803 	GRN_DB_VOID = .grn_builtin_type.GRN_DB_VOID,
804 	GRN_DB_DB = .grn_builtin_type.GRN_DB_DB,
805 	GRN_DB_OBJECT = .grn_builtin_type.GRN_DB_OBJECT,
806 	GRN_DB_BOOL = .grn_builtin_type.GRN_DB_BOOL,
807 	GRN_DB_INT8 = .grn_builtin_type.GRN_DB_INT8,
808 	GRN_DB_UINT8 = .grn_builtin_type.GRN_DB_UINT8,
809 	GRN_DB_INT16 = .grn_builtin_type.GRN_DB_INT16,
810 	GRN_DB_UINT16 = .grn_builtin_type.GRN_DB_UINT16,
811 	GRN_DB_INT32 = .grn_builtin_type.GRN_DB_INT32,
812 	GRN_DB_UINT32 = .grn_builtin_type.GRN_DB_UINT32,
813 	GRN_DB_INT64 = .grn_builtin_type.GRN_DB_INT64,
814 	GRN_DB_UINT64 = .grn_builtin_type.GRN_DB_UINT64,
815 	GRN_DB_FLOAT = .grn_builtin_type.GRN_DB_FLOAT,
816 	GRN_DB_TIME = .grn_builtin_type.GRN_DB_TIME,
817 	GRN_DB_SHORT_TEXT = .grn_builtin_type.GRN_DB_SHORT_TEXT,
818 	GRN_DB_TEXT = .grn_builtin_type.GRN_DB_TEXT,
819 	GRN_DB_LONG_TEXT = .grn_builtin_type.GRN_DB_LONG_TEXT,
820 	GRN_DB_TOKYO_GEO_POINT = .grn_builtin_type.GRN_DB_TOKYO_GEO_POINT,
821 	GRN_DB_WGS84_GEO_POINT = .grn_builtin_type.GRN_DB_WGS84_GEO_POINT,
822 	GRN_DB_FLOAT32 = .grn_builtin_type.GRN_DB_FLOAT32,
823 }
824 
825 enum grn_builtin_tokenizer
826 {
827 	GRN_DB_MECAB = 64,
828 	GRN_DB_DELIMIT,
829 	GRN_DB_UNIGRAM,
830 	GRN_DB_BIGRAM,
831 	GRN_DB_TRIGRAM,
832 }
833 
834 //Declaration name in C language
835 enum
836 {
837 	GRN_DB_MECAB = .grn_builtin_tokenizer.GRN_DB_MECAB,
838 	GRN_DB_DELIMIT = .grn_builtin_tokenizer.GRN_DB_DELIMIT,
839 	GRN_DB_UNIGRAM = .grn_builtin_tokenizer.GRN_DB_UNIGRAM,
840 	GRN_DB_BIGRAM = .grn_builtin_tokenizer.GRN_DB_BIGRAM,
841 	GRN_DB_TRIGRAM = .grn_builtin_tokenizer.GRN_DB_TRIGRAM,
842 }
843 
844 //GRN_API
845 .grn_obj* grn_ctx_at(.grn_ctx* ctx, .grn_id id);
846 
847 //GRN_API
848 .grn_bool grn_ctx_is_opened(.grn_ctx* ctx, .grn_id id);
849 
850 //GRN_API
851 .grn_rc grn_plugin_register(.grn_ctx* ctx, const (char)* name);
852 
853 //GRN_API
854 .grn_rc grn_plugin_unregister(.grn_ctx* ctx, const (char)* name);
855 
856 //GRN_API
857 .grn_rc grn_plugin_register_by_path(.grn_ctx* ctx, const (char)* path);
858 
859 //GRN_API
860 .grn_rc grn_plugin_unregister_by_path(.grn_ctx* ctx, const (char)* path);
861 
862 //GRN_API
863 const (char)* grn_plugin_get_system_plugins_dir();
864 
865 //GRN_API
866 const (char)* grn_plugin_get_suffix();
867 
868 //GRN_API
869 const (char)* grn_plugin_get_ruby_suffix();
870 
871 //GRN_API
872 .grn_rc grn_plugin_get_names(.grn_ctx* ctx, .grn_obj* names);
873 
874 struct grn_expr_var
875 {
876 	const (char)* name;
877 	uint name_size;
878 	.grn_obj value;
879 }
880 
881 .grn_rc function (.grn_ctx* ctx) grn_plugin_func;
882 
883 alias grn_table_cursor = .grn_obj;
884 
885 enum grn_operator
886 {
887 	GRN_OP_PUSH = 0,
888 	GRN_OP_POP,
889 	GRN_OP_NOP,
890 	GRN_OP_CALL,
891 	GRN_OP_INTERN,
892 	GRN_OP_GET_REF,
893 	GRN_OP_GET_VALUE,
894 	GRN_OP_AND,
895 	GRN_OP_AND_NOT,
896 
897 	/**
898 	 * Deprecated. Just for backward compatibility.
899 	 */
900 	GRN_OP_BUT = GRN_OP_AND_NOT,
901 
902 	GRN_OP_OR,
903 	GRN_OP_ASSIGN,
904 	GRN_OP_STAR_ASSIGN,
905 	GRN_OP_SLASH_ASSIGN,
906 	GRN_OP_MOD_ASSIGN,
907 	GRN_OP_PLUS_ASSIGN,
908 	GRN_OP_MINUS_ASSIGN,
909 	GRN_OP_SHIFTL_ASSIGN,
910 	GRN_OP_SHIFTR_ASSIGN,
911 	GRN_OP_SHIFTRR_ASSIGN,
912 	GRN_OP_AND_ASSIGN,
913 	GRN_OP_XOR_ASSIGN,
914 	GRN_OP_OR_ASSIGN,
915 	GRN_OP_JUMP,
916 	GRN_OP_CJUMP,
917 	GRN_OP_COMMA,
918 	GRN_OP_BITWISE_OR,
919 	GRN_OP_BITWISE_XOR,
920 	GRN_OP_BITWISE_AND,
921 	GRN_OP_BITWISE_NOT,
922 	GRN_OP_EQUAL,
923 	GRN_OP_NOT_EQUAL,
924 	GRN_OP_LESS,
925 	GRN_OP_GREATER,
926 	GRN_OP_LESS_EQUAL,
927 	GRN_OP_GREATER_EQUAL,
928 	GRN_OP_IN,
929 	GRN_OP_MATCH,
930 	GRN_OP_NEAR,
931 	GRN_OP_NEAR2,
932 	GRN_OP_SIMILAR,
933 	GRN_OP_TERM_EXTRACT,
934 	GRN_OP_SHIFTL,
935 	GRN_OP_SHIFTR,
936 	GRN_OP_SHIFTRR,
937 	GRN_OP_PLUS,
938 	GRN_OP_MINUS,
939 	GRN_OP_STAR,
940 	GRN_OP_SLASH,
941 	GRN_OP_MOD,
942 	GRN_OP_DELETE,
943 	GRN_OP_INCR,
944 	GRN_OP_DECR,
945 	GRN_OP_INCR_POST,
946 	GRN_OP_DECR_POST,
947 	GRN_OP_NOT,
948 	GRN_OP_ADJUST,
949 	GRN_OP_EXACT,
950 	GRN_OP_LCP,
951 	GRN_OP_PARTIAL,
952 	GRN_OP_UNSPLIT,
953 	GRN_OP_PREFIX,
954 	GRN_OP_SUFFIX,
955 	GRN_OP_GEO_DISTANCE1,
956 	GRN_OP_GEO_DISTANCE2,
957 	GRN_OP_GEO_DISTANCE3,
958 	GRN_OP_GEO_DISTANCE4,
959 	GRN_OP_GEO_WITHINP5,
960 	GRN_OP_GEO_WITHINP6,
961 	GRN_OP_GEO_WITHINP8,
962 	GRN_OP_OBJ_SEARCH,
963 	GRN_OP_EXPR_GET_VAR,
964 	GRN_OP_TABLE_CREATE,
965 	GRN_OP_TABLE_SELECT,
966 	GRN_OP_TABLE_SORT,
967 	GRN_OP_TABLE_GROUP,
968 	GRN_OP_JSON_PUT,
969 	GRN_OP_GET_MEMBER,
970 	GRN_OP_REGEXP,
971 	GRN_OP_FUZZY,
972 	GRN_OP_QUORUM,
973 	GRN_OP_NEAR_PHRASE,
974 	GRN_OP_ORDERED_NEAR_PHRASE,
975 }
976 
977 //Declaration name in C language
978 enum
979 {
980 	GRN_OP_PUSH = .grn_operator.GRN_OP_PUSH,
981 	GRN_OP_POP = .grn_operator.GRN_OP_POP,
982 	GRN_OP_NOP = .grn_operator.GRN_OP_NOP,
983 	GRN_OP_CALL = .grn_operator.GRN_OP_CALL,
984 	GRN_OP_INTERN = .grn_operator.GRN_OP_INTERN,
985 	GRN_OP_GET_REF = .grn_operator.GRN_OP_GET_REF,
986 	GRN_OP_GET_VALUE = .grn_operator.GRN_OP_GET_VALUE,
987 	GRN_OP_AND = .grn_operator.GRN_OP_AND,
988 	GRN_OP_AND_NOT = .grn_operator.GRN_OP_AND_NOT,
989 	GRN_OP_BUT = .grn_operator.GRN_OP_BUT,
990 	GRN_OP_OR = .grn_operator.GRN_OP_OR,
991 	GRN_OP_ASSIGN = .grn_operator.GRN_OP_ASSIGN,
992 	GRN_OP_STAR_ASSIGN = .grn_operator.GRN_OP_STAR_ASSIGN,
993 	GRN_OP_SLASH_ASSIGN = .grn_operator.GRN_OP_SLASH_ASSIGN,
994 	GRN_OP_MOD_ASSIGN = .grn_operator.GRN_OP_MOD_ASSIGN,
995 	GRN_OP_PLUS_ASSIGN = .grn_operator.GRN_OP_PLUS_ASSIGN,
996 	GRN_OP_MINUS_ASSIGN = .grn_operator.GRN_OP_MINUS_ASSIGN,
997 	GRN_OP_SHIFTL_ASSIGN = .grn_operator.GRN_OP_SHIFTL_ASSIGN,
998 	GRN_OP_SHIFTR_ASSIGN = .grn_operator.GRN_OP_SHIFTR_ASSIGN,
999 	GRN_OP_SHIFTRR_ASSIGN = .grn_operator.GRN_OP_SHIFTRR_ASSIGN,
1000 	GRN_OP_AND_ASSIGN = .grn_operator.GRN_OP_AND_ASSIGN,
1001 	GRN_OP_XOR_ASSIGN = .grn_operator.GRN_OP_XOR_ASSIGN,
1002 	GRN_OP_OR_ASSIGN = .grn_operator.GRN_OP_OR_ASSIGN,
1003 	GRN_OP_JUMP = .grn_operator.GRN_OP_JUMP,
1004 	GRN_OP_CJUMP = .grn_operator.GRN_OP_CJUMP,
1005 	GRN_OP_COMMA = .grn_operator.GRN_OP_COMMA,
1006 	GRN_OP_BITWISE_OR = .grn_operator.GRN_OP_BITWISE_OR,
1007 	GRN_OP_BITWISE_XOR = .grn_operator.GRN_OP_BITWISE_XOR,
1008 	GRN_OP_BITWISE_AND = .grn_operator.GRN_OP_BITWISE_AND,
1009 	GRN_OP_BITWISE_NOT = .grn_operator.GRN_OP_BITWISE_NOT,
1010 	GRN_OP_EQUAL = .grn_operator.GRN_OP_EQUAL,
1011 	GRN_OP_NOT_EQUAL = .grn_operator.GRN_OP_NOT_EQUAL,
1012 	GRN_OP_LESS = .grn_operator.GRN_OP_LESS,
1013 	GRN_OP_GREATER = .grn_operator.GRN_OP_GREATER,
1014 	GRN_OP_LESS_EQUAL = .grn_operator.GRN_OP_LESS_EQUAL,
1015 	GRN_OP_GREATER_EQUAL = .grn_operator.GRN_OP_GREATER_EQUAL,
1016 	GRN_OP_IN = .grn_operator.GRN_OP_IN,
1017 	GRN_OP_MATCH = .grn_operator.GRN_OP_MATCH,
1018 	GRN_OP_NEAR = .grn_operator.GRN_OP_NEAR,
1019 	GRN_OP_NEAR2 = .grn_operator.GRN_OP_NEAR2,
1020 	GRN_OP_SIMILAR = .grn_operator.GRN_OP_SIMILAR,
1021 	GRN_OP_TERM_EXTRACT = .grn_operator.GRN_OP_TERM_EXTRACT,
1022 	GRN_OP_SHIFTL = .grn_operator.GRN_OP_SHIFTL,
1023 	GRN_OP_SHIFTR = .grn_operator.GRN_OP_SHIFTR,
1024 	GRN_OP_SHIFTRR = .grn_operator.GRN_OP_SHIFTRR,
1025 	GRN_OP_PLUS = .grn_operator.GRN_OP_PLUS,
1026 	GRN_OP_MINUS = .grn_operator.GRN_OP_MINUS,
1027 	GRN_OP_STAR = .grn_operator.GRN_OP_STAR,
1028 	GRN_OP_SLASH = .grn_operator.GRN_OP_SLASH,
1029 	GRN_OP_MOD = .grn_operator.GRN_OP_MOD,
1030 	GRN_OP_DELETE = .grn_operator.GRN_OP_DELETE,
1031 	GRN_OP_INCR = .grn_operator.GRN_OP_INCR,
1032 	GRN_OP_DECR = .grn_operator.GRN_OP_DECR,
1033 	GRN_OP_INCR_POST = .grn_operator.GRN_OP_INCR_POST,
1034 	GRN_OP_DECR_POST = .grn_operator.GRN_OP_DECR_POST,
1035 	GRN_OP_NOT = .grn_operator.GRN_OP_NOT,
1036 	GRN_OP_ADJUST = .grn_operator.GRN_OP_ADJUST,
1037 	GRN_OP_EXACT = .grn_operator.GRN_OP_EXACT,
1038 	GRN_OP_LCP = .grn_operator.GRN_OP_LCP,
1039 	GRN_OP_PARTIAL = .grn_operator.GRN_OP_PARTIAL,
1040 	GRN_OP_UNSPLIT = .grn_operator.GRN_OP_UNSPLIT,
1041 	GRN_OP_PREFIX = .grn_operator.GRN_OP_PREFIX,
1042 	GRN_OP_SUFFIX = .grn_operator.GRN_OP_SUFFIX,
1043 	GRN_OP_GEO_DISTANCE1 = .grn_operator.GRN_OP_GEO_DISTANCE1,
1044 	GRN_OP_GEO_DISTANCE2 = .grn_operator.GRN_OP_GEO_DISTANCE2,
1045 	GRN_OP_GEO_DISTANCE3 = .grn_operator.GRN_OP_GEO_DISTANCE3,
1046 	GRN_OP_GEO_DISTANCE4 = .grn_operator.GRN_OP_GEO_DISTANCE4,
1047 	GRN_OP_GEO_WITHINP5 = .grn_operator.GRN_OP_GEO_WITHINP5,
1048 	GRN_OP_GEO_WITHINP6 = .grn_operator.GRN_OP_GEO_WITHINP6,
1049 	GRN_OP_GEO_WITHINP8 = .grn_operator.GRN_OP_GEO_WITHINP8,
1050 	GRN_OP_OBJ_SEARCH = .grn_operator.GRN_OP_OBJ_SEARCH,
1051 	GRN_OP_EXPR_GET_VAR = .grn_operator.GRN_OP_EXPR_GET_VAR,
1052 	GRN_OP_TABLE_CREATE = .grn_operator.GRN_OP_TABLE_CREATE,
1053 	GRN_OP_TABLE_SELECT = .grn_operator.GRN_OP_TABLE_SELECT,
1054 	GRN_OP_TABLE_SORT = .grn_operator.GRN_OP_TABLE_SORT,
1055 	GRN_OP_TABLE_GROUP = .grn_operator.GRN_OP_TABLE_GROUP,
1056 	GRN_OP_JSON_PUT = .grn_operator.GRN_OP_JSON_PUT,
1057 	GRN_OP_GET_MEMBER = .grn_operator.GRN_OP_GET_MEMBER,
1058 	GRN_OP_REGEXP = .grn_operator.GRN_OP_REGEXP,
1059 	GRN_OP_FUZZY = .grn_operator.GRN_OP_FUZZY,
1060 	GRN_OP_QUORUM = .grn_operator.GRN_OP_QUORUM,
1061 	GRN_OP_NEAR_PHRASE = .grn_operator.GRN_OP_NEAR_PHRASE,
1062 	GRN_OP_ORDERED_NEAR_PHRASE = .grn_operator.GRN_OP_ORDERED_NEAR_PHRASE,
1063 }
1064 
1065 //GRN_API
1066 .grn_obj* grn_obj_column(.grn_ctx* ctx, .grn_obj* table, const (char)* name, uint name_size);
1067 
1068 /*-------------------------------------------------------------
1069  * API for db, table and/or column
1070  */
1071 
1072 enum grn_info_type
1073 {
1074 	GRN_INFO_ENCODING = 0,
1075 	GRN_INFO_SOURCE,
1076 	GRN_INFO_DEFAULT_TOKENIZER,
1077 	GRN_INFO_ELEMENT_SIZE,
1078 	GRN_INFO_CURR_MAX,
1079 	GRN_INFO_MAX_ELEMENT_SIZE,
1080 	GRN_INFO_SEG_SIZE,
1081 	GRN_INFO_CHUNK_SIZE,
1082 	GRN_INFO_MAX_SECTION,
1083 	GRN_INFO_HOOK_LOCAL_DATA,
1084 	GRN_INFO_ELEMENT_A,
1085 	GRN_INFO_ELEMENT_CHUNK,
1086 	GRN_INFO_ELEMENT_CHUNK_SIZE,
1087 	GRN_INFO_ELEMENT_BUFFER_FREE,
1088 	GRN_INFO_ELEMENT_NTERMS,
1089 	GRN_INFO_ELEMENT_NTERMS_VOID,
1090 	GRN_INFO_ELEMENT_SIZE_IN_CHUNK,
1091 	GRN_INFO_ELEMENT_POS_IN_CHUNK,
1092 	GRN_INFO_ELEMENT_SIZE_IN_BUFFER,
1093 	GRN_INFO_ELEMENT_POS_IN_BUFFER,
1094 	GRN_INFO_ELEMENT_ESTIMATE_SIZE,
1095 	GRN_INFO_NGRAM_UNIT_SIZE,
1096 	/*
1097 	GRN_INFO_VERSION,
1098 	GRN_INFO_CONFIGURE_OPTIONS,
1099 	GRN_INFO_CONFIG_PATH,
1100 	*/
1101 	GRN_INFO_PARTIAL_MATCH_THRESHOLD,
1102 	GRN_INFO_II_SPLIT_THRESHOLD,
1103 	GRN_INFO_SUPPORT_ZLIB,
1104 	GRN_INFO_SUPPORT_LZ4,
1105 	/* Just for backward compatibility. We'll remove it at 5.0.0. */
1106 	GRN_INFO_SUPPORT_LZO = GRN_INFO_SUPPORT_LZ4,
1107 	GRN_INFO_NORMALIZER,
1108 	GRN_INFO_TOKEN_FILTERS,
1109 	GRN_INFO_SUPPORT_ZSTD,
1110 
1111 	GRN_INFO_SUPPORT_APACHE_ARROW,
1112 	GRN_INFO_NORMALIZERS,
1113 }
1114 
1115 //Declaration name in C language
1116 enum
1117 {
1118 	GRN_INFO_ENCODING = .grn_info_type.GRN_INFO_ENCODING,
1119 	GRN_INFO_SOURCE = .grn_info_type.GRN_INFO_SOURCE,
1120 	GRN_INFO_DEFAULT_TOKENIZER = .grn_info_type.GRN_INFO_DEFAULT_TOKENIZER,
1121 	GRN_INFO_ELEMENT_SIZE = .grn_info_type.GRN_INFO_ELEMENT_SIZE,
1122 	GRN_INFO_CURR_MAX = .grn_info_type.GRN_INFO_CURR_MAX,
1123 	GRN_INFO_MAX_ELEMENT_SIZE = .grn_info_type.GRN_INFO_MAX_ELEMENT_SIZE,
1124 	GRN_INFO_SEG_SIZE = .grn_info_type.GRN_INFO_SEG_SIZE,
1125 	GRN_INFO_CHUNK_SIZE = .grn_info_type.GRN_INFO_CHUNK_SIZE,
1126 	GRN_INFO_MAX_SECTION = .grn_info_type.GRN_INFO_MAX_SECTION,
1127 	GRN_INFO_HOOK_LOCAL_DATA = .grn_info_type.GRN_INFO_HOOK_LOCAL_DATA,
1128 	GRN_INFO_ELEMENT_A = .grn_info_type.GRN_INFO_ELEMENT_A,
1129 	GRN_INFO_ELEMENT_CHUNK = .grn_info_type.GRN_INFO_ELEMENT_CHUNK,
1130 	GRN_INFO_ELEMENT_CHUNK_SIZE = .grn_info_type.GRN_INFO_ELEMENT_CHUNK_SIZE,
1131 	GRN_INFO_ELEMENT_BUFFER_FREE = .grn_info_type.GRN_INFO_ELEMENT_BUFFER_FREE,
1132 	GRN_INFO_ELEMENT_NTERMS = .grn_info_type.GRN_INFO_ELEMENT_NTERMS,
1133 	GRN_INFO_ELEMENT_NTERMS_VOID = .grn_info_type.GRN_INFO_ELEMENT_NTERMS_VOID,
1134 	GRN_INFO_ELEMENT_SIZE_IN_CHUNK = .grn_info_type.GRN_INFO_ELEMENT_SIZE_IN_CHUNK,
1135 	GRN_INFO_ELEMENT_POS_IN_CHUNK = .grn_info_type.GRN_INFO_ELEMENT_POS_IN_CHUNK,
1136 	GRN_INFO_ELEMENT_SIZE_IN_BUFFER = .grn_info_type.GRN_INFO_ELEMENT_SIZE_IN_BUFFER,
1137 	GRN_INFO_ELEMENT_POS_IN_BUFFER = .grn_info_type.GRN_INFO_ELEMENT_POS_IN_BUFFER,
1138 	GRN_INFO_ELEMENT_ESTIMATE_SIZE = .grn_info_type.GRN_INFO_ELEMENT_ESTIMATE_SIZE,
1139 	GRN_INFO_NGRAM_UNIT_SIZE = .grn_info_type.GRN_INFO_NGRAM_UNIT_SIZE,
1140 	/*
1141 	GRN_INFO_VERSION = .grn_info_type.GRN_INFO_VERSION,
1142 	GRN_INFO_CONFIGURE_OPTIONS = .grn_info_type.GRN_INFO_CONFIGURE_OPTIONS,
1143 	GRN_INFO_CONFIG_PATH = .grn_info_type.GRN_INFO_CONFIG_PATH,
1144 	*/
1145 	GRN_INFO_PARTIAL_MATCH_THRESHOLD = .grn_info_type.GRN_INFO_PARTIAL_MATCH_THRESHOLD,
1146 	GRN_INFO_II_SPLIT_THRESHOLD = .grn_info_type.GRN_INFO_II_SPLIT_THRESHOLD,
1147 	GRN_INFO_SUPPORT_ZLIB = .grn_info_type.GRN_INFO_SUPPORT_ZLIB,
1148 	GRN_INFO_SUPPORT_LZ4 = .grn_info_type.GRN_INFO_SUPPORT_LZ4,
1149 	GRN_INFO_SUPPORT_LZO = .grn_info_type.GRN_INFO_SUPPORT_LZO,
1150 	GRN_INFO_NORMALIZER = .grn_info_type.GRN_INFO_NORMALIZER,
1151 	GRN_INFO_TOKEN_FILTERS = .grn_info_type.GRN_INFO_TOKEN_FILTERS,
1152 	GRN_INFO_SUPPORT_ZSTD = .grn_info_type.GRN_INFO_SUPPORT_ZSTD,
1153 
1154 	GRN_INFO_SUPPORT_APACHE_ARROW = .grn_info_type.GRN_INFO_SUPPORT_APACHE_ARROW,
1155 }
1156 
1157 /* Just for backward compatibility. */
1158 package alias GRN_INFO_SUPPORT_ARROW = .grn_info_type.GRN_INFO_SUPPORT_APACHE_ARROW;
1159 
1160 //GRN_API
1161 .grn_obj* grn_obj_get_info(.grn_ctx* ctx, .grn_obj* obj, .grn_info_type type, .grn_obj* valuebuf);
1162 
1163 //GRN_API
1164 .grn_rc grn_obj_set_info(.grn_ctx* ctx, .grn_obj* obj, .grn_info_type type, .grn_obj* value);
1165 
1166 //GRN_API
1167 .grn_obj* grn_obj_get_element_info(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, .grn_info_type type, .grn_obj* value);
1168 
1169 //GRN_API
1170 .grn_rc grn_obj_set_element_info(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, .grn_info_type type, .grn_obj* value);
1171 
1172 //GRN_API
1173 .grn_obj* grn_obj_get_value(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, .grn_obj* value);
1174 
1175 //GRN_API
1176 int grn_obj_get_values(.grn_ctx* ctx, .grn_obj* obj, .grn_id offset, void** values);
1177 
1178 
1179 //ToDo: temp
1180 alias internal_block_func = extern (C) nothrow @nogc void function();
1181 
1182 //ToDo: check
1183 /+
1184 pragma(inline, true)
1185 nothrow @nogc @disable
1186 void GRN_COLUMN_EACH(.grn_ctx* ctx, .grn_obj* column, uint id, void** value, internal_block_func block)
1187 
1188 	do
1189 	{
1190 		int _n;
1191 		.grn_id id = 1;
1192 
1193 		while ((_n = .grn_obj_get_values(ctx, column, id, value)) > 0) {
1194 			for (; _n; _n--, id++, value++) {
1195 				block();
1196 			}
1197 		}
1198 	}
1199 +/
1200 
1201 enum GRN_OBJ_SET_MASK = 0x07;
1202 enum GRN_OBJ_SET = 0x01;
1203 enum GRN_OBJ_INCR = 0x02;
1204 enum GRN_OBJ_DECR = 0x03;
1205 enum GRN_OBJ_APPEND = 0x04;
1206 enum GRN_OBJ_PREPEND = 0x05;
1207 enum GRN_OBJ_GET = 0x01 << 4;
1208 enum GRN_OBJ_COMPARE = 0x01 << 5;
1209 enum GRN_OBJ_LOCK = 0x01 << 6;
1210 enum GRN_OBJ_UNLOCK = 0x01 << 7;
1211 
1212 //GRN_API
1213 .grn_rc grn_obj_set_value(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, .grn_obj* value, int flags);
1214 
1215 //GRN_API
1216 .grn_rc grn_obj_remove(.grn_ctx* ctx, .grn_obj* obj);
1217 
1218 //GRN_API
1219 .grn_rc grn_obj_remove_dependent(.grn_ctx* ctx, .grn_obj* obj);
1220 
1221 //GRN_API
1222 .grn_rc grn_obj_remove_force(.grn_ctx* ctx, const (char)* name, int name_size);
1223 
1224 //GRN_API
1225 .grn_rc grn_obj_rename(.grn_ctx* ctx, .grn_obj* obj, const (char)* name, uint name_size);
1226 
1227 //GRN_API
1228 .grn_rc grn_table_rename(.grn_ctx* ctx, .grn_obj* table, const (char)* name, uint name_size);
1229 
1230 //GRN_API
1231 .grn_rc grn_column_rename(.grn_ctx* ctx, .grn_obj* column, const (char)* name, uint name_size);
1232 
1233 //GRN_API
1234 .grn_rc grn_obj_close(.grn_ctx* ctx, .grn_obj* obj);
1235 
1236 //GRN_API
1237 .grn_rc grn_obj_reinit(.grn_ctx* ctx, .grn_obj* obj, .grn_id domain, ubyte flags);
1238 /* On non reference count mode (default):
1239 * This closes the following objects immediately:
1240 *
1241 *   * Acceessor
1242 *   * Bulk
1243 *   * DB
1244 *   * Temporary column
1245 *   * Temporary table
1246 *
1247 * This does nothing for other objects such as persisted tables and
1248 * columns.
1249 *
1250 * On reference count mode (GRN_ENABLE_REFERENCE_COUNT=yes):
1251 * This closes the following objects immediately:
1252 *
1253 *   * Bulk
1254 *   * DB
1255 *
1256 * This decreases the reference count of the following objects:
1257 *
1258 *   * Acceessor
1259 *   * Column (both persisted and temporary)
1260 *   * Table (both persisted and temporary)
1261 *
1262 * If the decreased reference count is zero, the object is closed.
1263 */
1264 //GRN_API
1265 void grn_obj_unlink(.grn_ctx* ctx, .grn_obj* obj);
1266 
1267 //GRN_API
1268 .grn_rc grn_obj_refer(.grn_ctx* ctx, .grn_obj* obj);
1269 
1270 //GRN_API
1271 .grn_rc grn_obj_refer_recursive(.grn_ctx* ctx, .grn_obj* obj);
1272 
1273 //GRN_API
1274 .grn_rc grn_obj_refer_recursive_dependent(.grn_ctx* ctx, .grn_obj* obj);
1275 /* This calls grn_obj_unlink() only on reference count mode
1276 * (GRN_ENABLE_REFERENCE_COUNT=yes) */
1277 //GRN_API
1278 void grn_obj_unref(.grn_ctx* ctx, .grn_obj* obj);
1279 
1280 //GRN_API
1281 void grn_obj_unref_recursive(.grn_ctx* ctx, .grn_obj* obj);
1282 
1283 //GRN_API
1284 void grn_obj_unref_recursive_dependent(.grn_ctx* ctx, .grn_obj* obj);
1285 
1286 //GRN_API
1287 grn_user_data* grn_obj_user_data(.grn_ctx* ctx, .grn_obj* obj);
1288 
1289 //GRN_API
1290 .grn_rc grn_obj_set_finalizer(.grn_ctx* ctx, .grn_obj* obj, grn_proc_func* func);
1291 
1292 //GRN_API
1293 const (char)* grn_obj_path(.grn_ctx* ctx, .grn_obj* obj);
1294 
1295 //GRN_API
1296 int grn_obj_name(.grn_ctx* ctx, .grn_obj* obj, char* namebuf, int buf_size);
1297 
1298 //GRN_API
1299 int grn_column_name(.grn_ctx* ctx, .grn_obj* obj, char* namebuf, int buf_size);
1300 
1301 //GRN_API
1302 .grn_id grn_obj_get_range(.grn_ctx* ctx, .grn_obj* obj);
1303 
1304 pragma(inline, true)
1305 pure nothrow @trusted @nogc @live
1306 .grn_id GRN_OBJ_GET_DOMAIN(scope const .grn_obj* obj)
1307 
1308 	in
1309 	{
1310 		assert(obj != null);
1311 	}
1312 
1313 	do
1314 	{
1315 		return (obj.header.type == .GRN_TABLE_NO_KEY) ? (.GRN_ID_NIL) : (obj.header.domain);
1316 	}
1317 
1318 //GRN_API
1319 int grn_obj_expire(.grn_ctx* ctx, .grn_obj* obj, int threshold);
1320 
1321 //GRN_API
1322 int grn_obj_check(.grn_ctx* ctx, .grn_obj* obj);
1323 
1324 //GRN_API
1325 .grn_rc grn_obj_lock(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, int timeout);
1326 
1327 //GRN_API
1328 .grn_rc grn_obj_unlock(.grn_ctx* ctx, .grn_obj* obj, .grn_id id);
1329 
1330 //GRN_API
1331 .grn_rc grn_obj_clear_lock(.grn_ctx* ctx, .grn_obj* obj);
1332 
1333 //GRN_API
1334 uint grn_obj_is_locked(.grn_ctx* ctx, .grn_obj* obj);
1335 
1336 //GRN_API
1337 .grn_rc grn_obj_flush(.grn_ctx* ctx, .grn_obj* obj);
1338 
1339 //GRN_API
1340 .grn_rc grn_obj_flush_recursive(.grn_ctx* ctx, .grn_obj* obj);
1341 
1342 //GRN_API
1343 .grn_rc grn_obj_flush_recursive_dependent(.grn_ctx* ctx, .grn_obj* obj);
1344 
1345 //GRN_API
1346 .grn_rc grn_obj_flush_only_opened(.grn_ctx* ctx, .grn_obj* obj);
1347 
1348 //GRN_API
1349 int grn_obj_defrag(.grn_ctx* ctx, .grn_obj* obj, int threshold);
1350 
1351 //GRN_API
1352 .grn_obj* grn_obj_db(.grn_ctx* ctx, .grn_obj* obj);
1353 
1354 //GRN_API
1355 .grn_id grn_obj_id(.grn_ctx* ctx, .grn_obj* obj);
1356 
1357 /* Flags for grn_fuzzy_search_optarg.flags. */
1358 enum GRN_TABLE_FUZZY_SEARCH_WITH_TRANSPOSITION = 0x01;
1359 
1360 struct _grn_fuzzy_search_optarg
1361 {
1362 	uint max_distance;
1363 	uint max_expansion;
1364 	uint prefix_match_size;
1365 	int flags;
1366 }
1367 
1368 alias grn_fuzzy_search_optarg = ._grn_fuzzy_search_optarg;
1369 
1370 enum GRN_MATCH_INFO_GET_MIN_RECORD_ID = 0x01;
1371 enum GRN_MATCH_INFO_ONLY_SKIP_TOKEN = 0x02;
1372 
1373 struct _grn_match_info
1374 {
1375 	int flags;
1376 	.grn_id min;
1377 }
1378 
1379 alias grn_match_info = ._grn_match_info;
1380 
1381 struct _grn_search_optarg
1382 {
1383 	.grn_operator mode;
1384 	int similarity_threshold;
1385 	int max_interval;
1386 	int* weight_vector;
1387 	int vector_size;
1388 	.grn_obj* proc;
1389 	int max_size;
1390 	.grn_obj* scorer;
1391 	.grn_obj* scorer_args_expr;
1392 	uint scorer_args_expr_offset;
1393 	.grn_fuzzy_search_optarg fuzzy;
1394 	.grn_match_info match_info;
1395 	int quorum_threshold;
1396 	int additional_last_interval;
1397 	float* weight_vector_float;
1398 	float weight_float = 0;
1399 	.grn_obj* query_options;
1400 }
1401 
1402 alias grn_search_optarg = ._grn_search_optarg;
1403 
1404 //GRN_API
1405 .grn_rc grn_obj_search(.grn_ctx* ctx, .grn_obj* obj, .grn_obj* query, .grn_obj* res, .grn_operator op, .grn_search_optarg* optarg);
1406 
1407 //GRN_API
1408 .grn_rc grn_proc_set_is_stable(.grn_ctx* ctx, .grn_obj* proc, .grn_bool is_stable);
1409 
1410 //GRN_API
1411 .grn_bool grn_proc_is_stable(.grn_ctx* ctx, .grn_obj* proc);
1412 
1413 /*-------------------------------------------------------------
1414  * API for hook
1415  */
1416 
1417 //GRN_API
1418 int grn_proc_call_next(.grn_ctx* ctx, .grn_obj* exec_info, .grn_obj* in_, .grn_obj* out_);
1419 
1420 //GRN_API
1421 void* grn_proc_get_ctx_local_data(.grn_ctx* ctx, .grn_obj* exec_info);
1422 
1423 //GRN_API
1424 void* grn_proc_get_hook_local_data(.grn_ctx* ctx, .grn_obj* exec_info);
1425 
1426 enum grn_hook_entry
1427 {
1428 	GRN_HOOK_SET = 0,
1429 	GRN_HOOK_GET,
1430 	GRN_HOOK_INSERT,
1431 	GRN_HOOK_DELETE,
1432 	GRN_HOOK_SELECT,
1433 }
1434 
1435 //Declaration name in C language
1436 enum
1437 {
1438 	GRN_HOOK_SET = .grn_hook_entry.GRN_HOOK_SET,
1439 	GRN_HOOK_GET = .grn_hook_entry.GRN_HOOK_GET,
1440 	GRN_HOOK_INSERT = .grn_hook_entry.GRN_HOOK_INSERT,
1441 	GRN_HOOK_DELETE = .grn_hook_entry.GRN_HOOK_DELETE,
1442 	GRN_HOOK_SELECT = .grn_hook_entry.GRN_HOOK_SELECT,
1443 }
1444 
1445 //GRN_API
1446 .grn_rc grn_obj_add_hook(.grn_ctx* ctx, .grn_obj* obj, .grn_hook_entry entry, int offset, .grn_obj* proc, .grn_obj* data);
1447 
1448 //GRN_API
1449 int grn_obj_get_nhooks(.grn_ctx* ctx, .grn_obj* obj, .grn_hook_entry entry);
1450 
1451 //GRN_API
1452 .grn_obj* grn_obj_get_hook(.grn_ctx* ctx, .grn_obj* obj, .grn_hook_entry entry, int offset, .grn_obj* data);
1453 
1454 //GRN_API
1455 .grn_rc grn_obj_delete_hook(.grn_ctx* ctx, .grn_obj* obj, .grn_hook_entry entry, int offset);
1456 
1457 //GRN_API
1458 .grn_obj* grn_obj_open(.grn_ctx* ctx, ubyte type, .grn_obj_flags flags, .grn_id domain);
1459 
1460 /* Deprecated since 5.0.1. Use grn_column_find_index_data() instead. */
1461 
1462 //GRN_API
1463 int grn_column_index(.grn_ctx* ctx, .grn_obj* column, .grn_operator op, .grn_obj** indexbuf, int buf_size, int* section);
1464 
1465 /* @since 5.0.1. */
1466 struct _grn_index_datum
1467 {
1468 	.grn_obj* index;
1469 	uint section;
1470 }
1471 
1472 alias grn_index_datum = ._grn_index_datum;
1473 
1474 /* @since 5.0.1. */
1475 
1476 //GRN_API
1477 uint grn_column_find_index_data(.grn_ctx* ctx, .grn_obj* column, .grn_operator op, .grn_index_datum* index_data, uint n_index_data);
1478 /* @since 5.1.2. */
1479 
1480 //GRN_API
1481 uint grn_column_get_all_index_data(.grn_ctx* ctx, .grn_obj* column, .grn_index_datum* index_data, uint n_index_data);
1482 
1483 /* @since 9.1.2. */
1484 //GRN_API
1485 .grn_rc grn_column_get_all_index_columns(.grn_ctx* ctx, .grn_obj* column, .grn_obj* index_columns);
1486 
1487 //GRN_API
1488 .grn_rc grn_obj_delete_by_id(.grn_ctx* ctx, .grn_obj* db, .grn_id id, .grn_bool removep);
1489 
1490 //GRN_API
1491 .grn_rc grn_obj_path_by_id(.grn_ctx* ctx, .grn_obj* db, .grn_id id, char* buffer);
1492 
1493 /* query & snippet */
1494 
1495 static if (!__traits(compiles, .GRN_QUERY_AND)) {
1496 	enum GRN_QUERY_AND = '+';
1497 }
1498 
1499 static if (!__traits(compiles, .GRN_QUERY_AND_NOT)) {
1500 	static if (__traits(compiles, .GRN_QUERY_BUT)) {
1501 		/* Deprecated. Just for backward compatibility. */
1502 		enum GRN_QUERY_AND_NOT = .GRN_QUERY_BUT;
1503 	} else {
1504 		enum GRN_QUERY_AND_NOT = '-';
1505 	}
1506 }
1507 
1508 static if (!__traits(compiles, .GRN_QUERY_ADJ_INC)) {
1509 	enum GRN_QUERY_ADJ_INC = '>';
1510 }
1511 
1512 static if (!__traits(compiles, .GRN_QUERY_ADJ_DEC)) {
1513 	enum GRN_QUERY_ADJ_DEC = '<';
1514 }
1515 
1516 static if (!__traits(compiles, .GRN_QUERY_ADJ_NEG)) {
1517 	enum GRN_QUERY_ADJ_NEG = '~';
1518 }
1519 
1520 static if (!__traits(compiles, .GRN_QUERY_PREFIX)) {
1521 	enum GRN_QUERY_PREFIX = '*';
1522 }
1523 
1524 static if (!__traits(compiles, .GRN_QUERY_PARENL)) {
1525 	enum GRN_QUERY_PARENL = '(';
1526 }
1527 
1528 static if (!__traits(compiles, .GRN_QUERY_PARENR)) {
1529 	enum GRN_QUERY_PARENR = ')';
1530 }
1531 
1532 static if (!__traits(compiles, .GRN_QUERY_QUOTEL)) {
1533 	enum GRN_QUERY_QUOTEL = '"';
1534 }
1535 
1536 static if (!__traits(compiles, .GRN_QUERY_QUOTER)) {
1537 	enum GRN_QUERY_QUOTER = '"';
1538 }
1539 
1540 static if (!__traits(compiles, .GRN_QUERY_ESCAPE)) {
1541 	enum GRN_QUERY_ESCAPE = '\\';
1542 }
1543 
1544 static if (!__traits(compiles, .GRN_QUERY_COLUMN)) {
1545 	enum GRN_QUERY_COLUMN = ':';
1546 }
1547 
1548 struct _grn_snip_mapping
1549 {
1550 	void* dummy;
1551 }
1552 
1553 alias grn_snip_mapping = ._grn_snip_mapping;
1554 
1555 enum GRN_SNIP_NORMALIZE = 0x01 << 0;
1556 enum GRN_SNIP_COPY_TAG = 0x01 << 1;
1557 enum GRN_SNIP_SKIP_LEADING_SPACES = 0x01 << 2;
1558 
1559 /*
1560 //ToDo: 
1561 #define GRN_SNIP_MAPPING_HTML_ESCAPE ((.grn_snip_mapping *)-1)
1562 */
1563 
1564 //GRN_API
1565 .grn_obj* grn_snip_open(.grn_ctx* ctx, int flags, uint width, uint max_results, const (char)* defaultopentag, uint defaultopentag_len, const (char)* defaultclosetag, uint defaultclosetag_len, .grn_snip_mapping* mapping);
1566 
1567 //GRN_API
1568 .grn_rc grn_snip_add_cond(.grn_ctx* ctx, .grn_obj* snip, const (char)* keyword, uint keyword_len, const (char)* opentag, uint opentag_len, const (char)* closetag, uint closetag_len);
1569 
1570 //GRN_API
1571 .grn_rc grn_snip_set_normalizer(.grn_ctx* ctx, .grn_obj* snip, .grn_obj* normalizer);
1572 
1573 //GRN_API
1574 .grn_obj* grn_snip_get_normalizer(.grn_ctx* ctx, .grn_obj* snip);
1575 
1576 //GRN_API
1577 .grn_rc grn_snip_exec(.grn_ctx* ctx, .grn_obj* snip, const (char)* string_, uint string_len, uint* nresults, uint* max_tagged_len);
1578 
1579 //GRN_API
1580 .grn_rc grn_snip_get_result(.grn_ctx* ctx, .grn_obj* snip, const uint index, char* result, uint* result_len);
1581 
1582 /* log */
1583 
1584 enum GRN_LOG_NONE = 0x00 << 0;
1585 enum GRN_LOG_TIME = 0x01 << 0;
1586 enum GRN_LOG_TITLE = 0x01 << 1;
1587 enum GRN_LOG_MESSAGE = 0x01 << 2;
1588 enum GRN_LOG_LOCATION = 0x01 << 3;
1589 enum GRN_LOG_PID = 0x01 << 4;
1590 enum GRN_LOG_PROCESS_ID = .GRN_LOG_PID;
1591 enum GRN_LOG_THREAD_ID = 0x01 << 5;
1592 enum GRN_LOG_ALL = .GRN_LOG_TIME | .GRN_LOG_TITLE | .GRN_LOG_MESSAGE | .GRN_LOG_LOCATION | .GRN_LOG_PROCESS_ID | .GRN_LOG_THREAD_ID;
1593 enum GRN_LOG_DEFAULT = .GRN_LOG_TIME | .GRN_LOG_MESSAGE;
1594 
1595 /* Deprecated since 2.1.2. Use .grn_logger instead. */
1596 struct _grn_logger_info
1597 {
1598 extern (C):
1599 	.grn_log_level max_level;
1600 	int flags;
1601 	void function (int, const (char)*, const (char)*, const (char)*, const (char)*, void*) func;
1602 	void* func_arg;
1603 }
1604 
1605 /* Deprecated since 2.1.2. Use .grn_logger instead. */
1606 alias grn_logger_info = ._grn_logger_info;
1607 
1608 /* Deprecated since 2.1.2. Use grn_logger_set() instead. */
1609 
1610 //GRN_API
1611 .grn_rc grn_logger_info_set(.grn_ctx* ctx, const (.grn_logger_info)* info);
1612 
1613 struct _grn_logger
1614 {
1615 extern (C):
1616 	.grn_log_level max_level;
1617 	int flags;
1618 	void* user_data;
1619 	void function (.grn_ctx* ctx, .grn_log_level level, const (char)* timestamp, const (char)* title, const (char)* message, const (char)* location, void* user_data) log;
1620 	void function (.grn_ctx* ctx, void* user_data) reopen;
1621 	void function (.grn_ctx* ctx, void* user_data) fin;
1622 }
1623 
1624 alias grn_logger = ._grn_logger;
1625 
1626 //GRN_API
1627 .grn_bool grn_log_flags_parse(const (char)* string_, int string_size, int* flags);
1628 
1629 //GRN_API
1630 .grn_rc grn_logger_set(.grn_ctx* ctx, const (.grn_logger)* logger);
1631 
1632 //GRN_API
1633 void grn_logger_set_max_level(.grn_ctx* ctx, .grn_log_level max_level);
1634 
1635 //GRN_API
1636 .grn_log_level grn_logger_get_max_level(.grn_ctx* ctx);
1637 
1638 /+
1639 #ifdef __GNUC__
1640 # define GRN_ATTRIBUTE_PRINTF(fmt_pos) __attribute__ ((format(printf, fmt_pos, fmt_pos + 1)))
1641 #else
1642 # define GRN_ATTRIBUTE_PRINTF(fmt_pos)
1643 #endif /* __GNUC__ */
1644 
1645 #if defined(__clang__)
1646 # if __has_attribute(__alloc_size__)
1647 #  define HAVE_ALLOC_SIZE_ATTRIBUTE
1648 # endif /* __has_attribute(__alloc_size__) */
1649 #elif defined(__GNUC__) && ((__GNUC__ >= 5) || (__GNUC__ > 4 && __GNUC_MINOR__ >= 3))
1650 # define HAVE_ALLOC_SIZE_ATTRIBUTE
1651 #endif /* __clang__ */
1652 
1653 #ifdef HAVE_ALLOC_SIZE_ATTRIBUTE
1654 # define GRN_ATTRIBUTE_ALLOC_SIZE(size) __attribute__ ((alloc_size(size)))
1655 # define GRN_ATTRIBUTE_ALLOC_SIZE_N(n, size) __attribute__ ((alloc_size(n, size)))
1656 #else
1657 # define GRN_ATTRIBUTE_ALLOC_SIZE(size)
1658 # define GRN_ATTRIBUTE_ALLOC_SIZE_N(n, size)
1659 #endif /* HAVE_ALLOC_SIZE_ATTRIBUTE */
1660 
1661 //GRN_API
1662 void grn_logger_put(.grn_ctx* ctx, .grn_log_level level, const (char)* file, int line, const (char)* func, const (char)* fmt, ...) GRN_ATTRIBUTE_PRINTF(6);
1663 +/
1664 
1665 //GRN_API
1666 void grn_logger_putv(.grn_ctx* ctx, .grn_log_level level, const (char)* file, int line, const (char)* func, const (char)* fmt, core.stdc.stdarg.va_list ap);
1667 
1668 //GRN_API
1669 void grn_logger_reopen(.grn_ctx* ctx);
1670 
1671 //GRN_API
1672 .grn_bool grn_logger_pass(.grn_ctx* ctx, .grn_log_level level);
1673 
1674 //GRN_API
1675 .grn_bool grn_logger_is_default_logger(.grn_ctx* ctx);
1676 
1677 static if (!__traits(compiles, GRN_LOG_DEFAULT_LEVEL)) {
1678 	enum GRN_LOG_DEFAULT_LEVEL = .grn_log_level.GRN_LOG_NOTICE;
1679 }
1680 
1681 //GRN_API
1682 void grn_default_logger_set_max_level(.grn_log_level level);
1683 
1684 //GRN_API
1685 .grn_log_level grn_default_logger_get_max_level();
1686 
1687 //GRN_API
1688 void grn_default_logger_set_flags(int flags);
1689 
1690 //GRN_API
1691 int grn_default_logger_get_flags();
1692 
1693 //GRN_API
1694 void grn_default_logger_set_path(const (char)* path);
1695 
1696 //GRN_API
1697 const (char)* grn_default_logger_get_path();
1698 
1699 //GRN_API
1700 void grn_default_logger_set_rotate_threshold_size(.off_t threshold);
1701 
1702 //GRN_API
1703 .off_t grn_default_logger_get_rotate_threshold_size();
1704 
1705 /*
1706 #define GRN_LOG(ctx, level, ...)
1707 if (grn_logger_pass(ctx, level)) {
1708 	grn_logger_put(ctx, (level), __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__);
1709 }
1710 */
1711 
1712 struct _grn_query_logger
1713 {
1714 extern (C):
1715 	uint flags;
1716 	void* user_data;
1717 	void function(.grn_ctx* ctx, uint flag, const (char)* timestamp, const (char)* info, const (char)* message, void* user_data) log;
1718 	void function(.grn_ctx* ctx, void* user_data) reopen;
1719 	void function(.grn_ctx* ctx, void* user_data) fin;
1720 }
1721 
1722 alias grn_query_logger = ._grn_query_logger;
1723 
1724 //GRN_API
1725 .grn_bool grn_query_log_flags_parse(const (char)* string_, int string_size, uint* flags);
1726 
1727 //GRN_API
1728 .grn_rc grn_query_logger_set(.grn_ctx* ctx, const (.grn_query_logger)* logger);
1729 
1730 //GRN_API
1731 void grn_query_logger_set_flags(.grn_ctx* ctx, uint flags);
1732 
1733 //GRN_API
1734 void grn_query_logger_add_flags(.grn_ctx* ctx, uint flags);
1735 
1736 //GRN_API
1737 void grn_query_logger_remove_flags(.grn_ctx* ctx, uint flags);
1738 
1739 //GRN_API
1740 uint grn_query_logger_get_flags(.grn_ctx* ctx);
1741 
1742 /+
1743 //ToDo: 
1744 //GRN_API
1745 void grn_query_logger_put(.grn_ctx* ctx, uint flag, const (char)* mark, const (char)* format, ...) GRN_ATTRIBUTE_PRINTF(4);
1746 +/
1747 
1748 //GRN_API
1749 void grn_query_logger_reopen(.grn_ctx* ctx);
1750 
1751 //GRN_API
1752 .grn_bool grn_query_logger_pass(.grn_ctx* ctx, uint flag);
1753 
1754 //GRN_API
1755 void grn_default_query_logger_set_flags(uint flags);
1756 
1757 //GRN_API
1758 uint grn_default_query_logger_get_flags();
1759 
1760 //GRN_API
1761 void grn_default_query_logger_set_path(const (char)* path);
1762 
1763 //GRN_API
1764 const (char)* grn_default_query_logger_get_path();
1765 
1766 //GRN_API
1767 void grn_default_query_logger_set_rotate_threshold_size(.off_t threshold);
1768 
1769 //GRN_API
1770 .off_t grn_default_query_logger_get_rotate_threshold_size();
1771 
1772 /*
1773 //ToDo: 
1774 #define GRN_QUERY_LOG(ctx, flag, mark, format, ...)
1775 if (grn_query_logger_pass(ctx, flag)) {
1776 	grn_query_logger_put(ctx, (flag), (mark), format, __VA_ARGS__);
1777 }
1778 */
1779 
1780 /* grn_bulk */
1781 
1782 enum GRN_BULK_BUFSIZE = .grn_obj.sizeof - .grn_obj_header.sizeof;
1783 /* This assumes that .GRN_BULK_BUFSIZE is less than 32 (= 0x20). */
1784 enum GRN_BULK_BUFSIZE_MAX = 0x1F;
1785 
1786 pragma(inline, true)
1787 pure nothrow @trusted @nogc @live
1788 FLAGS GRN_BULK_SIZE_IN_FLAGS(FLAGS)(FLAGS flags)
1789 
1790 	do
1791 	{
1792 		return flags & .GRN_BULK_BUFSIZE_MAX;
1793 	}
1794 
1795 pragma(inline, true)
1796 pure nothrow @trusted @nogc @live
1797 ubyte GRN_BULK_OUTP(scope const .grn_obj* bulk)
1798 
1799 	in
1800 	{
1801 		assert(bulk != null);
1802 	}
1803 
1804 	do
1805 	{
1806 		return bulk.header.impl_flags & .GRN_OBJ_OUTPLACE;
1807 	}
1808 
1809 pragma(inline, true)
1810 pure nothrow @trusted @nogc @live
1811 void GRN_BULK_REWIND(scope .grn_obj* bulk)
1812 
1813 	in
1814 	{
1815 		assert(bulk != null);
1816 	}
1817 
1818 	do
1819 	{
1820 		if (bulk.header.type == .GRN_VECTOR) {
1821 			.grn_obj* _body = bulk.u.v.body_;
1822 
1823 			if (_body != null) {
1824 				if (.GRN_BULK_OUTP(_body)) {
1825 					_body.u.b.curr = _body.u.b.head;
1826 				} else {
1827 					_body.header.flags &= ~.GRN_BULK_BUFSIZE_MAX;
1828 				}
1829 			}
1830 
1831 			bulk.u.v.n_sections = 0;
1832 		} else {
1833 			if (.GRN_BULK_OUTP(bulk)) {
1834 				bulk.u.b.curr = bulk.u.b.head;
1835 			} else {
1836 				bulk.header.flags &= ~.GRN_BULK_BUFSIZE_MAX;
1837 			}
1838 		}
1839 	}
1840 
1841 pragma(inline, true)
1842 pure nothrow @trusted @nogc @live
1843 void GRN_BULK_SET_CURR(scope .grn_obj* buf, char* p)
1844 
1845 	in
1846 	{
1847 		assert(buf != null);
1848 	}
1849 
1850 	do
1851 	{
1852 		if (.GRN_BULK_OUTP(buf)) {
1853 			buf.u.b.curr = p;
1854 		} else {
1855 			buf.header.flags = cast(.grn_obj_flags)(p -GRN_BULK_HEAD(buf));
1856 		}
1857 	}
1858 
1859 pragma(inline, true)
1860 pure nothrow @trusted @nogc @live
1861 void GRN_BULK_INCR_LEN(scope .grn_obj* bulk, size_t len)
1862 
1863 	in
1864 	{
1865 		assert(bulk != null);
1866 	}
1867 
1868 	do
1869 	{
1870 		if (.GRN_BULK_OUTP(bulk)) {
1871 			bulk.u.b.curr += len;
1872 		} else {
1873 			bulk.header.flags += cast(.grn_obj_flags)(len);
1874 		}
1875 	}
1876 
1877 pragma(inline, true)
1878 pure nothrow @trusted @nogc @live
1879 char* GRN_BULK_WSIZE(return scope .grn_obj* bulk)
1880 
1881 	in
1882 	{
1883 		assert(bulk != null);
1884 	}
1885 
1886 	do
1887 	{
1888 		return (.GRN_BULK_OUTP(bulk)) ? (cast(char*)(bulk.u.b.tail - bulk.u.b.head)) : (cast(char*)(.GRN_BULK_BUFSIZE));
1889 	}
1890 
1891 pragma(inline, true)
1892 pure nothrow @trusted @nogc @live
1893 char* GRN_BULK_REST(return scope .grn_obj* bulk)
1894 
1895 	in
1896 	{
1897 		assert(bulk != null);
1898 	}
1899 
1900 	do
1901 	{
1902 		return (.GRN_BULK_OUTP(bulk)) ? (cast(char*)(bulk.u.b.tail - bulk.u.b.curr)) : (cast(char*)(.GRN_BULK_BUFSIZE - .GRN_BULK_SIZE_IN_FLAGS(bulk.header.flags)));
1903 	}
1904 
1905 pragma(inline, true)
1906 pure nothrow @trusted @nogc @live
1907 char* GRN_BULK_VSIZE(return scope .grn_obj* bulk)
1908 
1909 	in
1910 	{
1911 		assert(bulk != null);
1912 	}
1913 
1914 	do
1915 	{
1916 		return (.GRN_BULK_OUTP(bulk)) ? (cast(char*)(bulk.u.b.curr - bulk.u.b.head)) : (cast(char*)(.GRN_BULK_SIZE_IN_FLAGS(bulk.header.flags)));
1917 	}
1918 
1919 pragma(inline, true)
1920 pure nothrow @trusted @nogc @live
1921 char* GRN_BULK_EMPTYP(return scope .grn_obj* bulk)
1922 
1923 	in
1924 	{
1925 		assert(bulk != null);
1926 	}
1927 
1928 	do
1929 	{
1930 		return (.GRN_BULK_OUTP(bulk)) ? (cast(char*)(bulk.u.b.curr == bulk.u.b.head)) : (cast(char*)(!(.GRN_BULK_SIZE_IN_FLAGS(bulk.header.flags))));
1931 	}
1932 
1933 pragma(inline, true)
1934 pure nothrow @trusted @nogc @live
1935 char* GRN_BULK_HEAD(return scope .grn_obj* bulk)
1936 
1937 	in
1938 	{
1939 		assert(bulk != null);
1940 	}
1941 
1942 	do
1943 	{
1944 		return (.GRN_BULK_OUTP(bulk)) ? (bulk.u.b.head) : (cast(char*)(&(bulk.u.b.head)));
1945 	}
1946 
1947 pragma(inline, true)
1948 pure nothrow @trusted @nogc @live
1949 char* GRN_BULK_CURR(return scope .grn_obj* bulk)
1950 
1951 	in
1952 	{
1953 		assert(bulk != null);
1954 	}
1955 
1956 	do
1957 	{
1958 		return (.GRN_BULK_OUTP(bulk)) ? (bulk.u.b.curr) : (cast(char*)(&(bulk.u.b.head)) + .GRN_BULK_SIZE_IN_FLAGS(bulk.header.flags));
1959 	}
1960 
1961 pragma(inline, true)
1962 pure nothrow @trusted @nogc @live
1963 char* GRN_BULK_TAIL(return scope .grn_obj* bulk)
1964 
1965 	in
1966 	{
1967 		assert(bulk != null);
1968 	}
1969 
1970 	do
1971 	{
1972 		return (.GRN_BULK_OUTP(bulk)) ? (bulk.u.b.tail) : (cast(char*)(&(bulk[1])));
1973 	}
1974 
1975 //GRN_API
1976 .grn_rc grn_bulk_reinit(.grn_ctx* ctx, .grn_obj* bulk, size_t size);
1977 
1978 //GRN_API
1979 .grn_rc grn_bulk_resize(.grn_ctx* ctx, .grn_obj* bulk, size_t newsize);
1980 
1981 //GRN_API
1982 .grn_rc grn_bulk_write(.grn_ctx* ctx, .grn_obj* bulk, const (char)* str, size_t len);
1983 
1984 //GRN_API
1985 .grn_rc grn_bulk_write_from(.grn_ctx* ctx, .grn_obj* bulk, const (char)* str, size_t from, size_t len);
1986 
1987 //GRN_API
1988 .grn_rc grn_bulk_reserve(.grn_ctx* ctx, .grn_obj* bulk, size_t len);
1989 
1990 //GRN_API
1991 .grn_rc grn_bulk_space(.grn_ctx* ctx, .grn_obj* bulk, size_t len);
1992 
1993 //GRN_API
1994 .grn_rc grn_bulk_truncate(.grn_ctx* ctx, .grn_obj* bulk, size_t len);
1995 
1996 //GRN_API
1997 char* grn_bulk_detach(.grn_ctx* ctx, .grn_obj* bulk);
1998 
1999 //GRN_API
2000 .grn_rc grn_bulk_fin(.grn_ctx* ctx, .grn_obj* bulk);
2001 
2002 /* grn_text */
2003 
2004 //GRN_API
2005 .grn_rc grn_text_itoa(.grn_ctx* ctx, .grn_obj* bulk, int i);
2006 
2007 //GRN_API
2008 .grn_rc grn_text_itoa_padded(.grn_ctx* ctx, .grn_obj* bulk, int i, char ch, size_t len);
2009 
2010 //GRN_API
2011 .grn_rc grn_text_lltoa(.grn_ctx* ctx, .grn_obj* bulk, long i);
2012 
2013 //GRN_API
2014 .grn_rc grn_text_f32toa(.grn_ctx* ctx, .grn_obj* bulk, float f);
2015 
2016 //GRN_API
2017 .grn_rc grn_text_ftoa(.grn_ctx* ctx, .grn_obj* bulk, double d);
2018 
2019 //GRN_API
2020 .grn_rc grn_text_itoh(.grn_ctx* ctx, .grn_obj* bulk, uint i, size_t len);
2021 
2022 //GRN_API
2023 .grn_rc grn_text_itob(.grn_ctx* ctx, .grn_obj* bulk, .grn_id id);
2024 
2025 //GRN_API
2026 .grn_rc grn_text_lltob32h(.grn_ctx* ctx, .grn_obj* bulk, long i);
2027 
2028 //GRN_API
2029 .grn_rc grn_text_benc(.grn_ctx* ctx, .grn_obj* bulk, uint v);
2030 
2031 //GRN_API
2032 .grn_rc grn_text_esc(.grn_ctx* ctx, .grn_obj* bulk, const (char)* s, size_t len);
2033 
2034 //GRN_API
2035 .grn_rc grn_text_urlenc(.grn_ctx* ctx, .grn_obj* buf, const (char)* str, size_t len);
2036 
2037 //GRN_API
2038 const (char)* grn_text_urldec(.grn_ctx* ctx, .grn_obj* buf, const (char)* s, const (char)* e, char d);
2039 
2040 //GRN_API
2041 .grn_rc grn_text_escape_xml(.grn_ctx* ctx, .grn_obj* buf, const (char)* s, size_t len);
2042 
2043 //GRN_API
2044 .grn_rc grn_text_time2rfc1123(.grn_ctx* ctx, .grn_obj* bulk, int sec);
2045 
2046 /+
2047 //ToDo:
2048 //GRN_API
2049 .grn_rc grn_text_printf(.grn_ctx* ctx, .grn_obj* bulk, const (char)* format, ...) GRN_ATTRIBUTE_PRINTF(3);
2050 +/
2051 
2052 //GRN_API
2053 .grn_rc grn_text_printfv(.grn_ctx* ctx, .grn_obj* bulk, const (char)* format, core.stdc.stdarg.va_list args);
2054 /* Deprecated since 10.0.3. Use grn_text_printfv() instead. */
2055 //GRN_API
2056 .grn_rc grn_text_vprintf(.grn_ctx* ctx, .grn_obj* bulk, const (char)* format, core.stdc.stdarg.va_list args);
2057 
2058 alias grn_recv_handler_func = extern (C) void function(.grn_ctx* ctx, int flags, void* user_data);
2059 
2060 //GRN_API
2061 void grn_ctx_recv_handler_set(.grn_ctx*, .grn_recv_handler_func func, void* user_data);
2062 
2063 
2064 /* various values exchanged via .grn_obj */
2065 
2066 enum GRN_OBJ_DO_SHALLOW_COPY = .GRN_OBJ_REFER|.GRN_OBJ_OUTPLACE;
2067 enum GRN_OBJ_VECTOR = 0x01 << 7;
2068 
2069 /+
2070 #define GRN_OBJ_DO_SHALLOW_COPY        (GRN_OBJ_REFER|GRN_OBJ_OUTPLACE)
2071 #define GRN_OBJ_VECTOR                 (0x01<<7)
2072 
2073 #define GRN_OBJ_MUTABLE(obj) ((obj) && (obj)->header.type <= GRN_VECTOR)
2074 
2075 #define GRN_VALUE_FIX_SIZE_INIT(obj,flags,domain)\
2076 	GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_UVECTOR : GRN_BULK,\
2077 	             ((flags) & GRN_OBJ_DO_SHALLOW_COPY), (domain))
2078 #define GRN_VALUE_VAR_SIZE_INIT(obj,flags,domain)\
2079 	GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_VECTOR : GRN_BULK,\
2080 	             ((flags) & GRN_OBJ_DO_SHALLOW_COPY), (domain))
2081 
2082 #define GRN_VOID_INIT(obj) GRN_OBJ_INIT((obj), GRN_VOID, 0, GRN_DB_VOID)
2083 #define GRN_TEXT_INIT(obj,flags) \
2084 	GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_TEXT)
2085 #define GRN_SHORT_TEXT_INIT(obj,flags) \
2086 	GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_SHORT_TEXT)
2087 #define GRN_LONG_TEXT_INIT(obj,flags) \
2088 	GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_LONG_TEXT)
2089 #define GRN_TEXT_SET_REF(obj,str,len) do {\
2090 		(obj)->u.b.head = (char *)(str);\
2091 		(obj)->u.b.curr = (char *)(str) + (len);\
2092 	} while (0)
2093 #define GRN_TEXT_SET(ctx,obj,str,len) do {\
2094 		if ((obj)->header.impl_flags & GRN_OBJ_REFER) {\
2095 			GRN_TEXT_SET_REF((obj), (str), (len));\
2096 		} else {\
2097 			grn_bulk_write_from((ctx), (obj), (const char *)(str), 0, (unsigned int)(len));\
2098 		}\
2099 	} while (0)
2100 #define GRN_TEXT_PUT(ctx,obj,str,len) \
2101 	grn_bulk_write((ctx), (obj), (const char *)(str), (unsigned int)(len))
2102 #define GRN_TEXT_PUTC(ctx,obj,c) do {\
2103 		char _c = (c); grn_bulk_write((ctx), (obj), &_c, 1);\
2104 	} while (0)
2105 
2106 #define GRN_TEXT_PUTS(ctx,obj,str) GRN_TEXT_PUT((ctx), (obj), (str), strlen(str))
2107 #define GRN_TEXT_SETS(ctx,obj,str) GRN_TEXT_SET((ctx), (obj), (str), strlen(str))
2108 #define GRN_TEXT_VALUE(obj) GRN_BULK_HEAD(obj)
2109 #define GRN_TEXT_LEN(obj) GRN_BULK_VSIZE(obj)
2110 
2111 #define GRN_TEXT_EQUAL_CSTRING(bulk, string_)\
2112 	(GRN_TEXT_LEN(bulk) == strlen(string_) &&\
2113 	 memcmp(GRN_TEXT_VALUE(bulk), string_, GRN_TEXT_LEN(bulk)) == 0)
2114 
2115 #define GRN_BOOL_INIT(obj,flags) \
2116 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BOOL)
2117 #define GRN_INT8_INIT(obj,flags) \
2118 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT8)
2119 #define GRN_UINT8_INIT(obj,flags) \
2120 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT8)
2121 #define GRN_INT16_INIT(obj,flags) \
2122 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT16)
2123 #define GRN_UINT16_INIT(obj,flags) \
2124 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT16)
2125 #define GRN_INT32_INIT(obj,flags) \
2126 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT32)
2127 #define GRN_UINT32_INIT(obj,flags) \
2128 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT32)
2129 #define GRN_INT64_INIT(obj,flags) \
2130 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT64)
2131 #define GRN_UINT64_INIT(obj,flags) \
2132 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT64)
2133 #define GRN_FLOAT32_INIT(obj, flags) \
2134 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT32)
2135 #define GRN_FLOAT_INIT(obj,flags) \
2136 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT)
2137 #define GRN_TIME_INIT(obj,flags) \
2138 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TIME)
2139 #define GRN_RECORD_INIT GRN_VALUE_FIX_SIZE_INIT
2140 #define GRN_PTR_INIT(obj,flags,domain)\
2141 	GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_PVECTOR : GRN_PTR,\
2142 	             ((flags) & (GRN_OBJ_DO_SHALLOW_COPY | GRN_OBJ_OWN)),\
2143 	             (domain))
2144 #define GRN_TOKYO_GEO_POINT_INIT(obj,flags) \
2145 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TOKYO_GEO_POINT)
2146 #define GRN_WGS84_GEO_POINT_INIT(obj,flags) \
2147 	GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_WGS84_GEO_POINT)
2148 
2149 #define GRN_BOOL_SET(ctx,obj,val) do {\
2150 		bool _val = (bool)(val);\
2151 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(bool));\
2152 	} while (0)
2153 #define GRN_INT8_SET(ctx,obj,val) do {\
2154 		int8_t _val = (int8_t)(val);\
2155 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int8_t));\
2156 	} while (0)
2157 #define GRN_UINT8_SET(ctx,obj,val) do {\
2158 		uint8_t _val = (uint8_t)(val);\
2159 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint8_t));\
2160 	} while (0)
2161 #define GRN_INT16_SET(ctx,obj,val) do {\
2162 		int16_t _val = (int16_t)(val);\
2163 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int16_t));\
2164 	} while (0)
2165 #define GRN_UINT16_SET(ctx,obj,val) do {\
2166 		uint16_t _val = (uint16_t)(val);\
2167 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint16_t));\
2168 	} while (0)
2169 #define GRN_INT32_SET(ctx,obj,val) do {\
2170 		int32_t _val = (int32_t)(val);\
2171 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int32_t));\
2172 	} while (0)
2173 #define GRN_UINT32_SET(ctx,obj,val) do {\
2174 		uint32_t _val = (uint32_t)(val);\
2175 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint32_t));\
2176 	} while (0)
2177 #define GRN_INT64_SET(ctx,obj,val) do {\
2178 		int64_t _val = (int64_t)(val);\
2179 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int64_t));\
2180 	} while (0)
2181 #define GRN_UINT64_SET(ctx,obj,val) do {\
2182 		uint64_t _val = (uint64_t)(val);\
2183 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint64_t));\
2184 	} while (0)
2185 #define GRN_FLOAT32_SET(ctx, obj, val) \
2186 	do { \
2187 		float _val = (float) (val); \
2188 		grn_bulk_write_from((ctx), (obj), (char*) &_val, 0, sizeof(float)); \
2189 	} while (0)
2190 #define GRN_FLOAT_SET(ctx,obj,val) do {\
2191 		double _val = (double)(val);\
2192 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(double));\
2193 	} while (0)
2194 #define GRN_TIME_SET GRN_INT64_SET
2195 #define GRN_RECORD_SET(ctx,obj,val) do {\
2196 		grn_id _val = (grn_id)(val);\
2197 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_id));\
2198 	} while (0)
2199 #define GRN_PTR_SET(ctx,obj,val) do {\
2200 		grn_obj *_val = (grn_obj *)(val);\
2201 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_obj *));\
2202 	} while (0)
2203 
2204 #define GRN_GEO_DEGREE2MSEC(degree)\
2205 	((int32_t)((degree) * 3600 * 1000 + ((degree) > 0 ? 0.5 : -0.5)))
2206 #define GRN_GEO_MSEC2DEGREE(msec)\
2207 	((((int32_t)(msec)) / 3600.0) * 0.001)
2208 
2209 #define GRN_GEO_POINT_SET(ctx,obj,_latitude,_longitude) do {\
2210 		grn_geo_point _val;\
2211 		_val.latitude = (int)(_latitude);\
2212 		_val.longitude = (int)(_longitude);\
2213 		grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_geo_point));\
2214 	} while (0)
2215 
2216 #define GRN_BOOL_SET_AT(ctx,obj,offset,val) do {\
2217 		bool _val = (bool)(val);\
2218 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2219 		                    (offset), sizeof(bool));\
2220 	} while (0)
2221 #define GRN_INT8_SET_AT(ctx,obj,offset,val) do {\
2222 		int8_t _val = (int8_t)(val);\
2223 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2224 		                    (offset) * sizeof(int8_t), sizeof(int8_t));\
2225 	} while (0)
2226 #define GRN_UINT8_SET_AT(ctx,obj,offset,val) do { \
2227 		uint8_t _val = (uint8_t)(val);\
2228 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2229 		                    (offset) * sizeof(uint8_t), sizeof(uint8_t));\
2230 	} while (0)
2231 #define GRN_INT16_SET_AT(ctx,obj,offset,val) do {\
2232 		int16_t _val = (int16_t)(val);\
2233 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2234 		                    (offset) * sizeof(int16_t), sizeof(int16_t));\
2235 	} while (0)
2236 #define GRN_UINT16_SET_AT(ctx,obj,offset,val) do { \
2237 		uint16_t _val = (uint16_t)(val);\
2238 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2239 		                    (offset) * sizeof(uint16_t), sizeof(uint16_t));\
2240 	} while (0)
2241 #define GRN_INT32_SET_AT(ctx,obj,offset,val) do {\
2242 		int32_t _val = (int32_t)(val);\
2243 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2244 		                    (offset) * sizeof(int32_t), sizeof(int32_t));\
2245 	} while (0)
2246 #define GRN_UINT32_SET_AT(ctx,obj,offset,val) do { \
2247 		uint32_t _val = (uint32_t)(val);\
2248 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2249 		                    (offset) * sizeof(uint32_t), sizeof(uint32_t));\
2250 	} while (0)
2251 #define GRN_INT64_SET_AT(ctx,obj,offset,val) do {\
2252 		int64_t _val = (int64_t)(val);\
2253 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2254 		                    (offset) * sizeof(int64_t), sizeof(int64_t));\
2255 	} while (0)
2256 #define GRN_UINT64_SET_AT(ctx,obj,offset,val) do {\
2257 		uint64_t _val = (uint64_t)(val);\
2258 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2259 		                    (offset) * sizeof(uint64_t),\
2260 		                    sizeof(uint64_t));\
2261 	} while (0)
2262 #define GRN_FLOAT32_SET_AT(ctx, obj, offset, val) \
2263 	do { \
2264 		float _val = (float) (val); \
2265 		grn_bulk_write_from((ctx), (obj), (char*) &_val, (offset) * sizeof(float), sizeof(float)); \
2266 	} while (0)
2267 #define GRN_FLOAT_SET_AT(ctx,obj,offset,val) do {\
2268 		double _val = (double)(val);\
2269 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2270 		                    (offset) * sizeof(double), sizeof(double));\
2271 	} while (0)
2272 #define GRN_TIME_SET_AT GRN_INT64_SET_AT
2273 #define GRN_RECORD_SET_AT(ctx,obj,offset,val) do {\
2274 		grn_id _val = (grn_id)(val);\
2275 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2276 		                    (offset) * sizeof(grn_id), sizeof(grn_id));\
2277 	} while (0)
2278 #define GRN_PTR_SET_AT(ctx,obj,offset,val) do {\
2279 		grn_obj *_val = (grn_obj *)(val);\
2280 		grn_bulk_write_from((ctx), (obj), (char *)&_val,\
2281 		                    (offset) * sizeof(grn_obj *), sizeof(grn_obj *));\
2282 	} while (0)
2283 
2284 #define GRN_BOOL_VALUE(obj) (*((bool *)GRN_BULK_HEAD(obj)))
2285 #define GRN_INT8_VALUE(obj) (*((int8_t *)GRN_BULK_HEAD(obj)))
2286 #define GRN_UINT8_VALUE(obj) (*((uint8_t *)GRN_BULK_HEAD(obj)))
2287 #define GRN_INT16_VALUE(obj) (*((int16_t *)GRN_BULK_HEAD(obj)))
2288 #define GRN_UINT16_VALUE(obj) (*((uint16_t *)GRN_BULK_HEAD(obj)))
2289 #define GRN_INT32_VALUE(obj) (*((int32_t *)GRN_BULK_HEAD(obj)))
2290 #define GRN_UINT32_VALUE(obj) (*((uint32_t *)GRN_BULK_HEAD(obj)))
2291 #define GRN_INT64_VALUE(obj) (*((int64_t *)GRN_BULK_HEAD(obj)))
2292 #define GRN_UINT64_VALUE(obj) (*((uint64_t *)GRN_BULK_HEAD(obj)))
2293 #define GRN_FLOAT32_VALUE(obj) (*((float*) GRN_BULK_HEAD(obj)))
2294 #define GRN_FLOAT_VALUE(obj) (*((double *)GRN_BULK_HEAD(obj)))
2295 #define GRN_TIME_VALUE GRN_INT64_VALUE
2296 #define GRN_RECORD_VALUE(obj) (*((grn_id *)GRN_BULK_HEAD(obj)))
2297 #define GRN_PTR_VALUE(obj) (*((grn_obj **)GRN_BULK_HEAD(obj)))
2298 #define GRN_GEO_POINT_VALUE(obj,_latitude,_longitude) do {\
2299 		grn_geo_point *_val = (grn_geo_point *)GRN_BULK_HEAD(obj);\
2300 		_latitude = _val->latitude;\
2301 		_longitude = _val->longitude;\
2302 	} while (0)
2303 
2304 #define GRN_BOOL_VALUE_AT(obj,offset) (((bool *)GRN_BULK_HEAD(obj))[offset])
2305 #define GRN_INT8_VALUE_AT(obj,offset) (((int8_t *)GRN_BULK_HEAD(obj))[offset])
2306 #define GRN_UINT8_VALUE_AT(obj,offset) (((uint8_t *)GRN_BULK_HEAD(obj))[offset])
2307 #define GRN_INT16_VALUE_AT(obj,offset) (((int16_t *)GRN_BULK_HEAD(obj))[offset])
2308 #define GRN_UINT16_VALUE_AT(obj,offset) (((uint16_t *)GRN_BULK_HEAD(obj))[offset])
2309 #define GRN_INT32_VALUE_AT(obj,offset) (((int32_t *)GRN_BULK_HEAD(obj))[offset])
2310 #define GRN_UINT32_VALUE_AT(obj,offset) (((uint32_t *)GRN_BULK_HEAD(obj))[offset])
2311 #define GRN_INT64_VALUE_AT(obj,offset) (((int64_t *)GRN_BULK_HEAD(obj))[offset])
2312 #define GRN_UINT64_VALUE_AT(obj,offset) (((uint64_t *)GRN_BULK_HEAD(obj))[offset])
2313 #define GRN_FLOAT32_VALUE_AT(obj, offset) (((float*) GRN_BULK_HEAD(obj))[offset])
2314 #define GRN_FLOAT_VALUE_AT(obj,offset) (((double *)GRN_BULK_HEAD(obj))[offset])
2315 #define GRN_TIME_VALUE_AT GRN_INT64_VALUE_AT
2316 #define GRN_RECORD_VALUE_AT(obj,offset) (((grn_id *)GRN_BULK_HEAD(obj))[offset])
2317 #define GRN_PTR_VALUE_AT(obj,offset) (((grn_obj **)GRN_BULK_HEAD(obj))[offset])
2318 
2319 #define GRN_BOOL_PUT(ctx,obj,val) do {\
2320 		bool _val = (bool)(val);\
2321 		grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(bool));\
2322 	} while (0)
2323 #define GRN_INT8_PUT(ctx,obj,val) do {\
2324 		int8_t _val = (int8_t)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int8_t));\
2325 	} while (0)
2326 #define GRN_UINT8_PUT(ctx,obj,val) do {\
2327 		uint8_t _val = (uint8_t)(val);\
2328 		grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint8_t));\
2329 	} while (0)
2330 #define GRN_INT16_PUT(ctx,obj,val) do {\
2331 		int16_t _val = (int16_t)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int16_t));\
2332 	} while (0)
2333 #define GRN_UINT16_PUT(ctx,obj,val) do {\
2334 		uint16_t _val = (uint16_t)(val);\
2335 		grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint16_t));\
2336 	} while (0)
2337 #define GRN_INT32_PUT(ctx,obj,val) do {\
2338 		int32_t _val = (int32_t)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int32_t));\
2339 	} while (0)
2340 #define GRN_UINT32_PUT(ctx,obj,val) do {\
2341 		uint32_t _val = (uint32_t)(val);\
2342 		grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned int));\
2343 	} while (0)
2344 #define GRN_INT64_PUT(ctx,obj,val) do {\
2345 		int64_t _val = (int64_t)(val);\
2346 		grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int64_t));\
2347 	} while (0)
2348 #define GRN_UINT64_PUT(ctx,obj,val) do {\
2349 		uint64_t _val = (uint64_t)(val);\
2350 		grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint64_t));\
2351 	} while (0)
2352 #define GRN_FLOAT32_PUT(ctx, obj, val) \
2353 	do { \
2354 		float _val = (float) (val); \
2355 		grn_bulk_write((ctx), (obj), (char*) &_val, sizeof(float)); \
2356 	} while (0)
2357 #define GRN_FLOAT_PUT(ctx,obj,val) do {\
2358 		double _val = (double)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(double));\
2359 	} while (0)
2360 #define GRN_TIME_PUT GRN_INT64_PUT
2361 #define GRN_RECORD_PUT(ctx,obj,val) do {\
2362 		grn_id _val = (grn_id)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_id));\
2363 	} while (0)
2364 #define GRN_PTR_PUT(ctx,obj,val) do {\
2365 		grn_obj *_val = (grn_obj *)(val);\
2366 		grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_obj *));\
2367 	} while (0)
2368 
2369 #define GRN_BULK_POP(obj, value, type, default) do {\
2370 		if (GRN_BULK_VSIZE(obj) >= sizeof(type)) {\
2371 			GRN_BULK_INCR_LEN((obj), -(sizeof(type)));\
2372 			value = *(type *)(GRN_BULK_CURR(obj));\
2373 		} else {\
2374 			value = default;\
2375 		}\
2376 	} while (0)
2377 #define GRN_BOOL_POP(obj, value) GRN_BULK_POP(obj, value, bool, 0)
2378 #define GRN_INT8_POP(obj, value) GRN_BULK_POP(obj, value, int8_t, 0)
2379 #define GRN_UINT8_POP(obj, value) GRN_BULK_POP(obj, value, uint8_t, 0)
2380 #define GRN_INT16_POP(obj, value) GRN_BULK_POP(obj, value, int16_t, 0)
2381 #define GRN_UINT16_POP(obj, value) GRN_BULK_POP(obj, value, uint16_t, 0)
2382 #define GRN_INT32_POP(obj, value) GRN_BULK_POP(obj, value, int32_t, 0)
2383 #define GRN_UINT32_POP(obj, value) GRN_BULK_POP(obj, value, uint32_t, 0)
2384 #define GRN_INT64_POP(obj, value) GRN_BULK_POP(obj, value, int64_t, 0)
2385 #define GRN_UINT64_POP(obj, value) GRN_BULK_POP(obj, value, uint64_t, 0)
2386 #define GRN_FLOAT32_POP(obj, value) GRN_BULK_POP(obj, value, float, 0.0)
2387 #define GRN_FLOAT_POP(obj, value) GRN_BULK_POP(obj, value, double, 0.0)
2388 #define GRN_TIME_POP GRN_INT64_POP
2389 #define GRN_RECORD_POP(obj, value) GRN_BULK_POP(obj, value, grn_id, GRN_ID_NIL)
2390 #define GRN_PTR_POP(obj, value) GRN_BULK_POP(obj, value, grn_obj *, NULL)
2391 
2392 #define GRN_BULK_VECTOR_SIZE(obj, type) (GRN_BULK_VSIZE(obj) / sizeof(type))
2393 #define GRN_BOOL_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, bool)
2394 #define GRN_INT8_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int8_t)
2395 #define GRN_UINT8_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint8_t)
2396 #define GRN_INT16_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int16_t)
2397 #define GRN_UINT16_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint16_t)
2398 #define GRN_INT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int32_t)
2399 #define GRN_UINT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint32_t)
2400 #define GRN_INT64_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int64_t)
2401 #define GRN_UINT64_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint64_t)
2402 #define GRN_FLOAT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, float)
2403 #define GRN_FLOAT_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, double)
2404 #define GRN_TIME_VECTOR_SIZE GRN_INT64_VECTOR_SIZE
2405 #define GRN_RECORD_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, grn_id)
2406 #define GRN_PTR_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, grn_obj *)
2407 +/
2408 
2409 //GRN_API
2410 .grn_rc grn_ctx_push(.grn_ctx* ctx, .grn_obj* obj);
2411 
2412 //GRN_API
2413 .grn_obj* grn_ctx_pop(.grn_ctx* ctx);
2414 
2415 //GRN_API
2416 int grn_obj_columns(.grn_ctx* ctx, .grn_obj* table, const (char)* str, uint str_size, .grn_obj* res);
2417 
2418 //GRN_API
2419 .grn_rc grn_load(.grn_ctx* ctx, .grn_content_type input_type, const (char)* table, uint table_len, const (char)* columns, uint columns_len, const (char)* values, uint values_len, const (char)* ifexists, uint ifexists_len, const (char)* each, uint each_len);
2420 
2421 enum GRN_CTX_MORE = 0x01 << 0;
2422 enum GRN_CTX_TAIL = 0x01 << 1;
2423 enum GRN_CTX_HEAD = 0x01 << 2;
2424 enum GRN_CTX_QUIET = 0x01 << 3;
2425 enum GRN_CTX_QUIT = 0x01 << 4;
2426 
2427 //GRN_API
2428 .grn_rc grn_ctx_connect(.grn_ctx* ctx, const (char)* host, int port, int flags);
2429 
2430 //GRN_API
2431 uint grn_ctx_send(.grn_ctx* ctx, const (char)* str, uint str_len, int flags);
2432 
2433 //GRN_API
2434 uint grn_ctx_recv(.grn_ctx* ctx, char** str, uint* str_len, int* flags);
2435 
2436 struct _grn_ctx_info
2437 {
2438 	int fd;
2439 	uint com_status;
2440 	.grn_obj* outbuf;
2441 	ubyte stat;
2442 }
2443 
2444 alias grn_ctx_info = ._grn_ctx_info;
2445 
2446 //GRN_API
2447 .grn_rc grn_ctx_info_get(.grn_ctx* ctx, .grn_ctx_info* info);
2448 
2449 //GRN_API
2450 .grn_rc grn_set_segv_handler();
2451 
2452 //GRN_API
2453 .grn_rc grn_set_int_handler();
2454 
2455 //GRN_API
2456 .grn_rc grn_set_term_handler();
2457 
2458 struct _grn_table_delete_optarg
2459 {
2460 extern (C):
2461 	int flags;
2462 	int function(.grn_ctx* ctx, .grn_obj*, .grn_id, void*) func;
2463 	void* func_arg;
2464 }
2465 
2466 alias grn_table_delete_optarg = ._grn_table_delete_optarg;
2467 
2468 struct _grn_table_scan_hit
2469 {
2470 	.grn_id id;
2471 	uint offset;
2472 	uint length;
2473 }
2474 
2475 struct grn_timeval
2476 {
2477 	long tv_sec;
2478 	int tv_nsec;
2479 }