rroonga 4.0.3-x86-mingw32 → 4.0.4-x86-mingw32

data/vendor/local/include/groonga/groonga/plugin.h

@@ -51,34 +51,13 @@ GRN_API void *grn_plugin_realloc(grn_ctx *ctx, void *ptr, size_t size,
 GRN_API void grn_plugin_free(grn_ctx *ctx, void *ptr, const char *file,
                              int line, const char *func);
 
-/*
-  GRN_PLUGIN_MALLOC() allocates `size' bytes and returns a pointer to the
-  allocated memory space. Note that the memory space is associated with `ctx'.
- */
 #define GRN_PLUGIN_MALLOC(ctx, size) \
   grn_plugin_malloc((ctx), (size), __FILE__, __LINE__, __FUNCTION__)
-/*
-  GRN_PLUGIN_REALLOC() resizes the memory space pointed to by `ptr' or
-  allocates a new memory space of `size' bytes. GRN_PLUGIN_REALLOC() returns
-  a pointer to the memory space. The contents is unchanged or copied from the
-  old memory space to the new memory space.
- */
 #define GRN_PLUGIN_REALLOC(ctx, ptr, size) \
   grn_plugin_realloc((ctx), (ptr), (size), __FILE__, __LINE__, __FUNCTION__)
-/*
-  GRN_PLUGIN_FREE() frees a memory space allocated by GRN_PLUGIN_MALLOC() or
-  GRN_PLUGIN_REALLOC(). This means that `ptr' must be a pointer returned by
-  GRN_PLUGIN_MALLOC() or GRN_PLUGIN_REALLOC().
- */
 #define GRN_PLUGIN_FREE(ctx, ptr) \
   grn_plugin_free((ctx), (ptr), __FILE__, __LINE__, __FUNCTION__)
 
-/*
-  GRN_PLUGIN_LOG() reports a log of `level'. Its error message is generated
-  from the varying number of arguments, in which the first one is the format
-  string and the rest are its arguments. See grn_log_level in "groonga.h" for
-  more details of `level'.
- */
 #define GRN_PLUGIN_LOG(ctx, level, ...) \
   GRN_LOG((ctx), (level), __VA_ARGS__)
 
@@ -110,27 +89,11 @@ GRN_API void grn_plugin_logtrace(grn_ctx *ctx, grn_log_level level);
   grn_plugin_logtrace(ctx, level); \
 } while (0)
 
-/*
-  GRN_PLUGIN_ERROR() reports an error of `error_code'. Its error message is
-  generated from the varying number of arguments, in which the first one is the
-  format string and the rest are its arguments. See grn_rc in "groonga.h" for
-  more details of `error_code'.
- */
 #define GRN_PLUGIN_ERROR(ctx, error_code, ...) \
   GRN_PLUGIN_SET_ERROR(ctx, GRN_LOG_ERROR, error_code, __VA_ARGS__)
 
-/*
-  grn_plugin_mutex is available to make a critical section. See the
-  following functions.
- */
 typedef struct _grn_plugin_mutex grn_plugin_mutex;
 
-/*
-  grn_plugin_mutex_open() returns a pointer to a new object of
-  grn_plugin_mutex. Memory for the new object is obtained with
-  GRN_PLUGIN_MALLOC(). grn_plugin_mutex_open() returns NULL if sufficient
-  memory is not available.
- */
 GRN_API grn_plugin_mutex *grn_plugin_mutex_open(grn_ctx *ctx);
 
 /*
@@ -139,10 +102,6 @@ GRN_API grn_plugin_mutex *grn_plugin_mutex_open(grn_ctx *ctx);
 */
 GRN_API grn_plugin_mutex *grn_plugin_mutex_create(grn_ctx *ctx);
 
-/*
-  grn_plugin_mutex_close() finalizes an object of grn_plugin_mutex and then
-  frees memory allocated for that object.
- */
 GRN_API void grn_plugin_mutex_close(grn_ctx *ctx, grn_plugin_mutex *mutex);
 
 /*
@@ -151,70 +110,39 @@ GRN_API void grn_plugin_mutex_close(grn_ctx *ctx, grn_plugin_mutex *mutex);
 */
 GRN_API void grn_plugin_mutex_destroy(grn_ctx *ctx, grn_plugin_mutex *mutex);
 
-/*
-  grn_plugin_mutex_lock() locks a mutex object. If the object is already
-  locked, the calling thread waits until the object will be unlocked.
- */
 GRN_API void grn_plugin_mutex_lock(grn_ctx *ctx, grn_plugin_mutex *mutex);
 
-/*
-  grn_plugin_mutex_unlock() unlocks a mutex object. grn_plugin_mutex_unlock()
-  should not be called for an unlocked object.
- */
 GRN_API void grn_plugin_mutex_unlock(grn_ctx *ctx, grn_plugin_mutex *mutex);
 
-/*
-  grn_plugin_proc_alloc() allocates a `grn_obj` object.
-  You can use it in function that is registered as GRN_PROC_FUNCTION.
- */
 GRN_API grn_obj *grn_plugin_proc_alloc(grn_ctx *ctx, grn_user_data *user_data,
                                        grn_id domain, grn_obj_flags flags);
 
-/*
-  grn_plugin_proc_get_var() gets a variable from user_data by name.
-
-  If `name_size` is negative, `name` must be
-  NUL-terminated. `name_size` is computed by `strlen(name)` for the case.
-*/
-
 GRN_API grn_obj *grn_plugin_proc_get_var(grn_ctx *ctx, grn_user_data *user_data,
                                          const char *name, int name_size);
 
-/*
-  grn_plugin_proc_get_var_by_offset() gets a variable from user_data by offset.
-*/
-
 GRN_API grn_obj *grn_plugin_proc_get_var_by_offset(grn_ctx *ctx,
                                                    grn_user_data *user_data,
                                                    unsigned int offset);
 
-/*
-  grn_plugin_win32_base_dir() returns the groonga install directory.
-  The install directory is computed from the directory that has
-  `groonga.dll`. You can use the directory to generate install
-  directory aware path.
-
-  It only works on Windows. It returns `NULL` on other platforms.
- */
 GRN_API const char *grn_plugin_win32_base_dir(void);
 
-/*
-  grn_plugin_charlen() returns the length (#bytes) of the first character
-  in the string specified by `str_ptr' and `str_length'. If the starting bytes
-  are invalid as a character, grn_plugin_charlen() returns 0. See
-  grn_encoding in "groonga.h" for more details of `encoding'
- */
 GRN_API int grn_plugin_charlen(grn_ctx *ctx, const char *str_ptr,
                                unsigned int str_length, grn_encoding encoding);
 
-/*
-  grn_plugin_isspace() returns the length (#bytes) of the first character
-  in the string specified by `str_ptr' and `str_length' if it is a space
-  character. Otherwise, grn_plugin_isspace() returns 0.
- */
 GRN_API int grn_plugin_isspace(grn_ctx *ctx, const char *str_ptr,
                                unsigned int str_length, grn_encoding encoding);
 
+GRN_API grn_rc grn_plugin_expr_var_init(grn_ctx *ctx,
+                                        grn_expr_var *var,
+                                        const char *name,
+                                        int name_size);
+
+GRN_API grn_obj * grn_plugin_command_create(grn_ctx *ctx,
+                                            const char *name,
+                                            int name_size,
+                                            grn_proc_func func,
+                                            unsigned int n_vars,
+                                            grn_expr_var *vars);
 
 
 #ifdef __cplusplus

data/vendor/local/include/groonga/groonga/tokenizer.h

@@ -84,6 +84,7 @@ struct _grn_tokenizer_query {
   grn_encoding encoding;
   unsigned int flags;
   grn_bool have_tokenized_delimiter;
+  unsigned int token_mode;
 };
 
 /*
@@ -152,15 +153,19 @@ GRN_PLUGIN_EXPORT void grn_tokenizer_token_fin(grn_ctx *ctx, grn_tokenizer_token
 typedef unsigned int grn_tokenizer_status;
 
 /* GRN_TOKENIZER_TOKEN_CONTINUE means that the next token is not the last one. */
-#define GRN_TOKENIZER_TOKEN_CONTINUE  (0)
+#define GRN_TOKENIZER_TOKEN_CONTINUE           (0)
 /* GRN_TOKENIZER_TOKEN_LAST means that the next token is the last one. */
-#define GRN_TOKENIZER_TOKEN_LAST      (0x01L<<0)
+#define GRN_TOKENIZER_TOKEN_LAST               (0x01L<<0)
 /* GRN_TOKENIZER_TOKEN_OVERLAP means that ... */
-#define GRN_TOKENIZER_TOKEN_OVERLAP   (0x01L<<1)
+#define GRN_TOKENIZER_TOKEN_OVERLAP            (0x01L<<1)
 /* GRN_TOKENIZER_TOKEN_UNMATURED means that ... */
-#define GRN_TOKENIZER_TOKEN_UNMATURED (0x01L<<2)
+#define GRN_TOKENIZER_TOKEN_UNMATURED          (0x01L<<2)
 /* GRN_TOKENIZER_TOKEN_REACH_END means that ... */
-#define GRN_TOKENIZER_TOKEN_REACH_END (0x01L<<3)
+#define GRN_TOKENIZER_TOKEN_REACH_END          (0x01L<<3)
+/* GRN_TOKENIZER_TOKEN_SKIP means that the token is skipped */
+#define GRN_TOKENIZER_TOKEN_SKIP               (0x01L<<4)
+/* GRN_TOKENIZER_TOKEN_SKIP_WITH_POSITION means that the token and postion is skipped */
+#define GRN_TOKENIZER_TOKEN_SKIP_WITH_POSITION (0x01L<<5)
 
 /*
  * GRN_TOKENIZER_CONTINUE and GRN_TOKENIZER_LAST are deprecated. They

data/vendor/local/include/msgpack.h

@@ -20,6 +20,7 @@
  * @{
  * @}
  */
+
 #include "msgpack/object.h"
 #include "msgpack/zone.h"
 #include "msgpack/pack.h"

data/vendor/local/include/msgpack/fbuffer.h

@@ -0,0 +1,47 @@
+/*
+ * MessagePack for C FILE* buffer adaptor
+ *
+ * Copyright (C) 2013 Vladimir Volodko
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#ifndef MSGPACK_FBUFFER_H__
+#define MSGPACK_FBUFFER_H__
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup msgpack_fbuffer FILE* buffer
+ * @ingroup msgpack_buffer
+ * @{
+ */
+
+static inline int msgpack_fbuffer_write(void* data, const char* buf, unsigned int len)
+{
+	return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1;
+}
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/fbuffer.h */
+

data/vendor/local/include/msgpack/fbuffer.hpp

@@ -0,0 +1,56 @@
+//
+// MessagePack for C++ FILE* buffer adaptor
+//
+// Copyright (C) 2013 Vladimir Volodko
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_FBUFFER_HPP__
+#define MSGPACK_FBUFFER_HPP__
+
+#include <cstdio>
+#include <stdexcept>
+
+namespace msgpack {
+
+
+class fbuffer {
+public:
+	explicit fbuffer(FILE* file) : m_file(file) { }
+
+public:
+	void write(const char* buf, unsigned int len)
+	{
+		if (1 != fwrite(buf, len, 1, m_file)) {
+			throw std::runtime_error("fwrite() failed");
+		}
+	}
+
+	FILE* file() const
+	{
+		return m_file;
+	}
+
+private:
+	fbuffer(const fbuffer&);
+	fbuffer& operator= (const fbuffer&);
+
+private:
+	FILE* m_file;
+};
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/fbuffer.hpp */
+

data/vendor/local/include/msgpack/object.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// Copyright (C) 2008-2010 FURUHASHI Sadayuki
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -212,11 +212,20 @@ inline T& operator>> (object o, T& v)
 	return v;
 }
 
+namespace detail {
+template <typename Stream, typename T>
+struct packer_serializer {
+	static packer<Stream>& pack(packer<Stream>& o, const T& v) {
+		v.msgpack_pack(o);
+		return o;
+	}
+};
+}
+
 template <typename Stream, typename T>
 inline packer<Stream>& operator<< (packer<Stream>& o, const T& v)
 {
-	v.msgpack_pack(o);
-	return o;
+	return detail::packer_serializer<Stream, T>::pack(o, v);
 }
 
 template <typename T>

data/vendor/local/include/msgpack/pack.h

@@ -40,7 +40,7 @@ extern "C" {
  * @{
  */
 
-typedef int (*msgpack_packer_write)(void* data, const char* buf, unsigned int len);
+typedef int (*msgpack_packer_write)(void* data, const char* buf, size_t len);
 
 typedef struct msgpack_packer {
 	void* data;
@@ -52,10 +52,14 @@ static void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_w
 static msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback);
 static void msgpack_packer_free(msgpack_packer* pk);
 
+static int msgpack_pack_char(msgpack_packer* pk, char d);
+
+static int msgpack_pack_signed_char(msgpack_packer* pk, signed char d);
 static int msgpack_pack_short(msgpack_packer* pk, short d);
 static int msgpack_pack_int(msgpack_packer* pk, int d);
 static int msgpack_pack_long(msgpack_packer* pk, long d);
 static int msgpack_pack_long_long(msgpack_packer* pk, long long d);
+static int msgpack_pack_unsigned_char(msgpack_packer* pk, unsigned char d);
 static int msgpack_pack_unsigned_short(msgpack_packer* pk, unsigned short d);
 static int msgpack_pack_unsigned_int(msgpack_packer* pk, unsigned int d);
 static int msgpack_pack_unsigned_long(msgpack_packer* pk, unsigned long d);
@@ -86,9 +90,9 @@ static int msgpack_pack_nil(msgpack_packer* pk);
 static int msgpack_pack_true(msgpack_packer* pk);
 static int msgpack_pack_false(msgpack_packer* pk);
 
-static int msgpack_pack_array(msgpack_packer* pk, unsigned int n);
+static int msgpack_pack_array(msgpack_packer* pk, size_t n);
 
-static int msgpack_pack_map(msgpack_packer* pk, unsigned int n);
+static int msgpack_pack_map(msgpack_packer* pk, size_t n);
 
 static int msgpack_pack_raw(msgpack_packer* pk, size_t l);
 static int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l);

data/vendor/local/include/msgpack/pack.hpp

@@ -54,10 +54,13 @@ public:
 	packer<Stream>& pack_fix_int32(int32_t d);
 	packer<Stream>& pack_fix_int64(int64_t d);
 
+	packer<Stream>& pack_char(char d);
+	packer<Stream>& pack_signed_char(signed char d);
 	packer<Stream>& pack_short(short d);
 	packer<Stream>& pack_int(int d);
 	packer<Stream>& pack_long(long d);
 	packer<Stream>& pack_long_long(long long d);
+	packer<Stream>& pack_unsigned_char(unsigned char d);
 	packer<Stream>& pack_unsigned_short(unsigned short d);
 	packer<Stream>& pack_unsigned_int(unsigned int d);
 	packer<Stream>& pack_unsigned_long(unsigned long d);
@@ -70,9 +73,9 @@ public:
 	packer<Stream>& pack_true();
 	packer<Stream>& pack_false();
 
-	packer<Stream>& pack_array(unsigned int n);
+	packer<Stream>& pack_array(size_t n);
 
-	packer<Stream>& pack_map(unsigned int n);
+	packer<Stream>& pack_map(size_t n);
 
 	packer<Stream>& pack_raw(size_t l);
 	packer<Stream>& pack_raw_body(const char* b, size_t l);
@@ -96,10 +99,14 @@ private:
 	static void _pack_fix_int32(Stream& x, int32_t d);
 	static void _pack_fix_int64(Stream& x, int64_t d);
 
+	static void _pack_char(Stream& x, char d);
+
+	static void _pack_signed_char(Stream& x, signed char d);
 	static void _pack_short(Stream& x, short d);
 	static void _pack_int(Stream& x, int d);
 	static void _pack_long(Stream& x, long d);
 	static void _pack_long_long(Stream& x, long long d);
+	static void _pack_unsigned_char(Stream& x, unsigned char d);
 	static void _pack_unsigned_short(Stream& x, unsigned short d);
 	static void _pack_unsigned_int(Stream& x, unsigned int d);
 	static void _pack_unsigned_long(Stream& x, unsigned long d);
@@ -112,14 +119,14 @@ private:
 	static void _pack_true(Stream& x);
 	static void _pack_false(Stream& x);
 
-	static void _pack_array(Stream& x, unsigned int n);
+	static void _pack_array(Stream& x, size_t n);
 
-	static void _pack_map(Stream& x, unsigned int n);
+	static void _pack_map(Stream& x, size_t n);
 
 	static void _pack_raw(Stream& x, size_t l);
 	static void _pack_raw_body(Stream& x, const void* b, size_t l);
 
-	static void append_buffer(Stream& x, const unsigned char* buf, unsigned int len)
+	static void append_buffer(Stream& x, const unsigned char* buf, size_t len)
 		{ x.write((const char*)buf, len); }
 
 private:
@@ -238,6 +245,14 @@ inline packer<Stream>& packer<Stream>::pack_fix_int64(int64_t d)
 { _pack_fix_int64(m_stream, d); return *this;}
 
 
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_char(char d)
+{ _pack_char(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_signed_char(signed char d)
+{ _pack_signed_char(m_stream, d); return *this; }
+
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_short(short d)
 { _pack_short(m_stream, d); return *this; }
@@ -254,6 +269,10 @@ template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_long_long(long long d)
 { _pack_long_long(m_stream, d); return *this; }
 
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_char(unsigned char d)
+{ _pack_unsigned_char(m_stream, d); return *this; }
+
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_unsigned_short(unsigned short d)
 { _pack_unsigned_short(m_stream, d); return *this; }
@@ -294,12 +313,12 @@ inline packer<Stream>& packer<Stream>::pack_false()
 
 
 template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_array(unsigned int n)
+inline packer<Stream>& packer<Stream>::pack_array(size_t n)
 { _pack_array(m_stream, n); return *this; }
 
 
 template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_map(unsigned int n)
+inline packer<Stream>& packer<Stream>::pack_map(size_t n)
 { _pack_map(m_stream, n); return *this; }