rroonga 10.0.6 → 11.0.0

data/ext/groonga/rb-grn-double-array-trie.c

@@ -1,8 +1,8 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* vim: set sts=4 sw=4 ts=8 noet: */
 /*
+  Copyright (C) 2011-2021  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2014  Masafumi Yokoyama <myokoym@gmail.com>
-  Copyright (C) 2011-2014  Kouhei Sutou <kou@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -20,7 +20,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) ((RbGrnDoubleArrayTrie *)DATA_PTR(object))
+#define SELF(object) ((RbGrnDoubleArrayTrie *)RTYPEDDATA_DATA(object))
 
 VALUE rb_cGrnDoubleArrayTrie;
 

data/ext/groonga/rb-grn-encoding-support.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -18,7 +18,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) (RB_GRN_OBJECT(DATA_PTR(object)))
+#define SELF(object) (RB_GRN_OBJECT(RTYPEDDATA_DATA(object)))
 
 VALUE rb_mGrnEncodingSupport;
 

data/ext/groonga/rb-grn-exception.c

@@ -103,6 +103,7 @@ static VALUE eGrnScorerError;
 static VALUE eGrnCancel;
 static VALUE eGrnWindowFunctionError;
 static VALUE eGrnZstdError;
+static VALUE eGrnConnectionReset;
 
 VALUE
 rb_grn_rc_to_exception (grn_rc rc)
@@ -353,6 +354,9 @@ rb_grn_rc_to_exception (grn_rc rc)
       case GRN_ZSTD_ERROR:
         exception = eGrnZstdError;
         break;
+      case GRN_CONNECTION_RESET:
+        exception = eGrnConnectionReset;
+        break;
     }
 
     if (NIL_P(exception))
@@ -1072,4 +1076,14 @@ rb_grn_init_exception (VALUE mGrn)
      */
     eGrnZstdError =
         rb_define_class_under(mGrn, "ZstdError", rb_eGrnError);
+
+    /*
+     * Document-class: Groonga::ConnectionReset
+     *
+     * It is used when connection is reset.
+     *
+     * @since 10.1.1
+     */
+    eGrnConnectionReset =
+        rb_define_class_under(mGrn, "ConnectionReset", rb_eGrnError);
 }

data/ext/groonga/rb-grn-expression.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2018  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2014  Masafumi Yokoyama <myokoym@gmail.com>
 
   This library is free software; you can redistribute it and/or
@@ -19,7 +19,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) ((RbGrnExpression *)DATA_PTR(object))
+#define SELF(object) ((RbGrnExpression *)RTYPEDDATA_DATA(object))
 
 VALUE rb_cGrnExpression;
 
@@ -100,7 +100,7 @@ rb_grn_expression_initialize (int argc, VALUE *argv, VALUE self)
     expression = grn_expr_create(context, name, name_size);
     rb_grn_context_check(context, self);
     rb_grn_object_assign(Qnil, self, rb_context, context, expression);
-    rb_grn_context_register_floating_object(DATA_PTR(self));
+    rb_grn_context_register_floating_object(RTYPEDDATA_DATA(self));
 
     rb_iv_set(self, "@objects", rb_ary_new());
 

data/ext/groonga/rb-grn-fix-size-column.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -19,7 +19,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) ((RbGrnColumn *)DATA_PTR(object))
+#define SELF(object) ((RbGrnColumn *)RTYPEDDATA_DATA(object))
 
 VALUE rb_cGrnFixSizeColumn;
 

data/ext/groonga/rb-grn-flushable.c

@@ -1,6 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2015  Masafumi Yokoyama <yokoyama@clear-code.com>
+  Copyright (C) 2021  Sutou Kouhei <kou@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -18,7 +19,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) (RB_GRN_OBJECT(DATA_PTR(object)))
+#define SELF(object) (RB_GRN_OBJECT(RTYPEDDATA_DATA(object)))
 
 VALUE rb_mGrnFlushable;
 

data/ext/groonga/rb-grn-hash.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -18,7 +18,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) ((RbGrnTableKeySupport *)DATA_PTR(object))
+#define SELF(object) ((RbGrnTableKeySupport *)RTYPEDDATA_DATA(object))
 
 VALUE rb_cGrnHash;
 

data/ext/groonga/rb-grn-index-column.c

@@ -1,8 +1,8 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2019  Horimoto Yasuhiro <horimoto@clear-code.com>
-  Copyright (C) 2009-2017  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
+  Copyright (C) 2019  Horimoto Yasuhiro <horimoto@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -22,7 +22,7 @@
 
 #include <string.h>
 
-#define SELF(object) ((RbGrnIndexColumn *)DATA_PTR(object))
+#define SELF(object) ((RbGrnIndexColumn *)RTYPEDDATA_DATA(object))
 
 VALUE rb_cGrnIndexColumn;
 

data/ext/groonga/rb-grn-index-cursor.c

@@ -1,7 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2011  Haruka Yoshihara <yoshihara@clear-code.com>
-  Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2012-2021  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2019  Horimoto Yasuhiro <horimoto@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -20,7 +20,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) ((RbGrnIndexCursor *)DATA_PTR(object))
+#define SELF(object) ((RbGrnIndexCursor *)RTYPEDDATA_DATA(object))
 
 VALUE rb_cGrnIndexCursor;
 

data/ext/groonga/rb-grn-inverted-index-cursor.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2017  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2017-2021  Sutou Kouhei <kou@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -18,7 +18,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) ((RbGrnInvertedIndexCursor *)DATA_PTR(object))
+#define SELF(object) ((RbGrnInvertedIndexCursor *)RTYPEDDATA_DATA(object))
 
 typedef struct _RbGrnInvertedIndexCursor RbGrnInvertedIndexCursor;
 struct _RbGrnInvertedIndexCursor
@@ -255,7 +255,7 @@ void
 rb_grn_init_inverted_index_cursor (VALUE mGrn)
 {
     rb_cGrnInvertedIndexCursor =
-      rb_define_class_under(mGrn, "InvertedIndexCursor", rb_cData);
+      rb_define_class_under(mGrn, "InvertedIndexCursor", rb_cObject);
     rb_include_module(rb_cGrnInvertedIndexCursor, rb_mEnumerable);
 
     rb_define_method(rb_cGrnInvertedIndexCursor, "next",

data/ext/groonga/rb-grn-object.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2018  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2014-2016  Masafumi Yokoyama <yokoyama@clear-code.com>
   Copyright (C) 2019  Horimoto Yasuhiro <horimoto@clear-code.com>
 
@@ -28,10 +28,28 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) ((RbGrnObject *)DATA_PTR(object))
+#define SELF(object) ((RbGrnObject *)RTYPEDDATA_DATA(object))
 
 VALUE rb_cGrnObject;
 
+static void
+rb_grn_object_dfree (void *pointer)
+{
+    rb_grn_object_free(pointer);
+}
+
+rb_data_type_t rb_grn_object_data_type = {
+    "Groonga::Object",
+    {
+        NULL,
+        rb_grn_object_dfree,
+        NULL,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 grn_obj *
 rb_grn_object_from_ruby_object (VALUE object, grn_ctx **context)
 {
@@ -73,7 +91,10 @@ rb_grn_object_from_ruby_object (VALUE object, grn_ctx **context)
                  rb_grn_inspect(object));
     }
 
-    Data_Get_Struct(object, RbGrnObject, rb_grn_object);
+    TypedData_Get_Struct(object,
+                         RbGrnObject,
+                         &rb_grn_object_data_type,
+                         rb_grn_object);
     if (!rb_grn_object)
         rb_raise(rb_eGrnError, "Groonga object is NULL");
 
@@ -350,7 +371,9 @@ rb_grn_object_to_ruby_object (VALUE klass, grn_ctx *context, grn_obj *object,
 VALUE
 rb_grn_object_alloc (VALUE klass)
 {
-    return Data_Wrap_Struct(klass, NULL, rb_grn_object_free, NULL);
+    return TypedData_Wrap_Struct(klass,
+                                 &rb_grn_object_data_type,
+                                 NULL);
 }
 
 static void
@@ -359,15 +382,13 @@ rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
                            grn_ctx *context, grn_obj *object)
 {
     grn_user_data *user_data;
-    RbGrnContext *rb_grn_context;
 
     debug("bind: %p:%p:%p %s(%#x)\n",
           context, object, rb_grn_object,
           grn_obj_type_to_string(object->header.type),
           object->header.type);
 
-    Data_Get_Struct(rb_context, RbGrnContext, rb_grn_context);
-    rb_grn_object->rb_grn_context = rb_grn_context;
+    rb_grn_object->rb_grn_context = rb_grn_context_get_struct(rb_context);
     rb_grn_object->context = context;
     rb_grn_object->object = object;
     rb_grn_object->self = self;
@@ -419,7 +440,7 @@ rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
     else
         rb_grn_object->range = grn_ctx_at(context, rb_grn_object->range_id);
 
-    DATA_PTR(self) = rb_grn_object;
+    RTYPEDDATA_DATA(self) = rb_grn_object;
 }
 
 void
@@ -2213,7 +2234,7 @@ rb_grn_object_get_disk_usage (VALUE self)
 void
 rb_grn_init_object (VALUE mGrn)
 {
-    rb_cGrnObject = rb_define_class_under(mGrn, "Object", rb_cData);
+    rb_cGrnObject = rb_define_class_under(mGrn, "Object", rb_cObject);
     rb_define_alloc_func(rb_cGrnObject, rb_grn_object_alloc);
 
     rb_define_attr(rb_cGrnObject, "context", GRN_TRUE, GRN_FALSE);

data/ext/groonga/rb-grn-operator.c

@@ -325,353 +325,194 @@ rb_grn_init_operator (VALUE mGrn)
     rb_grn_init_prefix_operator(mGrn);
     rb_grn_init_regexp_operator(mGrn);
 
+#define OPERATOR_NEW(klass, name, NAME)                             \
+    rb_obj_freeze(rb_funcall(klass, rb_intern("new"), 2,            \
+                             rb_obj_freeze(rb_str_new_cstr(name)),  \
+                             UINT2NUM(GRN_OP_ ## NAME)))
+
     rb_define_const(rb_cGrnOperator, "PUSH",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("push"),
-                               UINT2NUM(GRN_OP_PUSH)));
+                    OPERATOR_NEW(rb_cGrnOperator, "push", PUSH));
     rb_define_const(rb_cGrnOperator, "POP",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("pop"),
-                               UINT2NUM(GRN_OP_POP)));
+                    OPERATOR_NEW(rb_cGrnOperator, "pop", POP));
     rb_define_const(rb_cGrnOperator, "NO_OPERATION",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("no-operation"),
-                               UINT2NUM(GRN_OP_NOP)));
+                    OPERATOR_NEW(rb_cGrnOperator, "no-operation", NOP));
     rb_define_const(rb_cGrnOperator, "CALL",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("call"),
-                               UINT2NUM(GRN_OP_CALL)));
+                    OPERATOR_NEW(rb_cGrnOperator, "call", CALL));
     rb_define_const(rb_cGrnOperator, "INTERN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("intern"),
-                               UINT2NUM(GRN_OP_INTERN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "intern", INTERN));
     rb_define_const(rb_cGrnOperator, "GET_REFERENCE",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("get-reference"),
-                               UINT2NUM(GRN_OP_GET_REF)));
+                    OPERATOR_NEW(rb_cGrnOperator, "get-reference", GET_REF));
     rb_define_const(rb_cGrnOperator, "GET_VALUE",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("get-value"),
-                               UINT2NUM(GRN_OP_GET_VALUE)));
+                    OPERATOR_NEW(rb_cGrnOperator, "get-value", GET_VALUE));
     rb_define_const(rb_cGrnOperator, "AND",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("and"),
-                               UINT2NUM(GRN_OP_AND)));
+                    OPERATOR_NEW(rb_cGrnOperator, "and", AND));
     rb_define_const(rb_cGrnOperator, "AND_NOT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("and-not"),
-                               UINT2NUM(GRN_OP_AND_NOT)));
-    /* Just for backward compatiblity. TODO: REMOVE ME! */
+                    OPERATOR_NEW(rb_cGrnOperator, "and-not", AND_NOT));
+    /* Just for backward compatibility. TODO: REMOVE ME! */
     rb_define_const(rb_cGrnOperator, "BUT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("but"),
-                               UINT2NUM(GRN_OP_BUT)));
+                    OPERATOR_NEW(rb_cGrnOperator, "but", BUT));
     rb_define_const(rb_cGrnOperator, "OR",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("or"),
-                               UINT2NUM(GRN_OP_OR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "or", OR));
     rb_define_const(rb_cGrnOperator, "ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("assign"),
-                               UINT2NUM(GRN_OP_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "assign", ASSIGN));
     rb_define_const(rb_cGrnOperator, "STAR_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("star-assign"),
-                               UINT2NUM(GRN_OP_STAR_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "star-assign", STAR_ASSIGN));
     rb_define_const(rb_cGrnOperator, "SLASH_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("slash-assign"),
-                               UINT2NUM(GRN_OP_SLASH_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "slash-assign", SLASH_ASSIGN));
     rb_define_const(rb_cGrnOperator, "MODULO_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("modulo-assign"),
-                               UINT2NUM(GRN_OP_MOD_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "modulo-assign", MOD_ASSIGN));
     rb_define_const(rb_cGrnOperator, "PLUS_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("plus-assign"),
-                               UINT2NUM(GRN_OP_PLUS_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "plus-assign", PLUS_ASSIGN));
     rb_define_const(rb_cGrnOperator, "MINUS_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("minus-assign"),
-                               UINT2NUM(GRN_OP_MINUS_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "minus-assign", MINUS_ASSIGN));
     rb_define_const(rb_cGrnOperator, "SHIFTL_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("shiftl-assign"),
-                               UINT2NUM(GRN_OP_SHIFTL_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "shiftl-assign", SHIFTL_ASSIGN));
     rb_define_const(rb_cGrnOperator, "SHIRTR_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("shirtr-assign"),
-                               UINT2NUM(GRN_OP_SHIFTR_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "shirtr-assign", SHIFTR_ASSIGN));
     rb_define_const(rb_cGrnOperator, "SHIFTRR_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("shiftrr-assign"),
-                               UINT2NUM(GRN_OP_SHIFTRR_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "shiftrr-assign", SHIFTRR_ASSIGN));
     rb_define_const(rb_cGrnOperator, "AND_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("and-assign"),
-                               UINT2NUM(GRN_OP_AND_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "and-assign", AND_ASSIGN));
     rb_define_const(rb_cGrnOperator, "XOR_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("xor-assign"),
-                               UINT2NUM(GRN_OP_XOR_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "xor-assign", XOR_ASSIGN));
     rb_define_const(rb_cGrnOperator, "OR_ASSIGN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("or-assign"),
-                               UINT2NUM(GRN_OP_OR_ASSIGN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "or-assign", OR_ASSIGN));
     rb_define_const(rb_cGrnOperator, "JUMP",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("jump"),
-                               UINT2NUM(GRN_OP_JUMP)));
+                    OPERATOR_NEW(rb_cGrnOperator, "jump", JUMP));
     rb_define_const(rb_cGrnOperator, "CJUMP",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("cjump"),
-                               UINT2NUM(GRN_OP_CJUMP)));
+                    OPERATOR_NEW(rb_cGrnOperator, "cjump", CJUMP));
     rb_define_const(rb_cGrnOperator, "COMMA",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("comma"),
-                               UINT2NUM(GRN_OP_COMMA)));
+                    OPERATOR_NEW(rb_cGrnOperator, "comma", COMMA));
     rb_define_const(rb_cGrnOperator, "BITWISE_OR",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("bitwise-or"),
-                               UINT2NUM(GRN_OP_BITWISE_OR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "bitwise-or", BITWISE_OR));
     rb_define_const(rb_cGrnOperator, "BITWISE_XOR",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("bitwise-xor"),
-                               UINT2NUM(GRN_OP_BITWISE_XOR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "bitwise-xor", BITWISE_XOR));
     rb_define_const(rb_cGrnOperator, "BITWISE_AND",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("bitwise-and"),
-                               UINT2NUM(GRN_OP_BITWISE_AND)));
+                    OPERATOR_NEW(rb_cGrnOperator, "bitwise-and", BITWISE_AND));
     rb_define_const(rb_cGrnOperator, "BITWISE_NOT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("bitwise-not"),
-                               UINT2NUM(GRN_OP_BITWISE_NOT)));
+                    OPERATOR_NEW(rb_cGrnOperator, "bitwise-not", BITWISE_NOT));
     rb_define_const(rb_cGrnOperator, "EQUAL",
-                    rb_funcall(rb_cGrnEqualOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("equal"),
-                               UINT2NUM(GRN_OP_EQUAL)));
+                    OPERATOR_NEW(rb_cGrnEqualOperator, "equal", EQUAL));
     rb_define_const(rb_cGrnOperator, "NOT_EQUAL",
-                    rb_funcall(rb_cGrnNotEqualOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("not-equal"),
-                               UINT2NUM(GRN_OP_NOT_EQUAL)));
+                    OPERATOR_NEW(rb_cGrnNotEqualOperator,
+                                 "not-equal",
+                                 NOT_EQUAL));
     rb_define_const(rb_cGrnOperator, "LESS",
-                    rb_funcall(rb_cGrnLessOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("less"),
-                               UINT2NUM(GRN_OP_LESS)));
+                    OPERATOR_NEW(rb_cGrnLessOperator, "less", LESS));
     rb_define_const(rb_cGrnOperator, "GREATER",
-                    rb_funcall(rb_cGrnGreaterOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("greater"),
-                               UINT2NUM(GRN_OP_GREATER)));
+                    OPERATOR_NEW(rb_cGrnGreaterOperator, "greater", GREATER));
     rb_define_const(rb_cGrnOperator, "LESS_EQUAL",
-                    rb_funcall(rb_cGrnLessEqualOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("less-equal"),
-                               UINT2NUM(GRN_OP_LESS_EQUAL)));
+                    OPERATOR_NEW(rb_cGrnLessEqualOperator,
+                                 "less-equal",
+                                 LESS_EQUAL));
     rb_define_const(rb_cGrnOperator, "GREATER_EQUAL",
-                    rb_funcall(rb_cGrnGreaterEqualOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("greater-equal"),
-                               UINT2NUM(GRN_OP_GREATER_EQUAL)));
+                    OPERATOR_NEW(rb_cGrnGreaterEqualOperator,
+                                 "greater-equal",
+                                 GREATER_EQUAL));
     rb_define_const(rb_cGrnOperator, "IN",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("in"),
-                               UINT2NUM(GRN_OP_IN)));
+                    OPERATOR_NEW(rb_cGrnOperator, "in", IN));
     rb_define_const(rb_cGrnOperator, "MATCH",
-                    rb_funcall(rb_cGrnMatchOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("match"),
-                               UINT2NUM(GRN_OP_MATCH)));
+                    OPERATOR_NEW(rb_cGrnMatchOperator, "match", MATCH));
     rb_define_const(rb_cGrnOperator, "NEAR",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("near"),
-                               UINT2NUM(GRN_OP_NEAR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "near", NEAR));
     rb_define_const(rb_cGrnOperator, "NEAR2",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("near2"),
-                               UINT2NUM(GRN_OP_NEAR2)));
+                    OPERATOR_NEW(rb_cGrnOperator, "near2", NEAR2));
     rb_define_const(rb_cGrnOperator, "SIMILAR",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("similar"),
-                               UINT2NUM(GRN_OP_SIMILAR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "similar", SIMILAR));
     rb_define_const(rb_cGrnOperator, "TERM_EXTRACT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("term-extract"),
-                               UINT2NUM(GRN_OP_TERM_EXTRACT)));
+                    OPERATOR_NEW(rb_cGrnOperator, "term-extract", TERM_EXTRACT));
     rb_define_const(rb_cGrnOperator, "SHIFTL",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("shiftl"),
-                               UINT2NUM(GRN_OP_SHIFTL)));
+                    OPERATOR_NEW(rb_cGrnOperator, "shiftl", SHIFTL));
     rb_define_const(rb_cGrnOperator, "SHIFTR",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("shiftr"),
-                               UINT2NUM(GRN_OP_SHIFTR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "shiftr", SHIFTR));
     rb_define_const(rb_cGrnOperator, "SHIFTRR",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("shiftrr"),
-                               UINT2NUM(GRN_OP_SHIFTRR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "shiftrr", SHIFTRR));
     rb_define_const(rb_cGrnOperator, "PLUS",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("plus"),
-                               UINT2NUM(GRN_OP_PLUS)));
+                    OPERATOR_NEW(rb_cGrnOperator, "plus", PLUS));
     rb_define_const(rb_cGrnOperator, "MINUS",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("minus"),
-                               UINT2NUM(GRN_OP_MINUS)));
+                    OPERATOR_NEW(rb_cGrnOperator, "minus", MINUS));
     rb_define_const(rb_cGrnOperator, "STAR",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("star"),
-                               UINT2NUM(GRN_OP_STAR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "star", STAR));
     rb_define_const(rb_cGrnOperator, "SLASH",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("slash"),
-                               UINT2NUM(GRN_OP_SLASH)));
+                    OPERATOR_NEW(rb_cGrnOperator, "slash", SLASH));
     rb_define_const(rb_cGrnOperator, "MODULO",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("modulo"),
-                               UINT2NUM(GRN_OP_MOD)));
+                    OPERATOR_NEW(rb_cGrnOperator, "modulo", MOD));
     rb_define_const(rb_cGrnOperator, "DELETE",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("delete"),
-                               UINT2NUM(GRN_OP_DELETE)));
+                    OPERATOR_NEW(rb_cGrnOperator, "delete", DELETE));
     rb_define_const(rb_cGrnOperator, "INCREMENT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("increment"),
-                               UINT2NUM(GRN_OP_INCR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "increment", INCR));
     rb_define_const(rb_cGrnOperator, "DECREMENT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("decrement"),
-                               UINT2NUM(GRN_OP_DECR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "decrement", DECR));
     rb_define_const(rb_cGrnOperator, "INCREMENT_POST",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("increment-post"),
-                               UINT2NUM(GRN_OP_INCR_POST)));
+                    OPERATOR_NEW(rb_cGrnOperator, "increment-post", INCR_POST));
     rb_define_const(rb_cGrnOperator, "DECREMENT_POST",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("decrement-post"),
-                               UINT2NUM(GRN_OP_DECR_POST)));
+                    OPERATOR_NEW(rb_cGrnOperator, "decrement-post", DECR_POST));
     rb_define_const(rb_cGrnOperator, "NOT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("not"),
-                               UINT2NUM(GRN_OP_NOT)));
+                    OPERATOR_NEW(rb_cGrnOperator, "not", NOT));
     rb_define_const(rb_cGrnOperator, "ADJUST",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("adjust"),
-                               UINT2NUM(GRN_OP_ADJUST)));
+                    OPERATOR_NEW(rb_cGrnOperator, "adjust", ADJUST));
     rb_define_const(rb_cGrnOperator, "EXACT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("exact"),
-                               UINT2NUM(GRN_OP_EXACT)));
+                    OPERATOR_NEW(rb_cGrnOperator, "exact", EXACT));
     rb_define_const(rb_cGrnOperator, "LONGEST_COMMON_PREFIX",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("longest-common-prefix"),
-                               UINT2NUM(GRN_OP_LCP)));
+                    OPERATOR_NEW(rb_cGrnOperator, "longest-common-prefix", LCP));
     rb_define_const(rb_cGrnOperator, "PARTIAL",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("partial"),
-                               UINT2NUM(GRN_OP_PARTIAL)));
+                    OPERATOR_NEW(rb_cGrnOperator, "partial", PARTIAL));
     rb_define_const(rb_cGrnOperator, "UNSPLIT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("unsplit"),
-                               UINT2NUM(GRN_OP_UNSPLIT)));
+                    OPERATOR_NEW(rb_cGrnOperator, "unsplit", UNSPLIT));
     rb_define_const(rb_cGrnOperator, "PREFIX",
-                    rb_funcall(rb_cGrnPrefixOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("prefix"),
-                               UINT2NUM(GRN_OP_PREFIX)));
+                    OPERATOR_NEW(rb_cGrnPrefixOperator, "prefix", PREFIX));
     rb_define_const(rb_cGrnOperator, "SUFFIX",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("suffix"),
-                               UINT2NUM(GRN_OP_SUFFIX)));
+                    OPERATOR_NEW(rb_cGrnOperator, "suffix", SUFFIX));
     rb_define_const(rb_cGrnOperator, "GEO_DISTANCE1",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-distance1"),
-                               UINT2NUM(GRN_OP_GEO_DISTANCE1)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-distance1", GEO_DISTANCE1));
     rb_define_const(rb_cGrnOperator, "GEO_DISTANCE2",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-distance2"),
-                               UINT2NUM(GRN_OP_GEO_DISTANCE2)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-distance2", GEO_DISTANCE2));
     rb_define_const(rb_cGrnOperator, "GEO_DISTANCE3",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-distance3"),
-                               UINT2NUM(GRN_OP_GEO_DISTANCE3)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-distance3", GEO_DISTANCE3));
     rb_define_const(rb_cGrnOperator, "GEO_DISTANCE4",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-distance4"),
-                               UINT2NUM(GRN_OP_GEO_DISTANCE4)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-distance4", GEO_DISTANCE4));
     rb_define_const(rb_cGrnOperator, "GEO_WITHINP5",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-withinp5"),
-                               UINT2NUM(GRN_OP_GEO_WITHINP5)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-withinp5", GEO_WITHINP5));
     rb_define_const(rb_cGrnOperator, "GEO_WITHINP6",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-withinp6"),
-                               UINT2NUM(GRN_OP_GEO_WITHINP6)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-withinp6", GEO_WITHINP6));
     rb_define_const(rb_cGrnOperator, "GEO_WITHINP8",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-withinp8"),
-                               UINT2NUM(GRN_OP_GEO_WITHINP8)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-withinp8", GEO_WITHINP8));
     rb_define_const(rb_cGrnOperator, "OBJECT_SEARCH",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("object-search"),
-                               UINT2NUM(GRN_OP_OBJ_SEARCH)));
+                    OPERATOR_NEW(rb_cGrnOperator, "object-search", OBJ_SEARCH));
     rb_define_const(rb_cGrnOperator, "EXPRESSION_GET_VARIABLE",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("expression-get-variable"),
-                               UINT2NUM(GRN_OP_EXPR_GET_VAR)));
+                    OPERATOR_NEW(rb_cGrnOperator, "expression-get-variable", EXPR_GET_VAR));
     rb_define_const(rb_cGrnOperator, "TABLE_CREATE",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("table-create"),
-                               UINT2NUM(GRN_OP_TABLE_CREATE)));
+                    OPERATOR_NEW(rb_cGrnOperator, "table-create", TABLE_CREATE));
     rb_define_const(rb_cGrnOperator, "TABLE_SELECT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("table-select"),
-                               UINT2NUM(GRN_OP_TABLE_SELECT)));
+                    OPERATOR_NEW(rb_cGrnOperator, "table-select", TABLE_SELECT));
     rb_define_const(rb_cGrnOperator, "TABLE_SORT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("table-sort"),
-                               UINT2NUM(GRN_OP_TABLE_SORT)));
+                    OPERATOR_NEW(rb_cGrnOperator, "table-sort", TABLE_SORT));
     rb_define_const(rb_cGrnOperator, "TABLE_GROUP",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("table-group"),
-                               UINT2NUM(GRN_OP_TABLE_GROUP)));
+                    OPERATOR_NEW(rb_cGrnOperator, "table-group", TABLE_GROUP));
     rb_define_const(rb_cGrnOperator, "JSON_PUT",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("json-put"),
-                               UINT2NUM(GRN_OP_JSON_PUT)));
+                    OPERATOR_NEW(rb_cGrnOperator, "json-put", JSON_PUT));
     rb_define_const(rb_cGrnOperator, "REGEXP",
-                    rb_funcall(rb_cGrnRegexpOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("regexp"),
-                               UINT2NUM(GRN_OP_REGEXP)));
+                    OPERATOR_NEW(rb_cGrnRegexpOperator, "regexp", REGEXP));
     rb_define_const(rb_cGrnOperator, "FUZZY",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("fuzzy"),
-                               UINT2NUM(GRN_OP_FUZZY)));
+                    OPERATOR_NEW(rb_cGrnOperator, "fuzzy", FUZZY));
 
 
 /*
     rb_define_const(rb_cGrnOperator, "GEO_DISTANCE1",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-distance1"),
-                               UINT2NUM(GRN_OP_GEO_DISTANCE1)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-distance1", GEO_DISTANCE1));
     rb_define_const(rb_cGrnOperator, "GEO_DISTANCE2",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-distance2"),
-                               UINT2NUM(GRN_OP_GEO_DISTANCE2)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-distance2", GEO_DISTANCE2));
     rb_define_const(rb_cGrnOperator, "GEO_DISTANCE3",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-distance3"),
-                               UINT2NUM(GRN_OP_GEO_DISTANCE3)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-distance3", GEO_DISTANCE3));
     rb_define_const(rb_cGrnOperator, "GEO_DISTANCE4",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-distance4"),
-                               UINT2NUM(GRN_OP_GEO_DISTANCE4)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-distance4", GEO_DISTANCE4));
     rb_define_const(rb_cGrnOperator, "GEO_WITHINP5",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-withinp5"),
-                               UINT2NUM(GRN_OP_GEO_WITHINP5)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-withinp5", GEO_WITHINP5));
     rb_define_const(rb_cGrnOperator, "GEO_WITHINP6",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-withinp6"),
-                               UINT2NUM(GRN_OP_GEO_WITHINP6)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-withinp6", GEO_WITHINP6));
     rb_define_const(rb_cGrnOperator, "GEO_WITHINP8",
-                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
-                               rb_str_new_cstr("geo-withinp8"),
-                               UINT2NUM(GRN_OP_GEO_WITHINP8)));
+                    OPERATOR_NEW(rb_cGrnOperator, "geo-withinp8", GEO_WITHINP8));
 */
+
+#undef OPERATOR_NEW
 }