isomorfeus-ferret 0.12.7 → 0.13.0

data/ext/isomorfeus_ferret_ext/frb_search.c

@@ -2,7 +2,9 @@
 #include "frt_array.h"
 #include "frt_search.h"
 #include "isomorfeus_ferret.h"
-#include <ruby/st.h>
+#include <ruby.h>
+
+#undef close
 
 VALUE mSearch;
 
@@ -125,11 +127,10 @@ static VALUE sym_pre_tag;
 static VALUE sym_post_tag;
 static VALUE sym_ellipsis;
 
-static FrtSymbol fsym_id;
+static ID fsym_id;
 
 extern VALUE cIndexReader;
-extern void frb_ir_free(void *p);
-extern void frb_ir_mark(void *p);
+extern const rb_data_type_t frb_index_reader_t;
 
 extern void frb_set_term(VALUE rterm, FrtTerm *t);
 extern VALUE frb_get_analyzer(FrtAnalyzer *a);
@@ -143,13 +144,8 @@ extern VALUE frb_get_lazy_doc(FrtLazyDoc *lazy_doc);
  *
  ****************************************************************************/
 
-static VALUE
-frb_get_hit(FrtHit *hit)
-{
-    return rb_struct_new(cHit,
-                         INT2FIX(hit->doc),
-                         rb_float_new((double)hit->score),
-                         NULL);
+static VALUE frb_get_hit(FrtHit *hit) {
+    return rb_struct_new(cHit, INT2FIX(hit->doc), rb_float_new((double)hit->score), NULL);
 }
 
 /****************************************************************************
@@ -158,9 +154,7 @@ frb_get_hit(FrtHit *hit)
  *
  ****************************************************************************/
 
-static VALUE
-frb_get_td(FrtTopDocs *td, VALUE rsearcher)
-{
+static VALUE frb_get_td(FrtTopDocs *td, VALUE rsearcher) {
     int i;
     VALUE rtop_docs;
     VALUE hit_ary = rb_ary_new2(td->size);
@@ -169,12 +163,8 @@ frb_get_td(FrtTopDocs *td, VALUE rsearcher)
       rb_ary_store(hit_ary, i, frb_get_hit(td->hits[i]));
     }
 
-    rtop_docs = rb_struct_new(cTopDocs,
-                              INT2FIX(td->total_hits),
-                              hit_ary,
-                              rb_float_new((double)td->max_score),
-                              rsearcher,
-                              NULL);
+    rtop_docs = rb_struct_new(cTopDocs, INT2FIX(td->total_hits), hit_ary,
+                              rb_float_new((double)td->max_score), rsearcher, NULL);
     frt_td_destroy(td);
     return rtop_docs;
 }
@@ -185,9 +175,7 @@ frb_get_td(FrtTopDocs *td, VALUE rsearcher)
  *
  *  Returns a string representation of the top_doc in readable format.
  */
-static VALUE
-frb_td_to_s(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_td_to_s(int argc, VALUE *argv, VALUE self) {
     int i;
     VALUE rhits = rb_funcall(self, id_hits, 0);
     FrtSearcher *sea = (FrtSearcher *)DATA_PTR(rb_funcall(self, id_searcher, 0));
@@ -195,7 +183,7 @@ frb_td_to_s(int argc, VALUE *argv, VALUE self)
     unsigned int capa = len * 64 + 100;
     int p = 0;
     char *str = FRT_ALLOC_N(char, len * 64 + 100);
-    FrtSymbol field = fsym_id;
+    ID field = fsym_id;
     VALUE rstr;
 
     if (argc) {
@@ -235,9 +223,7 @@ frb_td_to_s(int argc, VALUE *argv, VALUE self)
     return rstr;
 }
 
-static char *
-frb_lzd_load_to_json(FrtLazyDoc *lzd, char **str, char *s, int *slen)
-{
+static char *frb_lzd_load_to_json(FrtLazyDoc *lzd, char **str, char *s, int *slen) {
 	int i, j;
 	int diff = s - *str;
 	int len = diff, l;
@@ -285,9 +271,7 @@ frb_lzd_load_to_json(FrtLazyDoc *lzd, char **str, char *s, int *slen)
  *
  *  Returns a json representation of the top_doc.
  */
-static VALUE
-frb_td_to_json(VALUE self)
-{
+static VALUE frb_td_to_json(VALUE self) {
 	int i;
 	VALUE rhits = rb_funcall(self, id_hits, 0);
 	VALUE rhit;
@@ -333,9 +317,7 @@ frb_td_to_json(VALUE self)
  *
  *  Returns a string representation of the explanation in readable format.
  */
-static VALUE
-frb_expl_to_s(VALUE self)
-{
+static VALUE frb_expl_to_s(VALUE self) {
     GET_EXPL();
     char *str = frt_expl_to_s(expl);
     VALUE rstr = rb_str_new2(str);
@@ -349,9 +331,7 @@ frb_expl_to_s(VALUE self)
  *
  *  Returns an html representation of the explanation in readable format.
  */
-static VALUE
-frb_expl_to_html(VALUE self)
-{
+static VALUE frb_expl_to_html(VALUE self) {
     GET_EXPL();
     char *str = frt_expl_to_html(expl);
     VALUE rstr = rb_str_new2(str);
@@ -367,9 +347,7 @@ frb_expl_to_html(VALUE self)
  *  purposes mainly to check that the score returned by the explanation
  *  matches that of the score for the document in the original query.
  */
-static VALUE
-frb_expl_score(VALUE self)
-{
+static VALUE frb_expl_score(VALUE self) {
     GET_EXPL();
     return rb_float_new((double)expl->value);
 }
@@ -380,15 +358,10 @@ frb_expl_score(VALUE self)
  *
  ****************************************************************************/
 
-static void
-frb_q_free(void *p)
-{
-    object_del(p);
+static void frb_q_free(void *p) {
     frt_q_deref((FrtQuery *)p);
 }
 
-#define GET_Q() FrtQuery *q = (FrtQuery *)DATA_PTR(self)
-
 /*
  *  call-seq:
  *     query.to_s -> string
@@ -397,13 +370,11 @@ frb_q_free(void *p)
  *  this string through the Query parser will give you the exact Query you
  *  began with. This can be a good way to explore how the QueryParser works.
  */
-static VALUE
-frb_q_to_s(int argc, VALUE *argv, VALUE self)
-{
-    GET_Q();
+static VALUE frb_q_to_s(int argc, VALUE *argv, VALUE self) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     VALUE rstr, rfield;
     char *str;
-    FrtSymbol field = (FrtSymbol)NULL;
+    ID field = (ID)NULL;
     if (rb_scan_args(argc, argv, "01", &rfield)) {
         field = frb_field(rfield);
     }
@@ -420,10 +391,8 @@ frb_q_to_s(int argc, VALUE *argv, VALUE self)
  *  Returns the queries boost value. See the Query description for more
  *  information on Query boosts.
  */
-static VALUE
-frb_q_get_boost(VALUE self)
-{
-    GET_Q();
+static VALUE frb_q_get_boost(VALUE self) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     return rb_float_new((double)q->boost);
 }
 
@@ -434,10 +403,8 @@ frb_q_get_boost(VALUE self)
  *  Set the boost for a query. See the Query description for more information
  *  on Query boosts.
  */
-static VALUE
-frb_q_set_boost(VALUE self, VALUE rboost)
-{
-    GET_Q();
+static VALUE frb_q_set_boost(VALUE self, VALUE rboost) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     q->boost = (float)NUM2DBL(rboost);
     return rboost;
 }
@@ -449,10 +416,8 @@ frb_q_set_boost(VALUE self, VALUE rboost)
  *  Return a hash value for the query. This is used for caching query results
  *  in a hash object.
  */
-static VALUE
-frb_q_hash(VALUE self)
-{
-    GET_Q();
+static VALUE frb_q_hash(VALUE self) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     return INT2FIX(q->hash(q));
 }
 
@@ -469,12 +434,10 @@ frb_q_hash(VALUE self)
  *  although their result sets will be identical. Most queries should match as
  *  expected however.
  */
-static VALUE
-frb_q_eql(VALUE self, VALUE other)
-{
-    GET_Q();
+static VALUE frb_q_eql(VALUE self, VALUE other) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     FrtQuery *oq;
-    Data_Get_Struct(other, FrtQuery, oq);
+    oq = DATA_PTR(other);
     return q->eq(q, oq) ? Qtrue : Qfalse;
 }
 
@@ -487,15 +450,13 @@ frb_q_eql(VALUE self, VALUE other)
  *  searcher so that the query can be rewritten and optimized like it would be
  *  in a real search.
  */
-static VALUE
-frb_q_get_terms(VALUE self, VALUE searcher)
-{
+static VALUE frb_q_get_terms(VALUE self, VALUE searcher) {
     VALUE rterms = rb_ary_new();
     FrtHashSet *terms = frt_hs_new((frt_hash_ft)&frt_term_hash,
                             (frt_eq_ft)&frt_term_eq,
                             (frt_free_ft)frt_term_destroy);
     FrtHashSetEntry *hse;
-    GET_Q();
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     FrtSearcher *sea = (FrtSearcher *)DATA_PTR(searcher);
     FrtQuery *rq = sea->rewrite(sea, q);
     rq->extract_terms(rq, terms);
@@ -509,86 +470,59 @@ frb_q_get_terms(VALUE self, VALUE searcher)
     return rterms;
 }
 
-#define MK_QUERY(klass, q) Data_Wrap_Struct(klass, NULL, &frb_q_free, q)
-VALUE
-frb_get_q(FrtQuery *q)
-{
-    VALUE self = object_get(q);
-
-    if (self == Qnil) {
-        switch (q->type) {
-            case TERM_QUERY:
-                self = MK_QUERY(cTermQuery, q);
-                break;
-            case MULTI_TERM_QUERY:
-                self = MK_QUERY(cMultiTermQuery, q);
-                break;
-            case BOOLEAN_QUERY:
-                self = MK_QUERY(cBooleanQuery, q);
-                break;
-            case PHRASE_QUERY:
-                self = MK_QUERY(cPhraseQuery, q);
-                break;
-            case CONSTANT_QUERY:
-                self = MK_QUERY(cConstantScoreQuery, q);
-                break;
-            case FILTERED_QUERY:
-                self = MK_QUERY(cFilteredQuery, q);
-                break;
-            case MATCH_ALL_QUERY:
-                self = MK_QUERY(cMatchAllQuery, q);
-                break;
-            case RANGE_QUERY:
-                self = MK_QUERY(cRangeQuery, q);
-                break;
-            case TYPED_RANGE_QUERY:
-                self = MK_QUERY(cTypedRangeQuery, q);
-                break;
-            case WILD_CARD_QUERY:
-                self = MK_QUERY(cWildcardQuery, q);
-                break;
-            case FUZZY_QUERY:
-                self = MK_QUERY(cFuzzyQuery, q);
-                break;
-            case PREFIX_QUERY:
-                self = MK_QUERY(cPrefixQuery, q);
-                break;
-            case SPAN_TERM_QUERY:
-                self = MK_QUERY(cSpanMultiTermQuery, q);
-                break;
-            case SPAN_MULTI_TERM_QUERY:
-                self = MK_QUERY(cSpanPrefixQuery, q);
-                break;
-            case SPAN_PREFIX_QUERY:
-                self = MK_QUERY(cSpanTermQuery, q);
-                break;
-            case SPAN_FIRST_QUERY:
-                self = MK_QUERY(cSpanFirstQuery, q);
-                break;
-            case SPAN_OR_QUERY:
-                self = MK_QUERY(cSpanOrQuery, q);
-                break;
-            case SPAN_NOT_QUERY:
-                self = MK_QUERY(cSpanNotQuery, q);
-                break;
-            case SPAN_NEAR_QUERY:
-                self = MK_QUERY(cSpanNearQuery, q);
-                break;
-            default:
-                rb_raise(rb_eArgError, "Unknown query type");
-                break;
-        }
-        object_add(q, self);
-    }
-    return self;
-}
-
 /****************************************************************************
- *
  * TermQuery Methods
- *
  ****************************************************************************/
 
+static size_t frb_term_query_size(const void *p) {
+    return sizeof(FrtTermQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_term_query_t = {
+    .wrap_struct_name = "FrbTermQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_term_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_tq_alloc(VALUE rclass) {
+    FrtQuery *tq = frt_tq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_term_query_t, tq);
+}
+
+typedef struct frb_tq_args {
+    VALUE self;
+    VALUE rfield;
+    VALUE rterm;
+    char  *term;
+    ID    field;
+} frb_tq_args;
+
+VALUE frb_tq_init_2(VALUE args) {
+    frb_tq_args *a = (frb_tq_args *)args;
+    a->field = frb_field(a->rfield);
+    a->term = rs2s(rb_obj_as_string(a->rterm));
+    return Qnil;
+}
+
+VALUE frb_q_init_r(VALUE args, VALUE exception) {
+    frb_tq_args *a = (frb_tq_args *)args;
+    free(((struct RData *)(a->self))->data);
+    ((struct RData *)(a->self))->data = NULL;
+    ((struct RData *)(a->self))->dmark = NULL;
+    ((struct RData *)(a->self))->dfree = NULL;
+    rb_exc_raise(exception);
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     TermQuery.new(field, term) -> term_query
@@ -598,14 +532,13 @@ frb_get_q(FrtQuery *q)
  *
  *  Note: As usual, field should be a symbol
  */
-static VALUE
-frb_tq_init(VALUE self, VALUE rfield, VALUE rterm)
-{
-    FrtSymbol field = frb_field(rfield);
-    char *term = rs2s(rb_obj_as_string(rterm));
-    FrtQuery *q = frt_tq_new(field, term);
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+static VALUE frb_tq_init(VALUE self, VALUE rfield, VALUE rterm) {
+    frb_tq_args args = { .self = self, .rfield = rfield, .rterm = rterm, .field = 0, .term = NULL };
+    rb_rescue(frb_tq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
+    FrtQuery *q;
+    TypedData_Get_Struct(self, FrtQuery, &frb_term_query_t, q);
+    frt_tq_init(q, args.field, args.term);
+    q->rquery = self;
     return self;
 }
 
@@ -615,6 +548,30 @@ frb_tq_init(VALUE self, VALUE rfield, VALUE rterm)
  *
  ****************************************************************************/
 
+static size_t frb_multi_term_query_size(const void *p) {
+    return sizeof(FrtMultiTermQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_multi_term_query_t = {
+    .wrap_struct_name = "FrbTermQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_multi_term_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_mtq_alloc(VALUE rclass) {
+    FrtQuery *tq = frt_multi_tq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_multi_term_query_t, tq);
+}
+
 /*
  *  call-seq:
  *     MultiTermQuery.default_max_terms -> number
@@ -622,9 +579,7 @@ frb_tq_init(VALUE self, VALUE rfield, VALUE rterm)
  *  Get the default value for +:max_terms+ in a MultiTermQuery. This value is
  *  also used by PrefixQuery, FuzzyQuery and WildcardQuery.
  */
-static VALUE
-frb_mtq_get_dmt(VALUE self)
-{
+static VALUE frb_mtq_get_dmt(VALUE self) {
     return rb_cvar_get(cMultiTermQuery, id_default_max_terms);
 }
 
@@ -635,18 +590,42 @@ frb_mtq_get_dmt(VALUE self)
  *  Set the default value for +:max_terms+ in a MultiTermQuery. This value is
  *  also used by PrefixQuery, FuzzyQuery and WildcardQuery.
  */
-static VALUE
-frb_mtq_set_dmt(VALUE self, VALUE rnum_terms)
-{
+static VALUE frb_mtq_set_dmt(VALUE self, VALUE rnum_terms) {
     int max_terms = FIX2INT(rnum_terms);
     if (max_terms <= 0) {
-        rb_raise(rb_eArgError,
-                 "%d <= 0. @@max_terms must be > 0", max_terms);
+        rb_raise(rb_eArgError, "%d <= 0. @@max_terms must be > 0", max_terms);
     }
     rb_cvar_set(cMultiTermQuery, id_default_max_terms, rnum_terms);
     return rnum_terms;
 }
 
+typedef struct frb_mtq_args {
+    VALUE self;
+    VALUE argc;
+    VALUE *argv;
+    float min_score;
+    int   max_terms;
+    ID    field;
+} frb_mtq_args;
+
+VALUE frb_mtq_init_2(VALUE args) {
+    frb_mtq_args *a = (frb_mtq_args *)args;
+    VALUE rfield, roptions;
+    a->min_score = 0.0f;
+    a->max_terms = FIX2INT(frb_mtq_get_dmt(a->self));
+    if (rb_scan_args(a->argc, a->argv, "11", &rfield, &roptions) == 2) {
+        VALUE v;
+        if (Qnil != (v = rb_hash_aref(roptions, sym_max_terms))) {
+            a->max_terms = FIX2INT(v);
+        }
+        if (Qnil != (v = rb_hash_aref(roptions, sym_min_score))) {
+            a->min_score = (float)NUM2DBL(v);
+        }
+    }
+    a->field = frb_field(rfield);
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     MultiTermQuery.new(field, options = {}) -> multi_term_query
@@ -671,26 +650,13 @@ frb_mtq_set_dmt(VALUE self, VALUE rnum_terms)
  *               added to the query you could set a lower limit to this score.
  *               FuzzyQuery in particular makes use of this parameter.
  */
-static VALUE
-frb_mtq_init(int argc, VALUE *argv, VALUE self)
-{
-    VALUE rfield, roptions;
-    float min_score = 0.0f;
-    int max_terms = FIX2INT(frb_mtq_get_dmt(self));
+static VALUE frb_mtq_init(int argc, VALUE *argv, VALUE self) {
+    frb_mtq_args args = { .self = self, .argc = argc, .argv = argv, .field = 0 };
+    rb_rescue(frb_mtq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
     FrtQuery *q;
-
-    if (rb_scan_args(argc, argv, "11", &rfield, &roptions) == 2) {
-        VALUE v;
-        if (Qnil != (v = rb_hash_aref(roptions, sym_max_terms))) {
-            max_terms = FIX2INT(v);
-        }
-        if (Qnil != (v = rb_hash_aref(roptions, sym_min_score))) {
-            min_score = (float)NUM2DBL(v);
-        }
-    }
-    q = frt_multi_tq_new_conf(frb_field(rfield), max_terms, min_score);
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+    TypedData_Get_Struct(self, FrtQuery, &frb_multi_term_query_t, q);
+    frt_multi_tq_init_conf(q, args.field, args.max_terms, args.min_score);
+    q->rquery = self;
     return self;
 }
 
@@ -702,10 +668,8 @@ frb_mtq_init(int argc, VALUE *argv, VALUE self)
  *  Add a term to the MultiTermQuery with the score 1.0 unless specified
  *  otherwise.
  */
-static VALUE
-frb_mtq_add_term(int argc, VALUE *argv, VALUE self)
-{
-    GET_Q();
+static VALUE frb_mtq_add_term(int argc, VALUE *argv, VALUE self) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     VALUE rterm, rboost;
     float boost = 1.0f;
     char *term = NULL;
@@ -718,11 +682,9 @@ frb_mtq_add_term(int argc, VALUE *argv, VALUE self)
     return self;
 }
 
-typedef FrtQuery *(*mtq_maker_ft)(FrtSymbol field, const char *term);
+typedef FrtQuery *(*mtq_maker_ft)(ID field, const char *term);
 
-static int
-get_max_terms(VALUE rmax_terms, int max_terms)
-{
+static int get_max_terms(VALUE rmax_terms, int max_terms) {
     VALUE v;
     switch (TYPE(rmax_terms)) {
         case T_HASH:
@@ -739,56 +701,53 @@ get_max_terms(VALUE rmax_terms, int max_terms)
     return max_terms;
 }
 
-static VALUE
-frb_mtq_init_specific(int argc, VALUE *argv, VALUE self, mtq_maker_ft mm)
-{
-    VALUE rfield, rterm, rmax_terms;
-    int max_terms =
-        FIX2INT(rb_cvar_get(cMultiTermQuery, id_default_max_terms));
-    FrtQuery *q;
-
-    if (rb_scan_args(argc, argv, "21", &rfield, &rterm, &rmax_terms) == 3) {
-        max_terms = get_max_terms(rmax_terms, max_terms);
-    }
-
-    q = (*mm)(frb_field(rfield), StringValuePtr(rterm));
-    FrtMTQMaxTerms(q) = max_terms;
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
-    return self;
-}
-
 /****************************************************************************
  *
  * BooleanClause Methods
  *
  ****************************************************************************/
 
-static void
-frb_bc_mark(void *p)
-{
-    frb_gc_mark(((FrtBooleanClause *)p)->query);
+static size_t frb_boolean_clause_t_size(const void *p) {
+    return sizeof(FrtBooleanClause);
+    (void)p;
 }
 
-static void
-frb_bc_free(void *p)
-{
-    object_del(p);
+static void frb_bc_mark(void *p) {
+    if (((FrtBooleanClause *)p)->query->rquery)
+        rb_gc_mark(((FrtBooleanClause *)p)->query->rquery);
+}
+
+static void frb_bc_free(void *p) {
     frt_bc_deref((FrtBooleanClause *)p);
 }
 
-static VALUE
-frb_bc_wrap(FrtBooleanClause *bc)
-{
-    VALUE self = Data_Wrap_Struct(cBooleanClause, &frb_bc_mark, &frb_bc_free, bc);
+const rb_data_type_t frb_boolean_clause_t = {
+    .wrap_struct_name = "FrbBooleanClause",
+    .function = {
+        .dmark = frb_bc_mark,
+        .dfree = frb_bc_free,
+        .dsize = frb_boolean_clause_t_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_bc_alloc(VALUE rclass) {
+    FrtBooleanClause *bc = frt_bc_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_boolean_clause_t, bc);
+}
+
+static VALUE frb_bc_wrap(FrtBooleanClause *bc) {
+    VALUE self = TypedData_Wrap_Struct(cBooleanClause, &frb_boolean_clause_t, bc);
+    bc->rbc = self;
     FRT_REF(bc);
-    object_add(bc, self);
     return self;
 }
 
-static FrtBCType
-frb_get_occur(VALUE roccur)
-{
+static FrtBCType frb_get_occur(VALUE roccur) {
     FrtBCType occur = FRT_BC_SHOULD;
 
     if (roccur == sym_should) {
@@ -798,8 +757,7 @@ frb_get_occur(VALUE roccur)
     } else if (roccur == sym_must_not) {
         occur = FRT_BC_MUST_NOT;
     } else {
-        rb_raise(rb_eArgError, "occur argument must be one of [:must, "
-                 ":should, :must_not]");
+        rb_raise(rb_eArgError, "occur argument must be one of [:must, :should, :must_not]");
     }
     return occur;
 }
@@ -811,36 +769,33 @@ frb_get_occur(VALUE roccur)
  *  Create a new BooleanClause object, wrapping the query +query+. +occur+
  *  must be one of +:must+, +:should+ or +:must_not+.
  */
-static VALUE
-frb_bc_init(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_bc_init(int argc, VALUE *argv, VALUE self) {
     FrtBooleanClause *bc;
+    TypedData_Get_Struct(self, FrtBooleanClause, &frb_boolean_clause_t, bc);
     VALUE rquery, roccur;
     unsigned int occur = FRT_BC_SHOULD;
     FrtQuery *sub_q;
     if (rb_scan_args(argc, argv, "11", &rquery, &roccur) == 2) {
         occur = frb_get_occur(roccur);
     }
-    Data_Get_Struct(rquery, FrtQuery, sub_q);
+    sub_q = DATA_PTR(rquery);
     FRT_REF(sub_q);
-    bc = frt_bc_new(sub_q, occur);
-    Frt_Wrap_Struct(self, &frb_bc_mark, &frb_bc_free, bc);
-    object_add(bc, self);
+    frt_bc_init(bc, sub_q, occur);
+    bc->rbc = self;
     return self;
 }
 
-#define GET_BC() FrtBooleanClause *bc = (FrtBooleanClause *)DATA_PTR(self)
 /*
  *  call-seq:
  *     clause.query -> query
  *
  *  Return the query object wrapped by this BooleanClause.
  */
-static VALUE
-frb_bc_get_query(VALUE self)
-{
-    GET_BC();
-    return object_get(bc->query);
+static VALUE frb_bc_get_query(VALUE self) {
+    FrtBooleanClause *bc = (FrtBooleanClause *)DATA_PTR(self);
+    if (bc->query->rquery)
+        return bc->query->rquery;
+    return Qnil;
 }
 
 /*
@@ -849,11 +804,9 @@ frb_bc_get_query(VALUE self)
  *
  *  Set the query wrapped by this BooleanClause.
  */
-static VALUE
-frb_bc_set_query(VALUE self, VALUE rquery)
-{
-    GET_BC();
-    Data_Get_Struct(rquery, FrtQuery, bc->query);
+static VALUE frb_bc_set_query(VALUE self, VALUE rquery) {
+    FrtBooleanClause *bc = (FrtBooleanClause *)DATA_PTR(self);
+    bc->query = DATA_PTR(rquery);
     return rquery;
 }
 
@@ -864,10 +817,8 @@ frb_bc_set_query(VALUE self, VALUE rquery)
  *  Return true if this clause is required. ie, this will be true if occur was
  *  equal to +:must+.
  */
-static VALUE
-frb_bc_is_required(VALUE self)
-{
-    GET_BC();
+static VALUE frb_bc_is_required(VALUE self) {
+    FrtBooleanClause *bc = (FrtBooleanClause *)DATA_PTR(self);
     return bc->is_required ? Qtrue : Qfalse;
 }
 
@@ -878,10 +829,8 @@ frb_bc_is_required(VALUE self)
  *  Return true if this clause is prohibited. ie, this will be true if occur was
  *  equal to +:must_not+.
  */
-static VALUE
-frb_bc_is_prohibited(VALUE self)
-{
-    GET_BC();
+static VALUE frb_bc_is_prohibited(VALUE self) {
+    FrtBooleanClause *bc = (FrtBooleanClause *)DATA_PTR(self);
     return bc->is_prohibited ? Qtrue : Qfalse;
 }
 
@@ -892,10 +841,8 @@ frb_bc_is_prohibited(VALUE self)
  *  Set the +occur+ value for this BooleanClause. +occur+ must be one of
  *  +:must+, +:should+ or +:must_not+.
  */
-static VALUE
-frb_bc_set_occur(VALUE self, VALUE roccur)
-{
-    GET_BC();
+static VALUE frb_bc_set_occur(VALUE self, VALUE roccur) {
+    FrtBooleanClause *bc = (FrtBooleanClause *)DATA_PTR(self);
     FrtBCType occur = frb_get_occur(roccur);
     frt_bc_set_occur(bc, occur);
 
@@ -910,15 +857,13 @@ frb_bc_set_occur(VALUE self, VALUE roccur)
  *  BooleanQuery#to_s. It is only used by BooleanClause#to_s and will specify
  *  whether the clause is +:must+, +:should+ or +:must_not+.
  */
-static VALUE
-frb_bc_to_s(VALUE self)
-{
+static VALUE frb_bc_to_s(VALUE self) {
     VALUE rstr;
     char *qstr, *str;
     const char *ostr = "";
     int len;
-    GET_BC();
-    qstr = bc->query->to_s(bc->query, (FrtSymbol)NULL);
+    FrtBooleanClause *bc = (FrtBooleanClause *)DATA_PTR(self);
+    qstr = bc->query->to_s(bc->query, (ID)NULL);
     switch (bc->occur) {
         case FRT_BC_SHOULD:
             ostr = "Should";
@@ -945,15 +890,55 @@ frb_bc_to_s(VALUE self)
  *
  ****************************************************************************/
 
-static void
-frb_bq_mark(void *p)
-{
+static size_t frb_boolean_query_size(const void *p) {
+    return sizeof(FrtBooleanQuery);
+    (void)p;
+}
+
+static void frb_bq_mark(void *p) {
     int i;
     FrtQuery *q = (FrtQuery *)p;
     FrtBooleanQuery *bq = (FrtBooleanQuery *)q;
     for (i = 0; i < bq->clause_cnt; i++) {
-        frb_gc_mark(bq->clauses[i]);
+        if (bq->clauses[i]->rbc)
+            rb_gc_mark(bq->clauses[i]->rbc);
+    }
+}
+
+const rb_data_type_t frb_boolean_query_t = {
+    .wrap_struct_name = "FrbBooleanQuery",
+    .function = {
+        .dmark = frb_bq_mark,
+        .dfree = frb_q_free,
+        .dsize = frb_boolean_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_bq_alloc(VALUE rclass) {
+    FrtQuery *bq = frt_bq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_boolean_query_t, bq);
+}
+
+typedef struct frb_bq_args {
+    VALUE self;
+    VALUE argc;
+    VALUE *argv;
+    bool coord_disabled;
+} frb_bq_args;
+
+VALUE frb_bq_init_2(VALUE args) {
+    frb_bq_args *a = (frb_bq_args *)args;
+    VALUE rcoord_disabled;
+    a->coord_disabled = false;
+    if (rb_scan_args(a->argc, a->argv, "01", &rcoord_disabled)) {
+        a->coord_disabled = RTEST(rcoord_disabled);
     }
+    return Qnil;
 }
 
 /*
@@ -966,18 +951,13 @@ frb_bq_mark(void *p)
  *  score. This will slightly improve performance for the query. Usually you
  *  should leave this parameter as is.
  */
-static VALUE
-frb_bq_init(int argc, VALUE *argv, VALUE self)
-{
-    VALUE rcoord_disabled;
-    bool coord_disabled = false;
+static VALUE frb_bq_init(int argc, VALUE *argv, VALUE self) {
+    frb_bq_args args = { .self = self, .argc = argc, .argv = argv };
+    rb_rescue(frb_bq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
     FrtQuery *q;
-    if (rb_scan_args(argc, argv, "01", &rcoord_disabled)) {
-        coord_disabled = RTEST(rcoord_disabled);
-    }
-    q = frt_bq_new(coord_disabled);
-    Frt_Wrap_Struct(self, &frb_bq_mark, &frb_q_free, q);
-    object_add(q, self);
+    TypedData_Get_Struct(self, FrtQuery, &frb_boolean_query_t, q);
+    frt_bq_init(q, args.coord_disabled);
+    q->rquery = self;
     return self;
 }
 
@@ -1002,10 +982,8 @@ frb_bq_init(int argc, VALUE *argv, VALUE self)
  *            [:must, :should, :must_not]
  *  returns:: BooleanClause which was added
  */
-static VALUE
-frb_bq_add_query(int argc, VALUE *argv, VALUE self)
-{
-    GET_Q();
+static VALUE frb_bq_add_query(int argc, VALUE *argv, VALUE self) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     VALUE rquery, roccur;
     FrtBCType occur = FRT_BC_SHOULD;
     FrtQuery *sub_q;
@@ -1018,17 +996,15 @@ frb_bq_add_query(int argc, VALUE *argv, VALUE self)
     if (klass == cBooleanClause) {
         FrtBooleanClause *bc = (FrtBooleanClause *)DATA_PTR(rquery);
         if (argc > 1) {
-            rb_warning("Second argument to BooleanQuery#add is ignored "
-                       "when adding BooleanClause");
+            rb_warning("Second argument to BooleanQuery#add is ignored when adding BooleanClause");
         }
         frt_bq_add_clause(q, bc);
         return rquery;
     } else if (TYPE(rquery) == T_DATA) {
-        Data_Get_Struct(rquery, FrtQuery, sub_q);
+        sub_q = DATA_PTR(rquery);
         return frb_bc_wrap(frt_bq_add_query(q, sub_q, occur));
     } else {
-        rb_raise(rb_eArgError, "Cannot add %s to a BooleanQuery",
-                 rb_class2name(klass));
+        rb_raise(rb_eArgError, "Cannot add %s to a BooleanQuery", rb_class2name(klass));
     }
     return self;
 }
@@ -1039,62 +1015,94 @@ frb_bq_add_query(int argc, VALUE *argv, VALUE self)
  *
  ****************************************************************************/
 
-static void
-get_range_params(VALUE roptions, char **lterm, char **uterm,
-                 bool *include_lower, bool *include_upper)
-{
+static size_t frb_range_query_size(const void *p) {
+    return sizeof(FrtRangeQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_range_query_t = {
+    .wrap_struct_name = "FrbRangeQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_range_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_rq_alloc(VALUE rclass) {
+    FrtQuery *rq = frt_rq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_range_query_t, rq);
+}
+
+typedef struct frb_rq_args {
+    VALUE self;
+    VALUE rfield;
+    VALUE roptions;
+    ID    field;
+    char  *lterm;
+    char  *uterm;
+    bool  include_lower;
+    bool  include_upper;
+} frb_rq_args;
+
+VALUE frb_rq_init_2(VALUE args) {
+    frb_rq_args *a = (frb_rq_args *)args;
     VALUE v;
-    Check_Type(roptions, T_HASH);
-    if (Qnil != (v = rb_hash_aref(roptions, sym_lower))) {
-        *lterm = rs2s(rb_obj_as_string(v));
-        *include_lower = true;
+    Check_Type(a->roptions, T_HASH);
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_lower))) {
+        a->lterm = rs2s(rb_obj_as_string(v));
+        a->include_lower = true;
     }
-    if (Qnil != (v = rb_hash_aref(roptions, sym_upper))) {
-        *uterm = rs2s(rb_obj_as_string(v));
-        *include_upper = true;
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_upper))) {
+        a->uterm = rs2s(rb_obj_as_string(v));
+        a->include_upper = true;
     }
-    if (Qnil != (v = rb_hash_aref(roptions, sym_lower_exclusive))) {
-        *lterm = rs2s(rb_obj_as_string(v));
-        *include_lower = false;
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_lower_exclusive))) {
+        a->lterm = rs2s(rb_obj_as_string(v));
+        a->include_lower = false;
     }
-    if (Qnil != (v = rb_hash_aref(roptions, sym_upper_exclusive))) {
-        *uterm = rs2s(rb_obj_as_string(v));
-        *include_upper = false;
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_upper_exclusive))) {
+        a->uterm = rs2s(rb_obj_as_string(v));
+        a->include_upper = false;
     }
-    if (Qnil != (v = rb_hash_aref(roptions, sym_include_lower))) {
-        *include_lower = RTEST(v);
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_include_lower))) {
+        a->include_lower = RTEST(v);
     }
-    if (Qnil != (v = rb_hash_aref(roptions, sym_include_upper))) {
-        *include_upper = RTEST(v);
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_include_upper))) {
+        a->include_upper = RTEST(v);
     }
-    if (Qnil != (v = rb_hash_aref(roptions, sym_greater_than))) {
-        *lterm = rs2s(rb_obj_as_string(v));
-        *include_lower = false;
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_greater_than))) {
+        a->lterm = rs2s(rb_obj_as_string(v));
+        a->include_lower = false;
     }
-    if (Qnil != (v = rb_hash_aref(roptions, sym_greater_than_or_equal_to))) {
-        *lterm = rs2s(rb_obj_as_string(v));
-        *include_lower = true;
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_greater_than_or_equal_to))) {
+        a->lterm = rs2s(rb_obj_as_string(v));
+        a->include_lower = true;
     }
-    if (Qnil != (v = rb_hash_aref(roptions, sym_less_than))) {
-        *uterm = rs2s(rb_obj_as_string(v));
-        *include_upper = false;
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_less_than))) {
+        a->uterm = rs2s(rb_obj_as_string(v));
+        a->include_upper = false;
     }
-    if (Qnil != (v = rb_hash_aref(roptions, sym_less_than_or_equal_to))) {
-        *uterm = rs2s(rb_obj_as_string(v));
-        *include_upper = true;
+    if (Qnil != (v = rb_hash_aref(a->roptions, sym_less_than_or_equal_to))) {
+        a->uterm = rs2s(rb_obj_as_string(v));
+        a->include_upper = true;
     }
-    if (!*lterm && !*uterm) {
-        rb_raise(rb_eArgError,
-                 "The bounds of a range should not both be nil");
+    if (!a->lterm && !a->uterm) {
+        rb_raise(rb_eArgError, "The bounds of a range should not both be nil");
     }
-    if (*include_lower && !*lterm) {
-        rb_raise(rb_eArgError,
-                 "The lower bound should not be nil if it is inclusive");
+    if (a->include_lower && !a->lterm) {
+        rb_raise(rb_eArgError, "The lower bound should not be nil if it is inclusive");
     }
-    if (*include_upper && !*uterm) {
-        rb_raise(rb_eArgError,
-                 "The upper bound should not be nil if it is inclusive");
+    if (a->include_upper && !a->uterm) {
+        rb_raise(rb_eArgError, "The upper bound should not be nil if it is inclusive");
     }
+    a->field = frb_field(a->rfield);
+    return Qnil;
 }
 
 /*
@@ -1120,21 +1128,13 @@ get_range_params(VALUE roptions, char **lterm, char **uterm,
  *    q = RangeQuery.new(:date, :>= => "200501", :<= => 200502)
  *
  */
-static VALUE
-frb_rq_init(VALUE self, VALUE rfield, VALUE roptions)
-{
+static VALUE frb_rq_init(VALUE self, VALUE rfield, VALUE roptions) {
+    frb_rq_args a = { .self = self, .rfield = rfield, .roptions = roptions };
+    rb_rescue(frb_rq_init_2, (VALUE)&a, frb_q_init_r, (VALUE)&a);
     FrtQuery *q;
-    char *lterm = NULL;
-    char *uterm = NULL;
-    bool include_lower = false;
-    bool include_upper = false;
-
-    get_range_params(roptions, &lterm, &uterm, &include_lower, &include_upper);
-    q = frt_rq_new(frb_field(rfield),
-               lterm, uterm,
-               include_lower, include_upper);
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+    TypedData_Get_Struct(self, FrtQuery, &frb_range_query_t, q);
+    frt_rq_init(q, a.field, a.lterm, a.uterm, a.include_lower, a.include_upper);
+    q->rquery = self;
     return self;
 }
 
@@ -1144,6 +1144,30 @@ frb_rq_init(VALUE self, VALUE rfield, VALUE roptions)
  *
  ****************************************************************************/
 
+static size_t frb_typed_range_query_size(const void *p) {
+    return sizeof(FrtRangeQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_typed_range_query_t = {
+    .wrap_struct_name = "FrbTypedRangeQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_typed_range_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_trq_alloc(VALUE rclass) {
+    FrtQuery *trq = frt_trq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_typed_range_query_t, trq);
+}
+
 /*
  *  call-seq:
  *     TypedRangeQuery.new(field, options = {}) -> range_query
@@ -1172,21 +1196,13 @@ frb_rq_init(VALUE self, VALUE rfield, VALUE roptions)
  *    # is equivalent to
  *    q = TypedRangeQuery.new(:date, :>= => "-12.32", :<= => 0.21)
  */
-static VALUE
-frb_trq_init(VALUE self, VALUE rfield, VALUE roptions)
-{
+static VALUE frb_trq_init(VALUE self, VALUE rfield, VALUE roptions) {
+    frb_rq_args a = { .self = self, .rfield = rfield, .roptions = roptions };
+    rb_rescue(frb_rq_init_2, (VALUE)&a, frb_q_init_r, (VALUE)&a);
     FrtQuery *q;
-    char *lterm = NULL;
-    char *uterm = NULL;
-    bool include_lower = false;
-    bool include_upper = false;
-
-    get_range_params(roptions, &lterm, &uterm, &include_lower, &include_upper);
-    q = frt_trq_new(frb_field(rfield),
-                lterm, uterm,
-                include_lower, include_upper);
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+    TypedData_Get_Struct(self, FrtQuery, &frb_typed_range_query_t, q);
+    q = frt_trq_init(q, a.field, a.lterm, a.uterm, a.include_lower, a.include_upper);
+    q->rquery = self;
     return self;
 }
 
@@ -1196,6 +1212,49 @@ frb_trq_init(VALUE self, VALUE rfield, VALUE roptions)
  *
  ****************************************************************************/
 
+static size_t frb_phrase_query_size(const void *p) {
+    return sizeof(FrtPhraseQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_phrase_query_t = {
+    .wrap_struct_name = "FrbPhraseQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_phrase_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_phq_alloc(VALUE rclass) {
+    FrtQuery *phq = frt_phq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_phrase_query_t, phq);
+}
+
+typedef struct frb_phq_args {
+    VALUE self;
+    VALUE argc;
+    VALUE *argv;
+    ID    field;
+    int   slop;
+} frb_phq_args;
+
+VALUE frb_phq_init_2(VALUE args) {
+    frb_phq_args *a = (frb_phq_args *)args;
+    VALUE rfield, rslop;
+    rb_scan_args(a->argc, a->argv, "11", &rfield, &rslop);
+    a->field = frb_field(rfield);
+    if (rslop != Qnil) {
+        a->slop = FIX2INT(rslop);
+    }
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     PhraseQuery.new(field, slop = 0) -> phrase_query
@@ -1203,18 +1262,16 @@ frb_trq_init(VALUE self, VALUE rfield, VALUE roptions)
  *  Create a new PhraseQuery on the field +field+. You need to add terms to
  *  the query it will do anything of value. See PhraseQuery#add_term.
  */
-static VALUE
-frb_phq_init(int argc, VALUE *argv, VALUE self)
-{
-    VALUE rfield, rslop;
+static VALUE frb_phq_init(int argc, VALUE *argv, VALUE self) {
+    frb_phq_args args = { .self = self, .argc = argc, .argv = argv };
+    rb_rescue(frb_phq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
     FrtQuery *q;
-    rb_scan_args(argc, argv, "11", &rfield, &rslop);
-    q = frt_phq_new(frb_field(rfield));
+    TypedData_Get_Struct(self, FrtQuery, &frb_phrase_query_t, q);
+    frt_phq_init(q, args.field);
     if (argc == 2) {
-        ((FrtPhraseQuery *)q)->slop = FIX2INT(rslop);
+        ((FrtPhraseQuery *)q)->slop = args.slop;
     }
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+    q->rquery = self;
     return self;
 }
 
@@ -1239,7 +1296,7 @@ frb_phq_add(int argc, VALUE *argv, VALUE self)
 {
     VALUE rterm, rpos_inc;
     int pos_inc = 1;
-    GET_Q();
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     if (rb_scan_args(argc, argv, "11", &rterm, &rpos_inc) == 2) {
         pos_inc = FIX2INT(rpos_inc);
     }
@@ -1282,9 +1339,8 @@ frb_phq_add(int argc, VALUE *argv, VALUE self)
  *  description for more information on slop
  */
 static VALUE
-frb_phq_get_slop(VALUE self)
-{
-    GET_Q();
+frb_phq_get_slop(VALUE self) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     return INT2FIX(((FrtPhraseQuery *)q)->slop);
 }
 
@@ -1296,9 +1352,8 @@ frb_phq_get_slop(VALUE self)
  *  for more information on slop
  */
 static VALUE
-frb_phq_set_slop(VALUE self, VALUE rslop)
-{
-    GET_Q();
+frb_phq_set_slop(VALUE self, VALUE rslop) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     ((FrtPhraseQuery *)q)->slop = FIX2INT(rslop);
     return self;
 }
@@ -1309,6 +1364,51 @@ frb_phq_set_slop(VALUE self, VALUE rslop)
  *
  ****************************************************************************/
 
+static size_t frb_prefix_query_size(const void *p) {
+    return sizeof(FrtPrefixQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_prefix_query_t = {
+    .wrap_struct_name = "FrbPrefixQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_prefix_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_prq_alloc(VALUE rclass) {
+    FrtQuery *pq = frt_prefixq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_prefix_query_t, pq);
+}
+
+typedef struct frb_prq_args {
+    VALUE self;
+    VALUE argc;
+    VALUE *argv;
+    ID    field;
+    char  *term;
+    int   max_terms;
+} frb_prq_args;
+
+VALUE frb_prq_init_2(VALUE args) {
+    frb_prq_args *a = (frb_prq_args *)args;
+    VALUE rfield, rterm, rmax_terms;
+    a->max_terms = FIX2INT(rb_cvar_get(cMultiTermQuery, id_default_max_terms));
+    if (rb_scan_args(a->argc, a->argv, "21", &rfield, &rterm, &rmax_terms) == 3) {
+        a->max_terms = get_max_terms(rmax_terms, a->max_terms);
+    }
+    a->field = frb_field(rfield);
+    a->term = StringValuePtr(rterm);
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     PrefixQuery.new(field, prefix, options = {}) -> prefix-query
@@ -1325,10 +1425,15 @@ frb_phq_set_slop(VALUE self, VALUE rslop)
  *  +:max_terms+ which limits the number of terms that get added to the query.
  *  By default it is set to 512.
  */
-static VALUE
-frb_prq_init(int argc, VALUE *argv, VALUE self)
-{
-    return frb_mtq_init_specific(argc, argv, self, &frt_prefixq_new);
+static VALUE frb_prq_init(int argc, VALUE *argv, VALUE self) {
+    frb_prq_args args = { .self = self, .argc = argc, .argv = argv };
+    rb_rescue(frb_prq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
+    FrtQuery *q;
+    TypedData_Get_Struct(self, FrtQuery, &frb_prefix_query_t, q);
+    frt_prefixq_init(q, args.field, args.term);
+    FrtMTQMaxTerms(q) = args.max_terms;
+    q->rquery = self;
+    return self;
 }
 
 /****************************************************************************
@@ -1337,6 +1442,51 @@ frb_prq_init(int argc, VALUE *argv, VALUE self)
  *
  ****************************************************************************/
 
+static size_t frb_wildcard_query_size(const void *p) {
+    return sizeof(FrtWildCardQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_wilcard_query_t = {
+    .wrap_struct_name = "FrbWildcardQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_wildcard_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_wcq_alloc(VALUE rclass) {
+    FrtQuery *wq = frt_wcq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_wilcard_query_t, wq);
+}
+
+typedef struct frb_wcq_args {
+    VALUE self;
+    VALUE argc;
+    VALUE *argv;
+    ID    field;
+    char  *term;
+    int   max_terms;
+} frb_wcq_args;
+
+VALUE frb_wcq_init_2(VALUE args) {
+    frb_wcq_args *a = (frb_wcq_args *)args;
+    VALUE rfield, rterm, rmax_terms;
+    a->max_terms = FIX2INT(rb_cvar_get(cMultiTermQuery, id_default_max_terms));
+    if (rb_scan_args(a->argc, a->argv, "21", &rfield, &rterm, &rmax_terms) == 3) {
+        a->max_terms = get_max_terms(rmax_terms, a->max_terms);
+    }
+    a->field = frb_field(rfield);
+    a->term = StringValuePtr(rterm);
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     WildcardQuery.new(field, pattern, options = {}) -> wild-card-query
@@ -1355,10 +1505,15 @@ frb_prq_init(int argc, VALUE *argv, VALUE self)
  *  set +:max_terms+ which limits the number of terms that get added to the
  *  query.  By default it is set to 512.
  */
-static VALUE
-frb_wcq_init(int argc, VALUE *argv, VALUE self)
-{
-    return frb_mtq_init_specific(argc, argv, self, &frt_wcq_new);
+static VALUE frb_wcq_init(int argc, VALUE *argv, VALUE self) {
+    frb_wcq_args args = { .self = self, .argc = argc, .argv = argv };
+    rb_rescue(frb_wcq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
+    FrtQuery *q;
+    TypedData_Get_Struct(self, FrtQuery, &frb_wilcard_query_t, q);
+    frt_wcq_init(q, args.field, args.term);
+    FrtMTQMaxTerms(q) = args.max_terms;
+    q->rquery = self;
+    return self;
 }
 
 /****************************************************************************
@@ -1367,6 +1522,79 @@ frb_wcq_init(int argc, VALUE *argv, VALUE self)
  *
  ****************************************************************************/
 
+static size_t frb_fuzzy_query_size(const void *p) {
+    return sizeof(FrtFuzzyQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_fuzzy_query_t = {
+    .wrap_struct_name = "FrbFuzzyQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_fuzzy_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_fq_alloc(VALUE rclass) {
+    FrtQuery *fq = frt_fuzq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_fuzzy_query_t, fq);
+}
+
+typedef struct frb_fq_args {
+    VALUE self;
+    VALUE argc;
+    VALUE *argv;
+    ID    field;
+    char  *term;
+    float min_sim;
+    int   max_terms;
+    int   pre_len;
+} frb_fq_args;
+
+VALUE frb_fq_init_2(VALUE args) {
+    frb_fq_args *a = (frb_fq_args *)args;
+    VALUE rfield, rterm, roptions;
+    a->min_sim = (float)NUM2DBL(rb_cvar_get(cFuzzyQuery, id_default_min_similarity));
+    a->pre_len = FIX2INT(rb_cvar_get(cFuzzyQuery, id_default_prefix_length));
+    a->max_terms = FIX2INT(rb_cvar_get(cMultiTermQuery, id_default_max_terms));
+
+    if (rb_scan_args(a->argc, a->argv, "21", &rfield, &rterm, &roptions) >= 3) {
+        VALUE v;
+        Check_Type(roptions, T_HASH);
+        if (Qnil != (v = rb_hash_aref(roptions, sym_prefix_length))) {
+            a->pre_len = FIX2INT(v);
+        }
+        if (Qnil != (v = rb_hash_aref(roptions, sym_min_similarity))) {
+            a->min_sim = (float)NUM2DBL(v);
+        }
+        if (Qnil != (v = rb_hash_aref(roptions, sym_max_terms))) {
+            a->max_terms = FIX2INT(v);
+        }
+    }
+
+    if (a->min_sim >= 1.0f) {
+        rb_raise(rb_eArgError, "%f >= 1.0. :min_similarity must be < 1.0", a->min_sim);
+    } else if (a->min_sim < 0.0f) {
+        rb_raise(rb_eArgError, "%f < 0.0. :min_similarity must be > 0.0", a->min_sim);
+    }
+    if (a->pre_len < 0) {
+        rb_raise(rb_eArgError, "%d < 0. :prefix_length must be >= 0", a->pre_len);
+    }
+    if (a->max_terms < 0) {
+        rb_raise(rb_eArgError, "%d < 0. :max_terms must be >= 0", a->max_terms);
+    }
+
+    a->field = frb_field(rfield);
+    a->term = StringValuePtr(rterm);
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     FuzzyQuery.new(field, term, options = {}) -> fuzzy-query
@@ -1407,53 +1635,13 @@ frb_wcq_init(int argc, VALUE *argv, VALUE self)
  *                    not usually a problem with FuzzyQueries unless you set
  *                    +:min_similarity+ to a very low value.
  */
-static VALUE
-frb_fq_init(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_fq_init(int argc, VALUE *argv, VALUE self) {
+    frb_fq_args args = { .self = self, .argc = argc, .argv = argv };
+    rb_rescue(frb_fq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
     FrtQuery *q;
-    VALUE rfield, rterm, roptions;
-    float min_sim =
-        (float)NUM2DBL(rb_cvar_get(cFuzzyQuery, id_default_min_similarity));
-    int pre_len =
-        FIX2INT(rb_cvar_get(cFuzzyQuery, id_default_prefix_length));
-    int max_terms =
-        FIX2INT(rb_cvar_get(cMultiTermQuery, id_default_max_terms));
-
-
-    if (rb_scan_args(argc, argv, "21", &rfield, &rterm, &roptions) >= 3) {
-        VALUE v;
-        Check_Type(roptions, T_HASH);
-        if (Qnil != (v = rb_hash_aref(roptions, sym_prefix_length))) {
-            pre_len = FIX2INT(v);
-        }
-        if (Qnil != (v = rb_hash_aref(roptions, sym_min_similarity))) {
-            min_sim = (float)NUM2DBL(v);
-        }
-        if (Qnil != (v = rb_hash_aref(roptions, sym_max_terms))) {
-            max_terms = FIX2INT(v);
-        }
-    }
-
-    if (min_sim >= 1.0f) {
-        rb_raise(rb_eArgError,
-                 "%f >= 1.0. :min_similarity must be < 1.0", min_sim);
-    } else if (min_sim < 0.0f) {
-        rb_raise(rb_eArgError,
-                 "%f < 0.0. :min_similarity must be > 0.0", min_sim);
-    }
-    if (pre_len < 0) {
-        rb_raise(rb_eArgError,
-                 "%d < 0. :prefix_length must be >= 0", pre_len);
-    }
-    if (max_terms < 0) {
-        rb_raise(rb_eArgError,
-                 "%d < 0. :max_terms must be >= 0", max_terms);
-    }
-
-    q = frt_fuzq_new_conf(frb_field(rfield), StringValuePtr(rterm),
-                      min_sim, pre_len, max_terms);
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+    TypedData_Get_Struct(self, FrtQuery, &frb_fuzzy_query_t, q);
+    frt_fuzq_init_conf(q, args.field, args.term, args.min_sim, args.pre_len, args.max_terms);
+    q->rquery = self;
     return self;
 }
 
@@ -1464,9 +1652,8 @@ frb_fq_init(int argc, VALUE *argv, VALUE self)
  *  Get the +:prefix_length+ for the query.
  */
 static VALUE
-frb_fq_pre_len(VALUE self)
-{
-    GET_Q();
+frb_fq_pre_len(VALUE self) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     return INT2FIX(((FrtFuzzyQuery *)q)->pre_len);
 }
 
@@ -1477,9 +1664,8 @@ frb_fq_pre_len(VALUE self)
  *  Get the +:min_similarity+ for the query.
  */
 static VALUE
-frb_fq_min_sim(VALUE self)
-{
-    GET_Q();
+frb_fq_min_sim(VALUE self) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
     return rb_float_new((double)((FrtFuzzyQuery *)q)->min_sim);
 }
 
@@ -1490,8 +1676,7 @@ frb_fq_min_sim(VALUE self)
  *  Get the default value for +:min_similarity+
  */
 static VALUE
-frb_fq_get_dms(VALUE self)
-{
+frb_fq_get_dms(VALUE self) {
     return rb_cvar_get(cFuzzyQuery, id_default_min_similarity);
 }
 
@@ -1557,13 +1742,28 @@ frb_fq_set_dpl(VALUE self, VALUE val)
  *
  ****************************************************************************/
 
-static VALUE
-frb_maq_alloc(VALUE klass)
-{
+static size_t frb_match_all_query_size(const void *p) {
+    return sizeof(FrtQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_match_all_query_t = {
+    .wrap_struct_name = "FrbMatchAllQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_match_all_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_maq_alloc(VALUE rclass) {
     FrtQuery *q = frt_maq_new();
-    VALUE self = Data_Wrap_Struct(klass, NULL, &frb_q_free, q);
-    object_add(q, self);
-    return self;
+    return TypedData_Wrap_Struct(rclass, &frb_match_all_query_t, q);
 }
 
 /*
@@ -1572,9 +1772,10 @@ frb_maq_alloc(VALUE klass)
  *
  *  Create a query which matches all documents.
  */
-static VALUE
-frb_maq_init(VALUE self)
-{
+static VALUE frb_maq_init(VALUE self) {
+    FrtQuery *q;
+    TypedData_Get_Struct(self, FrtQuery, &frb_match_all_query_t, q);
+    q->rquery = self;
     return self;
 }
 
@@ -1584,6 +1785,30 @@ frb_maq_init(VALUE self)
  *
  ****************************************************************************/
 
+static size_t frb_constant_score_query_size(const void *p) {
+    return sizeof(FrtConstantScoreQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_constant_score_query_t = {
+    .wrap_struct_name = "FrbConstantScoreQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_constant_score_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_csq_alloc(VALUE rclass) {
+    FrtQuery *csq = frt_csq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_constant_score_query_t, csq);
+}
+
 /*
  *  call-seq:
  *     ConstantScoreQuery.new(filter) -> query
@@ -1591,16 +1816,12 @@ frb_maq_init(VALUE self)
  *  Create a ConstantScoreQuery which uses +filter+ to match documents giving
  *  each document a constant score.
  */
-static VALUE
-frb_csq_init(VALUE self, VALUE rfilter)
-{
+static VALUE frb_csq_init(VALUE self, VALUE rfilter) {
     FrtQuery *q;
-    FrtFilter *filter;
-    Data_Get_Struct(rfilter, FrtFilter, filter);
-    q = frt_csq_new(filter);
-
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+    FrtFilter *filter = DATA_PTR(rfilter);
+    TypedData_Get_Struct(self, FrtQuery, &frb_constant_score_query_t, q);
+    frt_csq_init(q, filter);
+    q->rquery = self;
     return self;
 }
 
@@ -1610,12 +1831,36 @@ frb_csq_init(VALUE self, VALUE rfilter)
  *
  ****************************************************************************/
 
-static void
-frb_fqq_mark(void *p)
-{
+static size_t frb_filtered_query_size(const void *p) {
+    return sizeof(FrtFilteredQuery);
+    (void)p;
+}
+
+static void frb_fqq_mark(void *p) {
     FrtFilteredQuery *fq = (FrtFilteredQuery *)p;
-    frb_gc_mark(fq->query);
-    frb_gc_mark(fq->filter);
+    if (fq->query->rquery)
+        rb_gc_mark(fq->query->rquery);
+    if (fq->filter->rfilter)
+        rb_gc_mark(fq->filter->rfilter);
+}
+
+const rb_data_type_t frb_filtered_query_t = {
+    .wrap_struct_name = "FrbFilteredQuery",
+    .function = {
+        .dmark = frb_fqq_mark,
+        .dfree = frb_q_free,
+        .dsize = frb_filtered_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_fqq_alloc(VALUE rclass) {
+    FrtQuery *fqq = frt_fq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_filtered_query_t, fqq);
 }
 
 /*
@@ -1624,18 +1869,15 @@ frb_fqq_mark(void *p)
  *
  *  Create a new FilteredQuery which filters +query+ with +filter+.
  */
-static VALUE
-frb_fqq_init(VALUE self, VALUE rquery, VALUE rfilter)
-{
-    FrtQuery *sq, *q;
-    FrtFilter *f;
-    Data_Get_Struct(rquery, FrtQuery, sq);
-    Data_Get_Struct(rfilter, FrtFilter, f);
-    q = frt_fq_new(sq, f);
+static VALUE frb_fqq_init(VALUE self, VALUE rquery, VALUE rfilter) {
+    FrtQuery *q;
+    FrtFilter *f = DATA_PTR(rfilter);
+    FrtQuery *sq = DATA_PTR(rquery);
+    TypedData_Get_Struct(self, FrtQuery, &frb_filtered_query_t, q);
+    frt_fq_init(q, sq, f);
     FRT_REF(sq);
     FRT_REF(f);
-    Frt_Wrap_Struct(self, &frb_fqq_mark, &frb_q_free, q);
-    object_add(q, self);
+    q->rquery = self;
     return self;
 }
 
@@ -1645,6 +1887,45 @@ frb_fqq_init(VALUE self, VALUE rquery, VALUE rfilter)
  *
  ****************************************************************************/
 
+static size_t frb_span_term_query_size(const void *p) {
+    return sizeof(FrtSpanTermQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_span_term_query_t = {
+    .wrap_struct_name = "FrbSpanTermQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_span_term_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_spantq_alloc(VALUE rclass) {
+    FrtQuery *stq = frt_spantq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_span_term_query_t, stq);
+}
+
+typedef struct frb_spantq_args {
+    VALUE self;
+    VALUE rfield;
+    VALUE rterm;
+    ID    field;
+    char  *term;
+} frb_spantq_args;
+
+VALUE frb_spantq_init_2(VALUE args) {
+    frb_spantq_args *a = (frb_spantq_args *)args;
+    a->field = frb_field(a->rfield);
+    a->term = StringValuePtr(a->rterm);
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     SpanTermQuery.new(field, term) -> query
@@ -1652,12 +1933,13 @@ frb_fqq_init(VALUE self, VALUE rquery, VALUE rfilter)
  *  Create a new SpanTermQuery which matches all documents with the term
  *  +term+ in the field +field+.
  */
-static VALUE
-frb_spantq_init(VALUE self, VALUE rfield, VALUE rterm)
-{
-    FrtQuery *q = frt_spantq_new(frb_field(rfield), StringValuePtr(rterm));
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+static VALUE frb_spantq_init(VALUE self, VALUE rfield, VALUE rterm) {
+    frb_spantq_args args = { .self = self, .rfield = rfield, .rterm = rterm };
+    rb_rescue(frb_spantq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
+    FrtQuery *q;
+    TypedData_Get_Struct(self, FrtQuery, &frb_span_term_query_t, q);
+    frt_spantq_init(q, args.field, args.term);
+    q->rquery = self;
     return self;
 }
 
@@ -1667,6 +1949,42 @@ frb_spantq_init(VALUE self, VALUE rfield, VALUE rterm)
  *
  ****************************************************************************/
 
+static size_t frb_span_multi_term_query_size(const void *p) {
+    return sizeof(FrtSpanMultiTermQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_span_multi_term_query_t = {
+    .wrap_struct_name = "FrbSpanMultiTermQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_span_multi_term_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_spanmtq_alloc(VALUE rclass) {
+    FrtQuery *smtq = frt_spanmtq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_span_multi_term_query_t, smtq);
+}
+
+typedef struct frb_spanmtq_args {
+    VALUE self;
+    VALUE rfield;
+    ID    field;
+} frb_spanmtq_args;
+
+VALUE frb_spanmtq_init_2(VALUE args) {
+    frb_spanmtq_args *a = (frb_spanmtq_args *)args;
+    a->field = frb_field(a->rfield);
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     SpanMultiTermQuery.new(field, terms) -> query
@@ -1674,16 +1992,17 @@ frb_spantq_init(VALUE self, VALUE rfield, VALUE rterm)
  *  Create a new SpanMultiTermQuery which matches all documents with the terms
  *  +terms+ in the field +field+. +terms+ should be an array of Strings.
  */
-static VALUE
-frb_spanmtq_init(VALUE self, VALUE rfield, VALUE rterms)
-{
-    FrtQuery *q = frt_spanmtq_new(frb_field(rfield));
+static VALUE frb_spanmtq_init(VALUE self, VALUE rfield, VALUE rterms) {
+    frb_spanmtq_args args = { .self = self, .rfield = rfield };
+    rb_rescue(frb_spanmtq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
+    FrtQuery *q;
+    TypedData_Get_Struct(self, FrtQuery, &frb_span_multi_term_query_t, q);
+    frt_spanmtq_init(q, args.field);
     int i;
     for (i = RARRAY_LEN(rterms) - 1; i >= 0; i--) {
         frt_spanmtq_add_term(q, StringValuePtr(RARRAY_PTR(rterms)[i]));
     }
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+    q->rquery = self;
     return self;
 }
 
@@ -1693,6 +2012,51 @@ frb_spanmtq_init(VALUE self, VALUE rfield, VALUE rterms)
  *
  ****************************************************************************/
 
+static size_t frb_span_prefix_query_size(const void *p) {
+    return sizeof(FrtSpanPrefixQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_span_prefix_query_t = {
+    .wrap_struct_name = "FrbSpanPrefixQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_span_prefix_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_spanprq_alloc(VALUE rclass) {
+    FrtQuery *spq = frt_spanprq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_span_prefix_query_t, spq);
+}
+
+typedef struct frb_spanprq_args {
+    VALUE self;
+    VALUE argc;
+    VALUE *argv;
+    ID    field;
+    char  *prefix;
+    int   max_terms;
+} frb_spanprq_args;
+
+VALUE frb_spanprq_init_2(VALUE args) {
+    frb_spanprq_args *a = (frb_spanprq_args *)args;
+    VALUE rfield, rprefix, rmax_terms;
+    a->max_terms = FRT_SPAN_PREFIX_QUERY_MAX_TERMS;
+    if (rb_scan_args(a->argc, a->argv, "21", &rfield, &rprefix, &rmax_terms) == 3) {
+        a->max_terms = FIX2INT(rmax_terms);
+    }
+    a->field = frb_field(rfield);
+    a->prefix = StringValuePtr(rprefix);
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     SpanPrefixQuery.new(field, prefix, max_terms = 256) -> query
@@ -1700,19 +2064,14 @@ frb_spanmtq_init(VALUE self, VALUE rfield, VALUE rterms)
  *  Create a new SpanPrefixQuery which matches all documents with the prefix
  *  +prefix+ in the field +field+.
  */
-static VALUE
-frb_spanprq_init(int argc, VALUE *argv, VALUE self)
-{
-    VALUE rfield, rprefix, rmax_terms;
-    int max_terms = FRT_SPAN_PREFIX_QUERY_MAX_TERMS;
+static VALUE frb_spanprq_init(int argc, VALUE *argv, VALUE self) {
+    frb_spanprq_args args = { .self = self, .argc = argc, .argv = argv };
+    rb_rescue(frb_spanprq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
     FrtQuery *q;
-    if (rb_scan_args(argc, argv, "21", &rfield, &rprefix, &rmax_terms) == 3) {
-        max_terms = FIX2INT(rmax_terms);
-    }
-    q = frt_spanprq_new(frb_field(rfield), StringValuePtr(rprefix));
-    ((FrtSpanPrefixQuery *)q)->max_terms = max_terms;
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+    TypedData_Get_Struct(self, FrtQuery, &frb_span_prefix_query_t, q);
+    frt_spanprq_init(q, args.field, args.prefix);
+    ((FrtSpanPrefixQuery *)q)->max_terms = args.max_terms;
+    q->rquery = self;
     return self;
 }
 
@@ -1722,6 +2081,42 @@ frb_spanprq_init(int argc, VALUE *argv, VALUE self)
  *
  ****************************************************************************/
 
+static size_t frb_span_first_query_size(const void *p) {
+    return sizeof(FrtSpanFirstQuery);
+    (void)p;
+}
+
+const rb_data_type_t frb_span_first_query_t = {
+    .wrap_struct_name = "FrbSpanFirstQuery",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_q_free,
+        .dsize = frb_span_first_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_spanfq_alloc(VALUE rclass) {
+    FrtQuery *sfq = frt_spanfq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_span_first_query_t, sfq);
+}
+
+typedef struct frb_spanfq_args {
+    VALUE self;
+    VALUE rend;
+    int end;
+} frb_spanfq_args;
+
+VALUE frb_spanfq_init_2(VALUE args) {
+    frb_spanfq_args *a = (frb_spanfq_args *)args;
+    a->end = FIX2INT(a->rend);
+    return Qnil;
+}
+
 /*
  *  call-seq:
  *     SpanFirstQuery.new(span_query, end) -> query
@@ -1730,15 +2125,14 @@ frb_spanprq_init(int argc, VALUE *argv, VALUE self)
  *  matches before +end+ where +end+ is a byte-offset from the start of the
  *  field
  */
-static VALUE
-frb_spanfq_init(VALUE self, VALUE rmatch, VALUE rend)
-{
+static VALUE frb_spanfq_init(VALUE self, VALUE rmatch, VALUE rend) {
+    frb_spanfq_args args = { .self = self, .rend = rend };
+    rb_rescue(frb_spanfq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
     FrtQuery *q;
-    FrtQuery *match;
-    Data_Get_Struct(rmatch, FrtQuery, match);
-    q = frt_spanfq_new(match, FIX2INT(rend));
-    Frt_Wrap_Struct(self, NULL, &frb_q_free, q);
-    object_add(q, self);
+    FrtQuery *match = DATA_PTR(rmatch);
+    TypedData_Get_Struct(self, FrtQuery, &frb_span_first_query_t, q);
+    frt_spanfq_init(q, match, args.end);
+    q->rquery = self;
     return self;
 }
 
@@ -1748,14 +2142,62 @@ frb_spanfq_init(VALUE self, VALUE rmatch, VALUE rend)
  *
  ****************************************************************************/
 
-static void
-frb_spannq_mark(void *p)
-{
+static size_t frb_span_near_query_size(const void *p) {
+    return sizeof(FrtSpanNearQuery);
+    (void)p;
+}
+
+static void frb_spannq_mark(void *p) {
     int i;
     FrtSpanNearQuery *snq = (FrtSpanNearQuery *)p;
     for (i = 0; i < snq->c_cnt; i++) {
-        frb_gc_mark(snq->clauses[i]);
+        if (snq->clauses[i]->rquery)
+            rb_gc_mark(snq->clauses[i]->rquery);
+    }
+}
+
+const rb_data_type_t frb_span_near_query_t = {
+    .wrap_struct_name = "FrbSpanNearQuery",
+    .function = {
+        .dmark = frb_spannq_mark,
+        .dfree = frb_q_free,
+        .dsize = frb_span_near_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_spannq_alloc(VALUE rclass) {
+    FrtQuery *snq = frt_spannq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_span_near_query_t, snq);
+}
+
+typedef struct frb_spannq_args {
+    VALUE self;
+    VALUE argc;
+    VALUE *argv;
+    int slop;
+    bool in_order;
+} frb_spannq_args;
+
+VALUE frb_spannq_init_2(VALUE args) {
+    frb_spannq_args *a = (frb_spannq_args *)args;
+    VALUE roptions = Qnil;
+    a->slop = 0;
+    a->in_order = false;
+    if (rb_scan_args(a->argc, a->argv, "01", &roptions) > 0) {
+        VALUE v;
+        if (Qnil != (v = rb_hash_aref(roptions, sym_slop))) {
+            a->slop = FIX2INT(v);
+        }
+        if (Qnil != (v = rb_hash_aref(roptions, sym_in_order))) {
+            a->in_order = RTEST(v);
+        }
     }
+    return roptions;
 }
 
 /*
@@ -1780,24 +2222,12 @@ frb_spannq_mark(void *p)
  *              occur in the order they were added to the query. When slop is
  *              set to 0, this parameter will make no difference.
  */
-static VALUE
-frb_spannq_init(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_spannq_init(int argc, VALUE *argv, VALUE self) {
+    frb_spannq_args args = { .self = self, .argc = argc, .argv = argv };
+    VALUE roptions = rb_rescue(frb_spannq_init_2, (VALUE)&args, frb_q_init_r, (VALUE)&args);
     FrtQuery *q;
-    VALUE roptions;
-    int slop = 0;
-    bool in_order = false;
-
-    if (rb_scan_args(argc, argv, "01", &roptions) > 0) {
-        VALUE v;
-        if (Qnil != (v = rb_hash_aref(roptions, sym_slop))) {
-            slop = FIX2INT(v);
-        }
-        if (Qnil != (v = rb_hash_aref(roptions, sym_in_order))) {
-            in_order = RTEST(v);
-        }
-    }
-    q = frt_spannq_new(slop, in_order);
+    TypedData_Get_Struct(self, FrtQuery, &frb_span_near_query_t, q);
+    frt_spannq_init(q, args.slop, args.in_order);
     if (argc > 0) {
         VALUE v;
         if (Qnil != (v = rb_hash_aref(roptions, sym_clauses))) {
@@ -1805,14 +2235,12 @@ frb_spannq_init(int argc, VALUE *argv, VALUE self)
             FrtQuery *clause;
             Check_Type(v, T_ARRAY);
             for (i = 0; i < RARRAY_LEN(v); i++) {
-                Data_Get_Struct(RARRAY_PTR(v)[i], FrtQuery, clause);
+                clause = DATA_PTR(RARRAY_PTR(v)[i]);
                 frt_spannq_add_clause(q, clause);
             }
         }
     }
-
-    Frt_Wrap_Struct(self, &frb_spannq_mark, &frb_q_free, q);
-    object_add(q, self);
+    q->rquery = self;
     return self;
 }
 
@@ -1825,12 +2253,9 @@ frb_spannq_init(int argc, VALUE *argv, VALUE self)
  *  are added to the query which is important for matching. Note that clauses
  *  must be SpanQueries, not other types of query.
  */
-static VALUE
-frb_spannq_add(VALUE self, VALUE rclause)
-{
-    GET_Q();
-    FrtQuery *clause;
-    Data_Get_Struct(rclause, FrtQuery, clause);
+static VALUE frb_spannq_add(VALUE self, VALUE rclause) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
+    FrtQuery *clause = DATA_PTR(rclause);
     frt_spannq_add_clause(q, clause);
     return self;
 }
@@ -1841,16 +2266,39 @@ frb_spannq_add(VALUE self, VALUE rclause)
  *
  ****************************************************************************/
 
-static void
-frb_spanoq_mark(void *p)
-{
+static size_t frb_span_or_query_size(const void *p) {
+    return sizeof(FrtSpanOrQuery);
+    (void)p;
+}
+
+static void frb_spanoq_mark(void *p) {
     int i;
     FrtSpanOrQuery *soq = (FrtSpanOrQuery *)p;
     for (i = 0; i < soq->c_cnt; i++) {
-        frb_gc_mark(soq->clauses[i]);
+        if (soq->clauses[i]->rquery)
+            rb_gc_mark(soq->clauses[i]->rquery);
     }
 }
 
+const rb_data_type_t frb_span_or_query_t = {
+    .wrap_struct_name = "FrbSpanOrQuery",
+    .function = {
+        .dmark = frb_spanoq_mark,
+        .dfree = frb_q_free,
+        .dsize = frb_span_or_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_spanoq_alloc(VALUE rclass) {
+    FrtQuery *soq = frt_spanoq_new();
+    return TypedData_Wrap_Struct(rclass, &frb_span_or_query_t, soq);
+}
+
 /*
  *  call-seq:
  *     SpanOrQuery.new(options = {}) -> query
@@ -1859,24 +2307,20 @@ frb_spanoq_mark(void *p)
  *  clauses with the occur value of :should. The difference is that it can be
  *  passed to other SpanQuerys like SpanNearQuery.
  */
-static VALUE
-frb_spanoq_init(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_spanoq_init(int argc, VALUE *argv, VALUE self) {
     FrtQuery *q;
     VALUE rclauses;
-
-    q = frt_spanoq_new();
+    TypedData_Get_Struct(self, FrtQuery, &frb_span_or_query_t, q);
     if (rb_scan_args(argc, argv, "01", &rclauses) > 0) {
         int i;
         FrtQuery *clause;
         Check_Type(rclauses, T_ARRAY);
         for (i = 0; i < RARRAY_LEN(rclauses); i++) {
-            Data_Get_Struct(RARRAY_PTR(rclauses)[i], FrtQuery, clause);
+            clause = DATA_PTR(RARRAY_PTR(rclauses)[i]);
             frt_spanoq_add_clause(q, clause);
         }
     }
-    Frt_Wrap_Struct(self, &frb_spanoq_mark, &frb_q_free, q);
-    object_add(q, self);
+    q->rquery = self;
     return self;
 }
 
@@ -1888,12 +2332,9 @@ frb_spanoq_init(int argc, VALUE *argv, VALUE self)
  *  Add a clause to the SpanOrQuery. Note that clauses must be SpanQueries,
  *  not other types of query.
  */
-static VALUE
-frb_spanoq_add(VALUE self, VALUE rclause)
-{
-    GET_Q();
-    FrtQuery *clause;
-    Data_Get_Struct(rclause, FrtQuery, clause);
+static VALUE frb_spanoq_add(VALUE self, VALUE rclause) {
+    FrtQuery *q = (FrtQuery *)DATA_PTR(self);
+    FrtQuery *clause = DATA_PTR(rclause);
     frt_spanoq_add_clause(q, clause);
     return self;
 }
@@ -1904,12 +2345,36 @@ frb_spanoq_add(VALUE self, VALUE rclause)
  *
  ****************************************************************************/
 
-static void
-frb_spanxq_mark(void *p)
-{
+static size_t frb_span_not_query_size(const void *p) {
+    return sizeof(FrtSpanNotQuery);
+    (void)p;
+}
+
+static void frb_spanxq_mark(void *p) {
     FrtSpanNotQuery *sxq = (FrtSpanNotQuery *)p;
-    frb_gc_mark(sxq->inc);
-    frb_gc_mark(sxq->exc);
+    if (sxq->inc->rquery)
+        rb_gc_mark(sxq->inc->rquery);
+    if (sxq->exc->rquery)
+        rb_gc_mark(sxq->exc->rquery);
+}
+
+const rb_data_type_t frb_span_not_query_t = {
+    .wrap_struct_name = "FrbSpanNotQuery",
+    .function = {
+        .dmark = frb_spanxq_mark,
+        .dfree = frb_q_free,
+        .dsize = frb_span_not_query_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_spanxq_alloc(VALUE rclass) {
+    FrtQuery *snq = frt_spanxq_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_span_not_query_t, snq);
 }
 
 /*
@@ -1919,15 +2384,13 @@ frb_spanxq_mark(void *p)
  *  Create a new SpanNotQuery which matches all documents which match
  *  +include_query+ and don't match +exclude_query+.
  */
-static VALUE
-frb_spanxq_init(VALUE self, VALUE rinc, VALUE rexc)
-{
+static VALUE frb_spanxq_init(VALUE self, VALUE rinc, VALUE rexc) {
     FrtQuery *q;
-    Check_Type(rinc, T_DATA);
-    Check_Type(rexc, T_DATA);
-    q = frt_spanxq_new(DATA_PTR(rinc), DATA_PTR(rexc));
-    Frt_Wrap_Struct(self, &frb_spanxq_mark, &frb_q_free, q);
-    object_add(q, self);
+    //Check_Type(rinc, T_DATA);
+    //Check_Type(rexc, T_DATA);
+    TypedData_Get_Struct(self, FrtQuery, &frb_span_not_query_t, q);
+    frt_spanxq_init(q, DATA_PTR(rinc), DATA_PTR(rexc));
+    q->rquery = self;
     return self;
 }
 
@@ -1937,10 +2400,7 @@ frb_spanxq_init(VALUE self, VALUE rinc, VALUE rexc)
  *
  ****************************************************************************/
 
-static void
-frb_f_free(void *p)
-{
-    object_del(p);
+static void frb_f_free(void *p) {
     frt_filt_deref((FrtFilter *)p);
 }
 
@@ -1953,9 +2413,7 @@ frb_f_free(void *p)
  *  Return a human readable string representing the Filter object that the
  *  method was called on.
  */
-static VALUE
-frb_f_to_s(VALUE self)
-{
+static VALUE frb_f_to_s(VALUE self) {
     VALUE rstr;
     char *str;
     GET_F();
@@ -1974,13 +2432,11 @@ extern VALUE frb_get_bv(FrtBitVector *bv);
  *  Get the bit_vector used by this filter. This method will usually be used
  *  to group filters or apply filters to other filters.
  */
-static VALUE
-frb_f_get_bits(VALUE self, VALUE rindex_reader)
-{
+static VALUE frb_f_get_bits(VALUE self, VALUE rindex_reader) {
     FrtBitVector *bv;
     FrtIndexReader *ir;
     GET_F();
-    Data_Get_Struct(rindex_reader, FrtIndexReader, ir);
+    TypedData_Get_Struct(rindex_reader, FrtIndexReader, &frb_index_reader_t, ir);
     bv = frt_filt_get_bv(f, ir);
     return frb_get_bv(bv);
 }
@@ -1991,6 +2447,29 @@ frb_f_get_bits(VALUE self, VALUE rindex_reader)
  *
  ****************************************************************************/
 
+static size_t frb_range_filter_size(const void *p) {
+    return sizeof(FrtRangeFilter);
+    (void)p;
+}
+
+const rb_data_type_t frb_range_filter_t = {
+    .wrap_struct_name = "FrbRangeFilter",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_f_free,
+        .dsize = frb_range_filter_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_rf_alloc(VALUE rclass) {
+    FrtFilter *rf = frt_rfilt_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_range_filter_t, rf);
+}
 
 /*
  *  call-seq:
@@ -2014,21 +2493,21 @@ frb_f_get_bits(VALUE self, VALUE rindex_reader)
  *    # is equivalent to
  *    f = RangeFilter.new(:date, :>= => "200501", :<= => 200502)
  */
-static VALUE
-frb_rf_init(VALUE self, VALUE rfield, VALUE roptions)
-{
-    FrtFilter *f;
-    char *lterm = NULL;
-    char *uterm = NULL;
-    bool include_lower = false;
-    bool include_upper = false;
+static VALUE frb_rf_init(VALUE self, VALUE rfield, VALUE roptions) {
     int ex_code = 0;
     const char *msg = NULL;
-    get_range_params(roptions, &lterm, &uterm, &include_lower, &include_upper);
+    frb_rq_args a = { .self = self, .rfield = rfield, .roptions = roptions };
+    rb_rescue(frb_rq_init_2, (VALUE)&a, frb_q_init_r, (VALUE)&a);
+    FrtFilter *f;
+    TypedData_Get_Struct(self, FrtFilter, &frb_range_filter_t, f);
     FRT_TRY
-        f = frt_rfilt_new(frb_field(rfield), lterm, uterm, include_lower, include_upper);
-        break;
-    default:
+        frt_rfilt_init(f, a.field, a.lterm, a.uterm, a.include_lower, a.include_upper);
+        f->rfilter = self;
+    FRT_XCATCHALL
+        ((struct RData *)(self))->data = NULL;
+        ((struct RData *)(self))->dmark = NULL;
+        ((struct RData *)(self))->dfree = NULL;
+        free(f);
         ex_code = xcontext.excode;
         msg = xcontext.msg;
         FRT_HANDLED();
@@ -2036,8 +2515,6 @@ frb_rf_init(VALUE self, VALUE rfield, VALUE roptions)
 
     if (ex_code && msg) { frb_raise(ex_code, msg); }
 
-    Frt_Wrap_Struct(self, NULL, &frb_f_free, f);
-    object_add(f, self);
     return self;
 }
 
@@ -2047,6 +2524,29 @@ frb_rf_init(VALUE self, VALUE rfield, VALUE roptions)
  *
  ****************************************************************************/
 
+static size_t frb_typed_range_filter_size(const void *p) {
+    return sizeof(FrtRangeFilter);
+    (void)p;
+}
+
+const rb_data_type_t frb_typed_range_filter_t = {
+    .wrap_struct_name = "FrbTypedRangeFilter",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_f_free,
+        .dsize = frb_typed_range_filter_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_trf_alloc(VALUE rclass) {
+    FrtFilter *f = frt_trfilt_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_typed_range_filter_t, f);
+}
 
 /*
  *  call-seq:
@@ -2071,20 +2571,28 @@ frb_rf_init(VALUE self, VALUE rfield, VALUE roptions)
  *    # is equivalent to
  *    f = TypedRangeFilter.new(:date, :>= => "-132.2", :<= => -1.4)
  */
-static VALUE
-frb_trf_init(VALUE self, VALUE rfield, VALUE roptions)
-{
+static VALUE frb_trf_init(VALUE self, VALUE rfield, VALUE roptions) {
+    int ex_code = 0;
+    const char *msg = NULL;
+    frb_rq_args a = { .self = self, .rfield = rfield, .roptions = roptions };
+    rb_rescue(frb_rq_init_2, (VALUE)&a, frb_q_init_r, (VALUE)&a);
     FrtFilter *f;
-    char *lterm = NULL;
-    char *uterm = NULL;
-    bool include_lower = false;
-    bool include_upper = false;
-
-    get_range_params(roptions, &lterm, &uterm, &include_lower, &include_upper);
-    f = frt_trfilt_new(frb_field(rfield), lterm, uterm,
-                   include_lower, include_upper);
-    Frt_Wrap_Struct(self, NULL, &frb_f_free, f);
-    object_add(f, self);
+    TypedData_Get_Struct(self, FrtFilter, &frb_typed_range_filter_t, f);
+    FRT_TRY
+        frt_trfilt_init(f, a.field, a.lterm, a.uterm, a.include_lower, a.include_upper);
+        f->rfilter = self;
+    FRT_XCATCHALL
+        ((struct RData *)(self))->data = NULL;
+        ((struct RData *)(self))->dmark = NULL;
+        ((struct RData *)(self))->dfree = NULL;
+        free(f);
+        ex_code = xcontext.excode;
+        msg = xcontext.msg;
+        FRT_HANDLED();
+    FRT_XENDTRY
+
+    if (ex_code && msg) { frb_raise(ex_code, msg); }
+
     return self;
 }
 
@@ -2094,21 +2602,42 @@ frb_trf_init(VALUE self, VALUE rfield, VALUE roptions)
  *
  ****************************************************************************/
 
+static size_t frb_query_filter_size(const void *p) {
+    return sizeof(FrtQueryFilter);
+    (void)p;
+}
+
+const rb_data_type_t frb_query_filter_t = {
+    .wrap_struct_name = "FrbQueryFilter",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_f_free,
+        .dsize = frb_query_filter_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_qf_alloc(VALUE rclass) {
+    FrtFilter *qf = frt_qfilt_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_query_filter_t, qf);
+}
+
 /*
  *  call-seq:
  *     QueryFilter.new(query) -> filter
  *
  *  Create a new QueryFilter which applies the query +query+.
  */
-static VALUE
-frb_qf_init(VALUE self, VALUE rquery)
-{
-    FrtQuery *q;
+static VALUE frb_qf_init(VALUE self, VALUE rquery) {
+    FrtQuery *q = DATA_PTR(rquery);
     FrtFilter *f;
-    Data_Get_Struct(rquery, FrtQuery, q);
-    f = frt_qfilt_new(q);
-    Frt_Wrap_Struct(self, NULL, &frb_f_free, f);
-    object_add(f, self);
+    TypedData_Get_Struct(self, FrtFilter, &frb_query_filter_t, f);
+    frt_qfilt_init(f, q);
+    f->rfilter = self;
     return self;
 }
 
@@ -2118,27 +2647,42 @@ frb_qf_init(VALUE self, VALUE rquery)
  *
  ****************************************************************************/
 
-static void
-frb_sf_free(void *p)
-{
-    object_del(p);
+static size_t frb_sort_field_size(const void *p) {
+    return sizeof(FrtSortField);
+    (void)p;
+}
+
+static void frb_sf_free(void *p) {
     frt_sort_field_destroy((FrtSortField *)p);
 }
 
-static VALUE
-frb_get_sf(FrtSortField *sf)
-{
-    VALUE self = object_get(sf);
-    if (self == Qnil) {
-        self = Data_Wrap_Struct(cSortField, NULL, &frb_sf_free, sf);
-        object_add(sf, self);
+const rb_data_type_t frb_sort_field_t = {
+    .wrap_struct_name = "FrbSortField",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_sf_free,
+        .dsize = frb_sort_field_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_sf_alloc(VALUE rclass) {
+    FrtSortField *sf = frt_sort_field_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_sort_field_t, sf);
+}
+
+static VALUE frb_get_sf(FrtSortField *sf) {
+    if (sf->rfield == 0 || sf->rfield == Qnil) {
+        sf->rfield = TypedData_Wrap_Struct(cSortField, &frb_sort_field_t, sf);
     }
-    return self;
+    return sf->rfield;
 }
 
-static int
-get_sort_type(VALUE rtype)
-{
+static int get_sort_type(VALUE rtype) {
     Check_Type(rtype, T_SYMBOL);
     if (rtype == sym_byte) {
         return FRT_SORT_TYPE_BYTE;
@@ -2182,16 +2726,14 @@ get_sort_type(VALUE rtype)
  *  :reverse        Default: false. Set to true if you want to reverse the
  *                  sort.
  */
-static VALUE
-frb_sf_init(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_sf_init(int argc, VALUE *argv, VALUE self) {
     FrtSortField *sf;
     VALUE rfield, roptions;
     VALUE rval;
     int type = FRT_SORT_TYPE_AUTO;
     int is_reverse = false;
-    FrtSymbol field;
-
+    ID field;
+    TypedData_Get_Struct(self, FrtSortField, &frb_sort_field_t, sf);
     if (rb_scan_args(argc, argv, "11", &rfield, &roptions) == 2) {
         if (Qnil != (rval = rb_hash_aref(roptions, sym_type))) {
             type = get_sort_type(rval);
@@ -2206,13 +2748,11 @@ frb_sf_init(int argc, VALUE *argv, VALUE self)
     if (NIL_P(rfield)) rb_raise(rb_eArgError, "must pass a valid field name");
     field = frb_field(rfield);
 
-    sf = frt_sort_field_new(field, type, is_reverse);
-    if (sf->field == (FrtSymbol)NULL) {
+    frt_sort_field_init(sf, field, type, is_reverse);
+    if (sf->field == (ID)NULL) {
         sf->field = field;
     }
-
-    Frt_Wrap_Struct(self, NULL, &frb_sf_free, sf);
-    object_add(sf, self);
+    sf->rfield = self;
     return self;
 }
 
@@ -2225,9 +2765,7 @@ frb_sf_init(int argc, VALUE *argv, VALUE self)
  *  Return true if the field is to be reverse sorted. This attribute is set
  *  when you create the sort_field.
  */
-static VALUE
-frb_sf_is_reverse(VALUE self)
-{
+static VALUE frb_sf_is_reverse(VALUE self) {
     GET_SF();
     return sf->reverse ? Qtrue : Qfalse;
 }
@@ -2238,9 +2776,7 @@ frb_sf_is_reverse(VALUE self)
  *
  *  Returns the name of the field to be sorted.
  */
-static VALUE
-frb_sf_get_name(VALUE self)
-{
+static VALUE frb_sf_get_name(VALUE self) {
     GET_SF();
     return sf->field ? ID2SYM(sf->field) : Qnil;
 }
@@ -2252,9 +2788,7 @@ frb_sf_get_name(VALUE self)
  *  Return the type of sort. Should be one of; +:auto+, +:integer+, +:float+,
  *  +:string+, +:byte+, +:doc_id+ or +:score+.
  */
-static VALUE
-frb_sf_get_type(VALUE self)
-{
+static VALUE frb_sf_get_type(VALUE self) {
     GET_SF();
     switch (sf->type) {
         case FRT_SORT_TYPE_BYTE:    return sym_byte;
@@ -2274,9 +2808,7 @@ frb_sf_get_type(VALUE self)
  *
  *  TODO: currently unsupported
  */
-static VALUE
-frb_sf_get_comparator(VALUE self)
-{
+static VALUE frb_sf_get_comparator(VALUE self) {
     return Qnil;
 }
 
@@ -2286,9 +2818,7 @@ frb_sf_get_comparator(VALUE self)
  *
  *  Return a human readable string describing this +sort_field+.
  */
-static VALUE
-frb_sf_to_s(VALUE self)
-{
+static VALUE frb_sf_to_s(VALUE self) {
     GET_SF();
     char *str = frt_sort_field_to_s(sf);
     VALUE rstr = rb_str_new2(str);
@@ -2302,38 +2832,47 @@ frb_sf_to_s(VALUE self)
  *
  ****************************************************************************/
 
-static void
-frb_sort_free(void *p)
-{
-    FrtSort *sort = (FrtSort *)p;
-    object_del(sort);
-    frt_sort_destroy(sort);
+static size_t frb_sort_size(const void *p) {
+    return sizeof(FrtSort);
+    (void)p;
 }
 
-static void
-frb_sort_mark(void *p)
-{
+static void frb_sort_free(void *p) {
+    frt_sort_destroy((FrtSort *)p);
+}
+
+static void frb_sort_mark(void *p) {
     FrtSort *sort = (FrtSort *)p;
     int i;
     for (i = 0; i < sort->size; i++) {
-        frb_gc_mark(sort->sort_fields[i]);
+        if (sort->sort_fields[i]->rfield)
+            rb_gc_mark(sort->sort_fields[i]->rfield);
     }
 }
 
-static VALUE
-frb_sort_alloc(VALUE klass)
-{
+const rb_data_type_t frb_sort_t = {
+    .wrap_struct_name = "FrbSort",
+    .function = {
+        .dmark = frb_sort_mark,
+        .dfree = frb_sort_free,
+        .dsize = frb_sort_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_sort_alloc(VALUE klass) {
     VALUE self;
     FrtSort *sort = frt_sort_new();
     sort->destroy_all = false;
-    self = Data_Wrap_Struct(klass, &frb_sort_mark, &frb_sort_free, sort);
-    object_add(sort, self);
+    self = TypedData_Wrap_Struct(klass, &frb_sort_t, sort);
     return self;
 }
 
-static void
-frb_parse_sort_str(FrtSort *sort, char *xsort_str)
-{
+static void frb_parse_sort_str(FrtSort *sort, char *xsort_str) {
     FrtSortField *sf;
     char *comma, *end, *e, *s;
     const int len = strlen(xsort_str);
@@ -2373,13 +2912,11 @@ frb_parse_sort_str(FrtSort *sort, char *xsort_str)
     free(sort_str);
 }
 
-static void
-frb_sort_add(FrtSort *sort, VALUE rsf, bool reverse)
-{
+static void frb_sort_add(FrtSort *sort, VALUE rsf, bool reverse) {
     FrtSortField *sf;
     switch (TYPE(rsf)) {
         case T_DATA:
-            Data_Get_Struct(rsf, FrtSortField, sf);
+            TypedData_Get_Struct(rsf, FrtSortField, &frb_sort_field_t, sf);
             if (reverse) sf->reverse = !sf->reverse;
             frt_sort_add_sort_field(sort, sf);
             break;
@@ -2408,9 +2945,7 @@ frb_sort_add(FrtSort *sort, VALUE rsf, bool reverse)
  *  reversed so if any of them are already reversed the  will be turned back
  *  to their natural order again. By default
  */
-static VALUE
-frb_sort_init(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_sort_init(int argc, VALUE *argv, VALUE self) {
     int i;
     VALUE rfields, rreverse;
     bool reverse = false;
@@ -2428,15 +2963,15 @@ frb_sort_init(int argc, VALUE *argv, VALUE self)
                     frb_sort_add(sort, rfields, reverse);
                 }
                 for (i = 0; i < sort->size; i++) {
-                    if (sort->sort_fields[i] == &FRT_SORT_FIELD_DOC) has_sfd = true;
+                    if (sort->sort_fields[i] == FRT_SORT_FIELD_DOC) has_sfd = true;
                 }
                 if (!has_sfd) {
-                    frt_sort_add_sort_field(sort, (FrtSortField *)&FRT_SORT_FIELD_DOC);
+                    frt_sort_add_sort_field(sort, FRT_SORT_FIELD_DOC);
                 }
                 break;
         case 0:
-                frt_sort_add_sort_field(sort, (FrtSortField *)&FRT_SORT_FIELD_SCORE);
-                frt_sort_add_sort_field(sort, (FrtSortField *)&FRT_SORT_FIELD_DOC);
+                frt_sort_add_sort_field(sort, FRT_SORT_FIELD_SCORE);
+                frt_sort_add_sort_field(sort, FRT_SORT_FIELD_DOC);
     }
 
     return self;
@@ -2448,28 +2983,23 @@ frb_sort_init(int argc, VALUE *argv, VALUE self)
  *
  *  Returns an array of the SortFields held by the Sort object.
  */
-static VALUE
-frb_sort_get_fields(VALUE self)
-{
+static VALUE frb_sort_get_fields(VALUE self) {
     GET_SORT();
     VALUE rfields = rb_ary_new2(sort->size);
     int i;
     for (i = 0; i < sort->size; i++) {
-        rb_ary_store(rfields, i, object_get(sort->sort_fields[i]));
+        rb_ary_store(rfields, i, sort->sort_fields[i]->rfield);
     }
     return rfields;
 }
 
-
 /*
  *  call-seq:
  *     sort.to_s -> string
  *
  *  Returns a human readable string representing the sort object.
  */
-static VALUE
-frb_sort_to_s(VALUE self)
-{
+static VALUE frb_sort_to_s(VALUE self) {
     GET_SORT();
     char *str = frt_sort_to_s(sort);
     VALUE rstr = rb_str_new2(str);
@@ -2483,11 +3013,8 @@ frb_sort_to_s(VALUE self)
  *
  ****************************************************************************/
 
-static void
-frb_sea_free(void *p)
-{
+static void frb_sea_free(void *p) {
     FrtSearcher *sea = (FrtSearcher *)p;
-    object_del(sea);
     sea->close(sea);
 }
 
@@ -2500,12 +3027,11 @@ frb_sea_free(void *p)
  *  Close the searcher. The garbage collector will do this for you or you can
  *  call this method explicitly.
  */
-static VALUE
-frb_sea_close(VALUE self)
-{
+static VALUE frb_sea_close(VALUE self) {
     GET_SEA();
-    Frt_Unwrap_Struct(self);
-    object_del(sea);
+    ((struct RData *)(self))->data = NULL;
+    ((struct RData *)(self))->dmark = NULL;
+    ((struct RData *)(self))->dfree = NULL;
     sea->close(sea);
     return Qnil;
 }
@@ -2516,11 +3042,9 @@ frb_sea_close(VALUE self)
  *
  *  Return the IndexReader wrapped by this searcher.
  */
-static VALUE
-frb_sea_get_reader(VALUE self)
-{
+static VALUE frb_sea_get_reader(VALUE self) {
     GET_SEA();
-    return object_get(((FrtIndexSearcher *)sea)->ir);
+    return ((FrtIndexSearcher *)sea)->ir->rir;
 }
 
 /*
@@ -2530,13 +3054,9 @@ frb_sea_get_reader(VALUE self)
  *  Return the number of documents in which the term +term+ appears in the
  *  field +field+.
  */
-static VALUE
-frb_sea_doc_freq(VALUE self, VALUE rfield, VALUE rterm)
-{
+static VALUE frb_sea_doc_freq(VALUE self, VALUE rfield, VALUE rterm) {
     GET_SEA();
-    return INT2FIX(sea->doc_freq(sea,
-                                 frb_field(rfield),
-                                 StringValuePtr(rterm)));
+    return INT2FIX(sea->doc_freq(sea, frb_field(rfield), StringValuePtr(rterm)));
 }
 
 /*
@@ -2548,9 +3068,7 @@ frb_sea_doc_freq(VALUE self, VALUE rfield, VALUE rterm)
  *  document returned. Documents are referenced internally by document ids
  *  which are returned by the Searchers search methods.
  */
-static VALUE
-frb_sea_doc(VALUE self, VALUE rdoc_id)
-{
+static VALUE frb_sea_doc(VALUE self, VALUE rdoc_id) {
     GET_SEA();
     return frb_get_lazy_doc(sea->get_lazy_doc(sea, FIX2INT(rdoc_id)));
 }
@@ -2564,20 +3082,13 @@ frb_sea_doc(VALUE self, VALUE rdoc_id)
  *  there are no deletions, this number also refers to the number of documents
  *  in the index.
  */
-static VALUE
-frb_sea_max_doc(VALUE self)
-{
+static VALUE frb_sea_max_doc(VALUE self) {
     GET_SEA();
     return INT2FIX(sea->max_doc(sea));
 }
 
-static float
-call_filter_proc(int doc_id, float score, FrtSearcher *self, void *arg)
-{
-    VALUE val = rb_funcall((VALUE)arg, id_call, 3,
-                           INT2FIX(doc_id),
-                           rb_float_new((double)score),
-                           object_get(self));
+static float call_filter_proc(int doc_id, float score, FrtSearcher *sea, void *arg) {
+    VALUE val = rb_funcall((VALUE)arg, id_call, 3, INT2FIX(doc_id), rb_float_new((double)score), sea->rsea);
     switch (TYPE(val)) {
         case T_NIL:
         case T_FALSE:
@@ -2592,44 +3103,35 @@ call_filter_proc(int doc_id, float score, FrtSearcher *self, void *arg)
     }
 }
 
-typedef struct CWrappedFilter
-{
+typedef struct CWrappedFilter {
     FrtFilter super;
     VALUE  rfilter;
 } CWrappedFilter;
+
 #define CWF(filt) ((CWrappedFilter *)(filt))
 
-static unsigned long long
-cwfilt_hash(FrtFilter *filt)
-{
+static unsigned long long cwfilt_hash(FrtFilter *filt) {
     return (unsigned long long)NUM2ULONG(rb_funcall(CWF(filt)->rfilter, id_hash, 0));
 }
 
-static int
-cwfilt_eq(FrtFilter *filt, FrtFilter *o)
-{
+static int cwfilt_eq(FrtFilter *filt, FrtFilter *o) {
     return RTEST(rb_funcall(CWF(filt)->rfilter, id_eql, 1, CWF(o)->rfilter));
 }
 
-static FrtBitVector *
-cwfilt_get_bv_i(FrtFilter *filt, FrtIndexReader *ir)
-{
-    VALUE rbv = rb_funcall(CWF(filt)->rfilter, id_bits, 1, object_get(ir));
+static FrtBitVector *cwfilt_get_bv_i(FrtFilter *filt, FrtIndexReader *ir) {
+    VALUE rbv = rb_funcall(CWF(filt)->rfilter, id_bits, 1, ir->rir);
     FrtBitVector *bv;
-    Data_Get_Struct(rbv, FrtBitVector, bv);
+    bv = DATA_PTR(rbv);
     FRT_REF(bv);
     return bv;
 }
 
-FrtFilter *
-frb_get_cwrapped_filter(VALUE rval)
-{
+FrtFilter *frb_get_cwrapped_filter(VALUE rval) {
     FrtFilter *filter;
     if (frb_is_cclass(rval) && DATA_PTR(rval)) {
-        Data_Get_Struct(rval, FrtFilter, filter);
+        filter = DATA_PTR(rval);
         FRT_REF(filter);
-    }
-    else {
+    } else {
         filter               = filt_new(CWrappedFilter);
         filter->hash         = &cwfilt_hash;
         filter->eq           = &cwfilt_eq;
@@ -2639,9 +3141,7 @@ frb_get_cwrapped_filter(VALUE rval)
     return filter;
 }
 
-static FrtTopDocs *
-frb_sea_search_internal(FrtQuery *query, VALUE roptions, FrtSearcher *sea)
-{
+static FrtTopDocs *frb_sea_search_internal(FrtQuery *query, VALUE roptions, FrtSearcher *sea) {
     VALUE rval;
     int offset = 0, limit = 10;
     FrtFilter *filter = NULL;
@@ -2666,11 +3166,9 @@ frb_sea_search_internal(FrtQuery *query, VALUE roptions, FrtSearcher *sea)
                 if (limit <= 0) {
                     rb_raise(rb_eArgError, ":limit must be > 0");
                 }
-            }
-            else if (rval == sym_all) {
+            } else if (rval == sym_all) {
                 limit = INT_MAX;
-            }
-            else {
+            } else {
                 rb_raise(rb_eArgError, "%s is not a sensible :limit value "
                          "Please use a positive integer or :all",
                          rs2s(rb_obj_as_string(rval)));
@@ -2700,14 +3198,14 @@ frb_sea_search_internal(FrtQuery *query, VALUE roptions, FrtSearcher *sea)
             if (TYPE(rval) != T_DATA || CLASS_OF(rval) == cSortField) {
                 rval = frb_sort_init(1, &rval, frb_sort_alloc(cSort));
             }
-            Data_Get_Struct(rval, FrtSort, sort);
+            TypedData_Get_Struct(rval, FrtSort, &frb_sort_t, sort);
         }
     }
 
     FRT_TRY
         td = sea->search(sea, query, offset, limit, filter, sort, post_filter, 0);
         if (filter) frt_filt_deref(filter);
-    default:
+    FRT_XCATCHALL
         ex_code = xcontext.excode;
         msg = xcontext.msg;
         FRT_HANDLED();
@@ -2756,14 +3254,11 @@ frb_sea_search_internal(FrtQuery *query, VALUE roptions, FrtSearcher *sea)
  *                  object. This can be used, for example, to weight the score
  *                  of a matched document by it's age.
  */
-static VALUE
-frb_sea_search(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_sea_search(int argc, VALUE *argv, VALUE self) {
     GET_SEA();
     VALUE rquery, roptions;
-    FrtQuery *query;
     rb_scan_args(argc, argv, "11", &rquery, &roptions);
-    Data_Get_Struct(rquery, FrtQuery, query);
+    FrtQuery *query = DATA_PTR(rquery);
     FrtTopDocs *td = frb_sea_search_internal(query, roptions, sea);
     return frb_get_td(td, self);
 }
@@ -2809,27 +3304,23 @@ frb_sea_search(int argc, VALUE *argv, VALUE self)
  *                  Boolean value specifying whether the result should be
  *                  included in the result set.
  */
-static VALUE
-frb_sea_search_each(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_sea_search_each(int argc, VALUE *argv, VALUE self) {
     int i;
-    FrtQuery *q;
     float max_score;
     FrtTopDocs *td;
     VALUE rquery, roptions, rtotal_hits;
     GET_SEA();
 
     rb_scan_args(argc, argv, "11", &rquery, &roptions);
+    FrtQuery *q = DATA_PTR(rquery);
 
-    Data_Get_Struct(rquery, FrtQuery, q);
     td = frb_sea_search_internal(q, roptions, sea);
 
     max_score = (td->max_score > 1.0f) ? td->max_score : 1.0f;
 
     /* yield normalized scores */
     for (i = 0; i < td->size; i++) {
-        rb_yield_values(2, INT2FIX(td->hits[i]->doc),
-                        rb_float_new((double)(td->hits[i]->score/max_score)));
+        rb_yield_values(2, INT2FIX(td->hits[i]->doc), rb_float_new((double)(td->hits[i]->score/max_score)));
     }
 
     rtotal_hits = INT2FIX(td->total_hits);
@@ -2877,10 +3368,7 @@ frb_sea_search_each(int argc, VALUE *argv, VALUE self)
  *      # start_doc will be nil now if results is empty, ie no more matches
  *    end while start_doc
  */
-static VALUE
-frb_sea_scan(int argc, VALUE *argv, VALUE self)
-{
-    FrtQuery *q;
+static VALUE frb_sea_scan(int argc, VALUE *argv, VALUE self) {
     int i, count;
     VALUE rval, rquery, roptions;
     int *doc_array;
@@ -2888,7 +3376,7 @@ frb_sea_scan(int argc, VALUE *argv, VALUE self)
     int start_doc = 0, limit = 50;
     GET_SEA();
     rb_scan_args(argc, argv, "11", &rquery, &roptions);
-    Data_Get_Struct(rquery, FrtQuery, q);
+    FrtQuery *q = DATA_PTR(rquery);
 
     if (Qnil != roptions) {
         Check_Type(roptions, T_HASH);
@@ -2938,15 +3426,41 @@ frb_sea_scan(int argc, VALUE *argv, VALUE self)
  *
  *    puts searcher.explain(query, doc_id).to_s
  */
-static VALUE
-frb_sea_explain(VALUE self, VALUE rquery, VALUE rdoc_id)
-{
+
+static size_t frb_explanation_size(const void *p) {
+    return sizeof(FrtExplanation);
+    (void)p;
+}
+
+static void frb_explanation_free(void *p) {
+    frt_expl_destroy((FrtExplanation *)p);
+}
+
+const rb_data_type_t frb_explanation_t = {
+    .wrap_struct_name = "FrbExplanation",
+    .function = {
+        .dmark = NULL,
+        .dfree = frb_explanation_free,
+        .dsize = frb_explanation_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_expl_alloc(VALUE rclass) {
+    FrtExplanation *e = FRT_ALLOC(FrtExplanation);
+    return TypedData_Wrap_Struct(rclass, &frb_explanation_t, e);
+}
+
+static VALUE frb_sea_explain(VALUE self, VALUE rquery, VALUE rdoc_id) {
     GET_SEA();
-    FrtQuery *query;
+    FrtQuery *query = DATA_PTR(rquery);
     FrtExplanation *expl;
-    Data_Get_Struct(rquery, FrtQuery, query);
     expl = sea->explain(sea, query, FIX2INT(rdoc_id));
-    return Data_Wrap_Struct(cExplanation, NULL, &frt_expl_destroy, expl);
+    return TypedData_Wrap_Struct(cExplanation, &frb_explanation_t, expl);
 }
 
 /*
@@ -2971,12 +3485,9 @@ frb_sea_explain(VALUE self, VALUE rquery, VALUE rdoc_id)
  *                      hits the start or end of the field. You'll probably
  *                      want to change this so a Unicode ellipsis character.
  */
-static VALUE
-frb_sea_highlight(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_sea_highlight(int argc, VALUE *argv, VALUE self) {
     GET_SEA();
     VALUE rquery, rdoc_id, rfield, roptions, v;
-    FrtQuery *query;
     int excerpt_length = 150;
     int num_excerpts = 2;
     const char *pre_tag = "<b>";
@@ -2985,7 +3496,7 @@ frb_sea_highlight(int argc, VALUE *argv, VALUE self)
     char **excerpts;
 
     rb_scan_args(argc, argv, "31", &rquery, &rdoc_id, &rfield, &roptions);
-    Data_Get_Struct(rquery, FrtQuery, query);
+    FrtQuery *query = DATA_PTR(rquery);
     if (argc > 3) {
         if (TYPE(roptions) != T_HASH) {
            rb_raise(rb_eArgError, "The fourth argument to Searcher#highlight must be a hash");
@@ -3036,23 +3547,40 @@ frb_sea_highlight(int argc, VALUE *argv, VALUE self)
 }
 
 /****************************************************************************
- *
  * Searcher Methods
- *
  ****************************************************************************/
 
-static void
-frb_sea_mark(void *p)
-{
-    FrtIndexSearcher *isea = (FrtIndexSearcher *)p;
-    frb_gc_mark(isea->ir);
-    frb_gc_mark(isea->ir->store);
+static size_t frb_index_searcher_size(const void *p) {
+    return sizeof(FrtIndexSearcher);
+    (void)p;
 }
 
-#define FRT_GET_IR(rir, ir) do {\
-    rir = Data_Wrap_Struct(cIndexReader, &frb_ir_mark, &frb_ir_free, ir);\
-    object_add(ir, rir);\
-} while (0)
+static void frb_sea_mark(void *p) {
+    FrtIndexSearcher *isea = (FrtIndexSearcher *)p;
+    if (isea->ir->rir)
+        rb_gc_mark(isea->ir->rir);
+    if (isea->ir->store->rstore)
+        rb_gc_mark(isea->ir->store->rstore);
+}
+
+const rb_data_type_t frb_index_searcher_t = {
+    .wrap_struct_name = "FrbIndexSearcher",
+    .function = {
+        .dmark = frb_sea_mark,
+        .dfree = frb_sea_free,
+        .dsize = frb_index_searcher_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_sea_alloc(VALUE rclass) {
+    FrtSearcher *s = frt_isea_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_index_searcher_t, s);
+}
 
 /*
  *  call-seq:
@@ -3064,34 +3592,33 @@ frb_sea_mark(void *p)
  *  searching multiple indexes. Just open the IndexReader on multiple
  *  directories.
  */
-static VALUE
-frb_sea_init(VALUE self, VALUE obj)
-{
+static VALUE frb_sea_init(VALUE self, VALUE obj) {
     FrtStore *store = NULL;
     FrtIndexReader *ir = NULL;
     FrtSearcher *sea;
     if (TYPE(obj) == T_STRING) {
         frb_create_dir(obj);
         store = frt_open_fs_store(rs2s(obj));
-        ir = frt_ir_open(store);
+        ir = frt_ir_open(NULL, store);
         FRT_DEREF(store);
-        FRT_GET_IR(obj, ir);
+        ir->rir = TypedData_Wrap_Struct(cIndexReader, &frb_index_reader_t, ir);
     } else {
-        Check_Type(obj, T_DATA);
+        // Check_Type(obj, T_DATA);
         if (rb_obj_is_kind_of(obj, cDirectory) == Qtrue) {
-            Data_Get_Struct(obj, FrtStore, store);
-            ir = frt_ir_open(store);
-            FRT_GET_IR(obj, ir);
+            store = DATA_PTR(obj);
+            ir = frt_ir_open(NULL, store);
+            ir->rir = TypedData_Wrap_Struct(cIndexReader, &frb_index_reader_t, ir);
         } else if (rb_obj_is_kind_of(obj, cIndexReader) == Qtrue) {
-            Data_Get_Struct(obj, FrtIndexReader, ir);
+            TypedData_Get_Struct(obj, FrtIndexReader, &frb_index_reader_t, ir);
+            ir->rir = obj;
         } else {
             rb_raise(rb_eArgError, "Unknown type for argument to IndexSearcher.new");
         }
     }
-    sea = frt_isea_new(ir);
+    TypedData_Get_Struct(self, FrtSearcher, &frb_index_searcher_t, sea);
+    frt_isea_init(sea, ir);
     ((FrtIndexSearcher *)sea)->close_ir = false;
-    Frt_Wrap_Struct(self, &frb_sea_mark, &frb_sea_free, sea);
-    object_add(sea, self);
+    sea->rsea = self;
     return self;
 }
 
@@ -3101,26 +3628,46 @@ frb_sea_init(VALUE self, VALUE obj)
  *
  ****************************************************************************/
 
-static void
-frb_ms_free(void *p)
-{
+static size_t frb_multi_searcher_size(const void *p) {
+    return sizeof(FrtMultiSearcher);
+    (void)p;
+}
+
+static void frb_ms_free(void *p) {
     FrtSearcher *sea = (FrtSearcher *)p;
     FrtMultiSearcher *msea = (FrtMultiSearcher *)sea;
     free(msea->searchers);
-    object_del(sea);
     frt_searcher_close(sea);
 }
 
-static void
-frb_ms_mark(void *p)
-{
+static void frb_ms_mark(void *p) {
     int i;
     FrtMultiSearcher *msea = (FrtMultiSearcher *)p;
     for (i = 0; i < msea->s_cnt; i++) {
-        frb_gc_mark(msea->searchers[i]);
+        if (msea->searchers[i]->rsea)
+            rb_gc_mark(msea->searchers[i]->rsea);
     }
 }
 
+const rb_data_type_t frb_multi_searcher_t = {
+    .wrap_struct_name = "FrbMultiSearcher",
+    .function = {
+        .dmark = frb_ms_mark,
+        .dfree = frb_ms_free,
+        .dsize = frb_multi_searcher_size,
+        .dcompact = NULL,
+        .reserved = {0},
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE frb_ms_alloc(VALUE rclass) {
+    FrtSearcher *s = frt_msea_alloc();
+    return TypedData_Wrap_Struct(rclass, &frb_multi_searcher_t, s);
+}
+
 /*
  *  call-seq:
  *     MultiSearcher.new(searcher*) -> searcher
@@ -3128,15 +3675,12 @@ frb_ms_mark(void *p)
  *  Create a new MultiSearcher by passing a list of subsearchers to the
  *  constructor.
  */
-static VALUE
-frb_ms_init(int argc, VALUE *argv, VALUE self)
-{
+static VALUE frb_ms_init(int argc, VALUE *argv, VALUE self) {
     int i, j, top = 0, capa = argc;
 
     VALUE rsearcher;
     FrtSearcher **searchers = FRT_ALLOC_N(FrtSearcher *, capa);
-    FrtSearcher *s;
-
+    FrtSearcher *sea;
     for (i = 0; i < argc; i++) {
         rsearcher = argv[i];
         switch (TYPE(rsearcher)) {
@@ -3145,23 +3689,93 @@ frb_ms_init(int argc, VALUE *argv, VALUE self)
                 FRT_REALLOC_N(searchers, FrtSearcher *, capa);
                 for (j = 0; j < RARRAY_LEN(rsearcher); j++) {
                     VALUE rs = RARRAY_PTR(rsearcher)[j];
-                    Data_Get_Struct(rs, FrtSearcher, s);
-                    searchers[top++] = s;
+                    sea = DATA_PTR(rs);
+                    searchers[top++] = sea;
                 }
                 break;
             case T_DATA:
-                Data_Get_Struct(rsearcher, FrtSearcher, s);
-                searchers[top++] = s;
+                sea = DATA_PTR(rsearcher);
+                searchers[top++] = sea;
+                break;
+            default:
+                rb_raise(rb_eArgError, "Can't add class %s to MultiSearcher", rb_obj_classname(rsearcher));
+                break;
+        }
+    }
+    TypedData_Get_Struct(self, FrtSearcher, &frb_multi_searcher_t, sea);
+    frt_msea_init(sea, searchers, top, false);
+    sea->rsea = self;
+    return self;
+}
+
+VALUE frb_get_q(FrtQuery *q) {
+    VALUE self = q->rquery;
+
+    if (self == 0 || self == Qnil) {
+        switch (q->type) {
+            case TERM_QUERY:
+                self = TypedData_Wrap_Struct(cTermQuery, &frb_term_query_t, q);
+                break;
+            case MULTI_TERM_QUERY:
+                self = TypedData_Wrap_Struct(cMultiTermQuery, &frb_multi_term_query_t, q);
+                break;
+            case BOOLEAN_QUERY:
+                self = TypedData_Wrap_Struct(cBooleanQuery, &frb_boolean_query_t, q);
+                break;
+            case PHRASE_QUERY:
+                self = TypedData_Wrap_Struct(cPhraseQuery, &frb_phrase_query_t, q);
+                break;
+            case CONSTANT_QUERY:
+                self = TypedData_Wrap_Struct(cConstantScoreQuery, &frb_constant_score_query_t, q);
+                break;
+            case FILTERED_QUERY:
+                self = TypedData_Wrap_Struct(cFilteredQuery, &frb_filtered_query_t, q);
+                break;
+            case MATCH_ALL_QUERY:
+                self = TypedData_Wrap_Struct(cMatchAllQuery, &frb_match_all_query_t, q);
+                break;
+            case RANGE_QUERY:
+                self = TypedData_Wrap_Struct(cRangeQuery, &frb_range_query_t, q);
+                break;
+            case TYPED_RANGE_QUERY:
+                self = TypedData_Wrap_Struct(cTypedRangeQuery, &frb_typed_range_query_t, q);
+                break;
+            case WILD_CARD_QUERY:
+                self = TypedData_Wrap_Struct(cWildcardQuery, &frb_wilcard_query_t, q);
+                break;
+            case FUZZY_QUERY:
+                self = TypedData_Wrap_Struct(cFuzzyQuery, &frb_fuzzy_query_t, q);
+                break;
+            case PREFIX_QUERY:
+                self = TypedData_Wrap_Struct(cPrefixQuery, &frb_prefix_query_t, q);
+                break;
+            case SPAN_TERM_QUERY:
+                self = TypedData_Wrap_Struct(cSpanMultiTermQuery, &frb_span_multi_term_query_t, q);
+                break;
+            case SPAN_MULTI_TERM_QUERY:
+                self = TypedData_Wrap_Struct(cSpanPrefixQuery, &frb_span_prefix_query_t, q);
+                break;
+            case SPAN_PREFIX_QUERY:
+                self = TypedData_Wrap_Struct(cSpanTermQuery, &frb_span_term_query_t, q);
+                break;
+            case SPAN_FIRST_QUERY:
+                self = TypedData_Wrap_Struct(cSpanFirstQuery, &frb_span_first_query_t, q);
+                break;
+            case SPAN_OR_QUERY:
+                self = TypedData_Wrap_Struct(cSpanOrQuery, &frb_span_or_query_t, q);
+                break;
+            case SPAN_NOT_QUERY:
+                self = TypedData_Wrap_Struct(cSpanNotQuery, &frb_span_not_query_t, q);
+                break;
+            case SPAN_NEAR_QUERY:
+                self = TypedData_Wrap_Struct(cSpanNearQuery, &frb_span_near_query_t, q);
                 break;
             default:
-                rb_raise(rb_eArgError, "Can't add class %s to MultiSearcher",
-                         rb_obj_classname(rsearcher));
+                rb_raise(rb_eArgError, "Unknown query type");
                 break;
         }
+        q->rquery = self;
     }
-    s = frt_msea_new(searchers, top, false);
-    Frt_Wrap_Struct(self, &frb_ms_mark, &frb_ms_free, s);
-    object_add(s, self);
     return self;
 }
 
@@ -3186,9 +3800,7 @@ cTopDocs = rb_define_class_under(mSearch, "TopDocs", rb_cObject);
  *  is not normalized so it can be greater than 1.0. To normalize scores to
  *  the range 0.0..1.0 divide the scores by TopDocs#max_score.
  */
-static void
-Init_Hit(void)
-{
+static void Init_Hit(void) {
     const char *hit_class = "Hit";
     /* rdochack
     cHit = rb_define_class_under(mSearch, "Hit", rb_cObject);
@@ -3218,9 +3830,7 @@ Init_Hit(void)
  *      puts "#{hit.doc} scored #{hit.score * 100.0 / top_docs.max_score}"
  *    end
  */
-static void
-Init_TopDocs(void)
-{
+static void Init_TopDocs(void) {
     const char *td_class = "TopDocs";
     /* rdochack
     cTopDocs = rb_define_class_under(mSearch, "TopDocs", rb_cObject);
@@ -3257,11 +3867,9 @@ Init_TopDocs(void)
  *
  *    puts searcher.explain(query, doc_id).to_s
  */
-static void
-Init_Explanation(void)
-{
+static void Init_Explanation(void) {
     cExplanation = rb_define_class_under(mSearch, "Explanation", rb_cObject);
-    rb_define_alloc_func(cExplanation, frb_data_alloc);
+    rb_define_alloc_func(cExplanation, frb_expl_alloc);
 
     rb_define_method(cExplanation, "to_s", frb_expl_to_s, 0);
     rb_define_method(cExplanation, "to_html", frb_expl_to_html, 0);
@@ -3304,9 +3912,7 @@ Init_Explanation(void)
  *  for train rails you might also add the tern Ruby but Rails is the more
  *  important term so you'd give it a boost.
  */
-static void
-Init_Query(void)
-{
+static void Init_Query(void) {
     cQuery = rb_define_class_under(mSearch, "Query", rb_cObject);
 
     rb_define_method(cQuery, "to_s", frb_q_to_s, -1);
@@ -3338,12 +3944,9 @@ Init_Query(void)
  *  downcase all text added to the index. The title in this case was not
  *  tokenized so the case would have been left as is.
  */
-static void
-Init_TermQuery(void)
-{
+static void Init_TermQuery(void) {
     cTermQuery = rb_define_class_under(mSearch, "TermQuery", cQuery);
-    rb_define_alloc_func(cTermQuery, frb_data_alloc);
-
+    rb_define_alloc_func(cTermQuery, frb_tq_alloc);
     rb_define_method(cTermQuery, "initialize", frb_tq_init, 2);
 }
 
@@ -3368,20 +3971,16 @@ Init_TermQuery(void)
  *
  *    multi_term_query << "Ruby" << "Ferret" << "Rails" << "Search"
  */
-static void
-Init_MultiTermQuery(void)
-{
+static void Init_MultiTermQuery(void) {
     id_default_max_terms = rb_intern("@@default_max_terms");
     sym_max_terms = ID2SYM(rb_intern("max_terms"));
     sym_min_score = ID2SYM(rb_intern("min_score"));
 
     cMultiTermQuery = rb_define_class_under(mSearch, "MultiTermQuery", cQuery);
-    rb_define_alloc_func(cMultiTermQuery, frb_data_alloc);
+    rb_define_alloc_func(cMultiTermQuery, frb_mtq_alloc);
     rb_cvar_set(cMultiTermQuery, id_default_max_terms, INT2FIX(512));
-    rb_define_singleton_method(cMultiTermQuery, "default_max_terms",
-                               frb_mtq_get_dmt, 0);
-    rb_define_singleton_method(cMultiTermQuery, "default_max_terms=",
-                               frb_mtq_set_dmt, 1);
+    rb_define_singleton_method(cMultiTermQuery, "default_max_terms", frb_mtq_get_dmt, 0);
+    rb_define_singleton_method(cMultiTermQuery, "default_max_terms=", frb_mtq_set_dmt, 1);
 
     rb_define_method(cMultiTermQuery, "initialize", frb_mtq_init, -1);
     rb_define_method(cMultiTermQuery, "add_term", frb_mtq_add_term, -1);
@@ -3415,11 +4014,9 @@ static void Init_BooleanClause(void);
  *    query = BooleanQuery.new
  *    query.add_query(tq1, :must).add_query(bq2, :must).add_query(rq3, :must)
  */
-static void
-Init_BooleanQuery(void)
-{
+static void Init_BooleanQuery(void) {
     cBooleanQuery = rb_define_class_under(mSearch, "BooleanQuery", cQuery);
-    rb_define_alloc_func(cBooleanQuery, frb_data_alloc);
+    rb_define_alloc_func(cBooleanQuery, frb_bq_alloc);
 
     rb_define_method(cBooleanQuery, "initialize", frb_bq_init, -1);
     rb_define_method(cBooleanQuery, "add_query", frb_bq_add_query, -1);
@@ -3447,16 +4044,13 @@ Init_BooleanQuery(void)
  *    query = BooleanQuery.new
  *    query << clause1 << clause2
  */
-static void
-Init_BooleanClause(void)
-{
+static void Init_BooleanClause(void) {
     sym_should = ID2SYM(rb_intern("should"));
     sym_must = ID2SYM(rb_intern("must"));
     sym_must_not = ID2SYM(rb_intern("must_not"));
 
-    cBooleanClause = rb_define_class_under(cBooleanQuery, "BooleanClause",
-                                           rb_cObject);
-    rb_define_alloc_func(cBooleanClause, frb_data_alloc);
+    cBooleanClause = rb_define_class_under(cBooleanQuery, "BooleanClause", rb_cObject);
+    rb_define_alloc_func(cBooleanClause, frb_bc_alloc);
 
     rb_define_method(cBooleanClause, "initialize", frb_bc_init, -1);
     rb_define_method(cBooleanClause, "query", frb_bc_get_query, 0);
@@ -3503,9 +4097,7 @@ Init_BooleanClause(void)
  *    [1010, 0001, 0910, 1100, 1534]
  *
  */
-static void
-Init_RangeQuery(void)
-{
+static void Init_RangeQuery(void) {
     sym_upper = ID2SYM(rb_intern("upper"));
     sym_lower = ID2SYM(rb_intern("lower"));
     sym_upper_exclusive = ID2SYM(rb_intern("upper_exclusive"));
@@ -3519,7 +4111,7 @@ Init_RangeQuery(void)
     sym_greater_than_or_equal_to = ID2SYM(rb_intern(">="));
 
     cRangeQuery = rb_define_class_under(mSearch, "RangeQuery", cQuery);
-    rb_define_alloc_func(cRangeQuery, frb_data_alloc);
+    rb_define_alloc_func(cRangeQuery, frb_rq_alloc);
 
     rb_define_method(cRangeQuery, "initialize", frb_rq_init, 2);
 }
@@ -3549,12 +4141,9 @@ Init_RangeQuery(void)
  *  usually better to use a standard RangeQuery. This will require a little
  *  work on your behalf. See RangeQuery for notes on how to do this.
  */
-static void
-Init_TypedRangeQuery(void)
-{
-    cTypedRangeQuery =
-        rb_define_class_under(mSearch, "TypedRangeQuery", cQuery);
-    rb_define_alloc_func(cTypedRangeQuery, frb_data_alloc);
+static void Init_TypedRangeQuery(void) {
+    cTypedRangeQuery = rb_define_class_under(mSearch, "TypedRangeQuery", cQuery);
+    rb_define_alloc_func(cTypedRangeQuery, frb_trq_alloc);
 
     rb_define_method(cTypedRangeQuery, "initialize", frb_trq_init, 2);
 }
@@ -3622,11 +4211,9 @@ Init_TypedRangeQuery(void)
  *  italic text for example. If you want more information about this, ask on
  *  the mailing list.
  */
-static void
-Init_PhraseQuery(void)
-{
+static void Init_PhraseQuery(void) {
     cPhraseQuery = rb_define_class_under(mSearch, "PhraseQuery", cQuery);
-    rb_define_alloc_func(cPhraseQuery, frb_data_alloc);
+    rb_define_alloc_func(cPhraseQuery, frb_phq_alloc);
 
     rb_define_method(cPhraseQuery, "initialize", frb_phq_init, -1);
     rb_define_method(cPhraseQuery, "add_term", frb_phq_add, -1);
@@ -3664,11 +4251,9 @@ Init_PhraseQuery(void)
  *    # matches => "cat2/sub_cat1"
  *    # matches => "cat2/sub_cat2"
  */
-static void
-Init_PrefixQuery(void)
-{
+static void Init_PrefixQuery(void) {
     cPrefixQuery = rb_define_class_under(mSearch, "PrefixQuery", cQuery);
-    rb_define_alloc_func(cPrefixQuery, frb_data_alloc);
+    rb_define_alloc_func(cPrefixQuery, frb_prq_alloc);
 
     rb_define_method(cPrefixQuery, "initialize", frb_prq_init, -1);
 }
@@ -3699,11 +4284,9 @@ Init_PrefixQuery(void)
  *    # matches => "falling"
  *    # matches => "folly"
  */
-static void
-Init_WildcardQuery(void)
-{
+static void Init_WildcardQuery(void) {
     cWildcardQuery = rb_define_class_under(mSearch, "WildcardQuery", cQuery);
-    rb_define_alloc_func(cWildcardQuery, frb_data_alloc);
+    rb_define_alloc_func(cWildcardQuery, frb_wcq_alloc);
 
     rb_define_method(cWildcardQuery, "initialize", frb_wcq_init, -1);
 }
@@ -3729,9 +4312,7 @@ Init_WildcardQuery(void)
  *                   :prefix_length => 2)
  *    # matches => "gogle", "goggle", "googol", "googel"
  */
-static void
-Init_FuzzyQuery(void)
-{
+static void Init_FuzzyQuery(void) {
     id_default_min_similarity = rb_intern("@@default_min_similarity");
     id_default_prefix_length = rb_intern("@@default_prefix_length");
 
@@ -3739,20 +4320,14 @@ Init_FuzzyQuery(void)
     sym_prefix_length = ID2SYM(rb_intern("prefix_length"));
 
     cFuzzyQuery = rb_define_class_under(mSearch, "FuzzyQuery", cQuery);
-    rb_define_alloc_func(cFuzzyQuery, frb_data_alloc);
-    rb_cvar_set(cFuzzyQuery, id_default_min_similarity,
-                rb_float_new(0.5));
-    rb_cvar_set(cFuzzyQuery, id_default_prefix_length,
-                INT2FIX(0));
-
-    rb_define_singleton_method(cFuzzyQuery, "default_min_similarity",
-                               frb_fq_get_dms, 0);
-    rb_define_singleton_method(cFuzzyQuery, "default_min_similarity=",
-                               frb_fq_set_dms, 1);
-    rb_define_singleton_method(cFuzzyQuery, "default_prefix_length",
-                               frb_fq_get_dpl, 0);
-    rb_define_singleton_method(cFuzzyQuery, "default_prefix_length=",
-                               frb_fq_set_dpl, 1);
+    rb_define_alloc_func(cFuzzyQuery, frb_fq_alloc);
+    rb_cvar_set(cFuzzyQuery, id_default_min_similarity, rb_float_new(0.5));
+    rb_cvar_set(cFuzzyQuery, id_default_prefix_length, INT2FIX(0));
+
+    rb_define_singleton_method(cFuzzyQuery, "default_min_similarity", frb_fq_get_dms, 0);
+    rb_define_singleton_method(cFuzzyQuery, "default_min_similarity=", frb_fq_set_dms, 1);
+    rb_define_singleton_method(cFuzzyQuery, "default_prefix_length", frb_fq_get_dpl, 0);
+    rb_define_singleton_method(cFuzzyQuery, "default_prefix_length=", frb_fq_set_dpl, 1);
 
     rb_define_method(cFuzzyQuery, "initialize",     frb_fq_init, -1);
     rb_define_method(cFuzzyQuery, "prefix_length",  frb_fq_pre_len, 0);
@@ -3768,9 +4343,7 @@ Init_FuzzyQuery(void)
  *  query in combination with a filter, however, ConstantScoreQuery is
  *  probably better in that circumstance.
  */
-static void
-Init_MatchAllQuery(void)
-{
+static void Init_MatchAllQuery(void) {
     cMatchAllQuery = rb_define_class_under(mSearch, "MatchAllQuery", cQuery);
     rb_define_alloc_func(cMatchAllQuery, frb_maq_alloc);
 
@@ -3797,12 +4370,9 @@ Init_MatchAllQuery(void)
  *  Once this is run once the results are cached and will be returned very
  *  quickly in future requests.
  */
-static void
-Init_ConstantScoreQuery(void)
-{
-    cConstantScoreQuery = rb_define_class_under(mSearch,
-                                                "ConstantScoreQuery", cQuery);
-    rb_define_alloc_func(cConstantScoreQuery, frb_data_alloc);
+static void Init_ConstantScoreQuery(void) {
+    cConstantScoreQuery = rb_define_class_under(mSearch, "ConstantScoreQuery", cQuery);
+    rb_define_alloc_func(cConstantScoreQuery, frb_csq_alloc);
 
     rb_define_method(cConstantScoreQuery, "initialize", frb_csq_init, 1);
 }
@@ -3818,11 +4388,9 @@ Init_ConstantScoreQuery(void)
  *  directly to a Searcher#search method unless you are applying more than one
  *  filter since the search method also takes a filter as a parameter.
  */
-static void
-Init_FilteredQuery(void)
-{
+static void Init_FilteredQuery(void) {
     cFilteredQuery = rb_define_class_under(mSearch, "FilteredQuery", cQuery);
-    rb_define_alloc_func(cFilteredQuery, frb_data_alloc);
+    rb_define_alloc_func(cFilteredQuery, frb_fqq_alloc);
 
     rb_define_method(cFilteredQuery, "initialize", frb_fqq_init, 2);
 }
@@ -3836,11 +4404,9 @@ Init_FilteredQuery(void)
  *  being that it returns the start and end offset of all of its matches for
  *  use by enclosing SpanQueries.
  */
-static void
-Init_SpanTermQuery(void)
-{
+static void Init_SpanTermQuery(void) {
     cSpanTermQuery = rb_define_class_under(mSpans, "SpanTermQuery", cQuery);
-    rb_define_alloc_func(cSpanTermQuery, frb_data_alloc);
+    rb_define_alloc_func(cSpanTermQuery, frb_spantq_alloc);
 
     rb_define_method(cSpanTermQuery, "initialize", frb_spantq_init, 2);
 }
@@ -3854,11 +4420,9 @@ Init_SpanTermQuery(void)
  *  difference being that it returns the start and end offset of all of its
  *  matches for use by enclosing SpanQueries.
  */
-static void
-Init_SpanMultiTermQuery(void)
-{
+static void Init_SpanMultiTermQuery(void) {
     cSpanMultiTermQuery = rb_define_class_under(mSpans, "SpanMultiTermQuery", cQuery);
-    rb_define_alloc_func(cSpanMultiTermQuery, frb_data_alloc);
+    rb_define_alloc_func(cSpanMultiTermQuery, frb_spanmtq_alloc);
 
     rb_define_method(cSpanMultiTermQuery, "initialize", frb_spanmtq_init, 2);
 }
@@ -3872,11 +4436,9 @@ Init_SpanMultiTermQuery(void)
  *  being that it returns the start and end offset of all of its matches for
  *  use by enclosing SpanQueries.
  */
-static void
-Init_SpanPrefixQuery(void)
-{
+static void Init_SpanPrefixQuery(void) {
     cSpanPrefixQuery = rb_define_class_under(mSpans, "SpanPrefixQuery", cQuery);
-    rb_define_alloc_func(cSpanPrefixQuery, frb_data_alloc);
+    rb_define_alloc_func(cSpanPrefixQuery, frb_spanprq_alloc);
 
     rb_define_method(cSpanPrefixQuery, "initialize", frb_spanprq_init, -1);
 }
@@ -3901,11 +4463,9 @@ Init_SpanPrefixQuery(void)
  *
  *  SpanFirstQuery only works with other SpanQueries.
  */
-static void
-Init_SpanFirstQuery(void)
-{
+static void Init_SpanFirstQuery(void) {
     cSpanFirstQuery = rb_define_class_under(mSpans, "SpanFirstQuery", cQuery);
-    rb_define_alloc_func(cSpanFirstQuery, frb_data_alloc);
+    rb_define_alloc_func(cSpanFirstQuery, frb_spanfq_alloc);
 
     rb_define_method(cSpanFirstQuery, "initialize", frb_spanfq_init, 2);
 }
@@ -3948,15 +4508,13 @@ Init_SpanFirstQuery(void)
  *
  *  SpanNearQuery only works with other SpanQueries.
  */
-static void
-Init_SpanNearQuery(void)
-{
+static void Init_SpanNearQuery(void) {
     sym_slop = ID2SYM(rb_intern("slop"));
     sym_in_order = ID2SYM(rb_intern("in_order"));
     sym_clauses = ID2SYM(rb_intern("clauses"));
 
     cSpanNearQuery = rb_define_class_under(mSpans, "SpanNearQuery", cQuery);
-    rb_define_alloc_func(cSpanNearQuery, frb_data_alloc);
+    rb_define_alloc_func(cSpanNearQuery, frb_spannq_alloc);
 
     rb_define_method(cSpanNearQuery, "initialize", frb_spannq_init, -1);
     rb_define_method(cSpanNearQuery, "add", frb_spannq_add, 1);
@@ -4002,11 +4560,9 @@ Init_SpanNearQuery(void)
  *
  *  SpanOrQuery only works with other SpanQueries.
  */
-static void
-Init_SpanOrQuery(void)
-{
+static void Init_SpanOrQuery(void) {
     cSpanOrQuery = rb_define_class_under(mSpans, "SpanOrQuery", cQuery);
-    rb_define_alloc_func(cSpanOrQuery, frb_data_alloc);
+    rb_define_alloc_func(cSpanOrQuery, frb_spanoq_alloc);
 
     rb_define_method(cSpanOrQuery, "initialize", frb_spanoq_init, -1);
     rb_define_method(cSpanOrQuery, "add", frb_spanoq_add, 1);
@@ -4036,11 +4592,9 @@ Init_SpanOrQuery(void)
  *
  *  SpanOrQuery only works with other SpanQueries.
  */
-static void
-Init_SpanNotQuery(void)
-{
+static void Init_SpanNotQuery(void) {
     cSpanNotQuery = rb_define_class_under(mSpans, "SpanNotQuery", cQuery);
-    rb_define_alloc_func(cSpanNotQuery, frb_data_alloc);
+    rb_define_alloc_func(cSpanNotQuery, frb_spanxq_alloc);
 
     rb_define_method(cSpanNotQuery, "initialize", frb_spanxq_init, 2);
 }
@@ -4061,9 +4615,7 @@ extern VALUE mSearch = rb_define_module_under(mFerret, "Search");
  *  field. They are often used in combination to perform special types of
  *  PhraseQuery.
  */
-static void
-Init_Spans(void)
-{
+static void Init_Spans(void) {
     mSpans = rb_define_module_under(mSearch, "Spans");
     Init_SpanTermQuery();
     Init_SpanMultiTermQuery();
@@ -4093,12 +4645,10 @@ Init_Spans(void)
  *  See RangeQuery for notes on how to use the RangeFilter on a field
  *  containing numbers.
  */
-static void
-Init_RangeFilter(void)
-{
+static void Init_RangeFilter(void) {
     cRangeFilter = rb_define_class_under(mSearch, "RangeFilter", cFilter);
     frb_mark_cclass(cRangeFilter);
-    rb_define_alloc_func(cRangeFilter, frb_data_alloc);
+    rb_define_alloc_func(cRangeFilter, frb_rf_alloc);
 
     rb_define_method(cRangeFilter, "initialize", frb_rf_init, 2);
 }
@@ -4120,13 +4670,10 @@ Init_RangeFilter(void)
  *
  *    filter = TypedRangeFilter.new(:created_on, :<= => "50.00")
  */
-static void
-Init_TypedRangeFilter(void)
-{
-    cTypedRangeFilter =
-        rb_define_class_under(mSearch, "TypedRangeFilter", cFilter);
+static void Init_TypedRangeFilter(void) {
+    cTypedRangeFilter = rb_define_class_under(mSearch, "TypedRangeFilter", cFilter);
     frb_mark_cclass(cTypedRangeFilter);
-    rb_define_alloc_func(cTypedRangeFilter, frb_data_alloc);
+    rb_define_alloc_func(cTypedRangeFilter, frb_trf_alloc);
 
     rb_define_method(cTypedRangeFilter, "initialize", frb_trf_init, 2);
 }
@@ -4156,12 +4703,10 @@ Init_TypedRangeFilter(void)
  *  caching. Don't create a new one for each request. Of course, this won't
  *  work in a CGI application.
  */
-static void
-Init_QueryFilter(void)
-{
+static void Init_QueryFilter(void) {
     cQueryFilter = rb_define_class_under(mSearch, "QueryFilter", cFilter);
     frb_mark_cclass(cQueryFilter);
-    rb_define_alloc_func(cQueryFilter, frb_data_alloc);
+    rb_define_alloc_func(cQueryFilter, frb_qf_alloc);
 
     rb_define_method(cQueryFilter, "initialize", frb_qf_init, 1);
 }
@@ -4181,13 +4726,11 @@ Init_QueryFilter(void)
  *  TODO add support for user implemented Filter.
  *  TODO add example of user implemented Filter.
  */
-static void
-Init_Filter(void)
-{
+static void Init_Filter(void) {
     id_bits = rb_intern("bits");
     cFilter = rb_define_class_under(mSearch, "Filter", rb_cObject);
     frb_mark_cclass(cFilter);
-    rb_define_alloc_func(cConstantScoreQuery, frb_data_alloc);
+    rb_define_alloc_func(cConstantScoreQuery, frb_csq_alloc);
 
     rb_define_method(cFilter, "bits", frb_f_get_bits, 1);
     rb_define_method(cFilter, "to_s", frb_f_to_s, 0);
@@ -4230,12 +4773,11 @@ Init_Filter(void)
  *  Note 2: When sorting by integer, integers are only 4 bytes so anything
  *  larger will cause strange sorting behaviour.
  */
-static void
-Init_SortField(void)
-{
+
+static void Init_SortField(void) {
     /* option hash keys for SortField#initialize */
-    sym_type  = ID2SYM(rb_intern("type"));
-    sym_reverse    = ID2SYM(rb_intern("reverse"));
+    sym_type = ID2SYM(rb_intern("type"));
+    sym_reverse = ID2SYM(rb_intern("reverse"));
     sym_comparator = ID2SYM(rb_intern("comparator"));
 
     /* Sort types */
@@ -4248,7 +4790,7 @@ Init_SortField(void)
     sym_byte = ID2SYM(rb_intern("byte"));
 
     cSortField = rb_define_class_under(mSearch, "SortField", rb_cObject);
-    rb_define_alloc_func(cSortField, frb_data_alloc);
+    rb_define_alloc_func(cSortField, frb_sf_alloc);
 
     rb_define_method(cSortField, "initialize", frb_sf_init, -1);
     rb_define_method(cSortField, "reverse?", frb_sf_is_reverse, 0);
@@ -4257,34 +4799,18 @@ Init_SortField(void)
     rb_define_method(cSortField, "comparator", frb_sf_get_comparator, 0);
     rb_define_method(cSortField, "to_s", frb_sf_to_s, 0);
 
-    rb_define_const(cSortField, "SCORE",
-                    Data_Wrap_Struct(cSortField, NULL,
-                                     &frb_deref_free,
-                                     (FrtSortField *)&FRT_SORT_FIELD_SCORE));
-    object_add((FrtSortField *)&FRT_SORT_FIELD_SCORE,
-               rb_const_get(cSortField, rb_intern("SCORE")));
-
-    rb_define_const(cSortField, "SCORE_REV",
-                    Data_Wrap_Struct(cSortField, NULL,
-                                     &frb_deref_free,
-                                     (FrtSortField *)&FRT_SORT_FIELD_SCORE_REV));
-    object_add((FrtSortField *)&FRT_SORT_FIELD_SCORE_REV,
-               rb_const_get(cSortField, rb_intern("SCORE_REV")));
-
-    rb_define_const(cSortField, "DOC_ID",
-                    Data_Wrap_Struct(cSortField, NULL,
-                                     &frb_deref_free,
-                                     (FrtSortField *)&FRT_SORT_FIELD_DOC));
+    rb_define_const(cSortField, "SCORE", TypedData_Wrap_Struct(cSortField, &frb_sort_field_t, FRT_SORT_FIELD_SCORE));
+    FRT_SORT_FIELD_SCORE->rfield = rb_const_get(cSortField, rb_intern("SCORE"));
 
+    rb_define_const(cSortField, "SCORE_REV", TypedData_Wrap_Struct(cSortField, &frb_sort_field_t, FRT_SORT_FIELD_SCORE_REV));
+    FRT_SORT_FIELD_SCORE_REV->rfield = rb_const_get(cSortField, rb_intern("SCORE_REV"));
+
+    rb_define_const(cSortField, "DOC_ID", TypedData_Wrap_Struct(cSortField, &frb_sort_field_t, FRT_SORT_FIELD_DOC));
     oSORT_FIELD_DOC = rb_const_get(cSortField, rb_intern("DOC_ID"));
-    object_add((FrtSortField *)&FRT_SORT_FIELD_DOC, oSORT_FIELD_DOC);
+    FRT_SORT_FIELD_DOC->rfield = oSORT_FIELD_DOC;
 
-    rb_define_const(cSortField, "DOC_ID_REV",
-                    Data_Wrap_Struct(cSortField, NULL,
-                                     &frb_deref_free,
-                                     (FrtSortField *)&FRT_SORT_FIELD_DOC_REV));
-    object_add((FrtSortField *)&FRT_SORT_FIELD_DOC_REV,
-               rb_const_get(cSortField, rb_intern("DOC_ID_REV")));
+    rb_define_const(cSortField, "DOC_ID_REV", TypedData_Wrap_Struct(cSortField, &frb_sort_field_t, FRT_SORT_FIELD_DOC_REV));
+    FRT_SORT_FIELD_DOC_REV->rfield = rb_const_get(cSortField, rb_intern("DOC_ID_REV"));
 }
 
 /*
@@ -4307,9 +4833,7 @@ Init_SortField(void)
  *  Remember that the :type parameter for SortField is set to :auto be default
  *  be I strongly recommend you specify a :type value.
  */
-static void
-Init_Sort(void)
-{
+static void Init_Sort(void) {
     /* Sort */
     cSort = rb_define_class_under(mSearch, "Sort", rb_cObject);
     rb_define_alloc_func(cSort, frb_sort_alloc);
@@ -4318,10 +4842,8 @@ Init_Sort(void)
     rb_define_method(cSort, "fields", frb_sort_get_fields, 0);
     rb_define_method(cSort, "to_s", frb_sort_to_s, 0);
 
-    rb_define_const(cSort, "RELEVANCE",
-                    frb_sort_init(0, NULL, frb_sort_alloc(cSort)));
-    rb_define_const(cSort, "INDEX_ORDER",
-                    frb_sort_init(1, &oSORT_FIELD_DOC, frb_sort_alloc(cSort)));
+    rb_define_const(cSort, "RELEVANCE", frb_sort_init(0, NULL, frb_sort_alloc(cSort)));
+    rb_define_const(cSort, "INDEX_ORDER", frb_sort_init(1, &oSORT_FIELD_DOC, frb_sort_alloc(cSort)));
 }
 
 /*
@@ -4354,9 +4876,7 @@ Init_Sort(void)
  *        puts "#{searcher[doc_id][title] scored #{score}"
  *    end
  */
-static void
-Init_Searcher(void)
-{
+static void Init_Searcher(void) {
     /* option hash keys for Searcher#search */
     sym_offset          = ID2SYM(rb_intern("offset"));
     sym_limit           = ID2SYM(rb_intern("limit"));
@@ -4375,7 +4895,7 @@ Init_Searcher(void)
 
     /* Searcher */
     cSearcher = rb_define_class_under(mSearch, "Searcher", rb_cObject);
-    rb_define_alloc_func(cSearcher, frb_data_alloc);
+    rb_define_alloc_func(cSearcher, frb_sea_alloc);
 
     rb_define_method(cSearcher, "initialize", frb_sea_init, 1);
     rb_define_method(cSearcher, "close", frb_sea_close, 0);
@@ -4403,11 +4923,9 @@ Init_Searcher(void)
  *  RemoteSearcher, the MultiSearcher can be used to search multiple machines
  *  at once.
  */
-static void
-Init_MultiSearcher(void)
-{
+static void Init_MultiSearcher(void) {
     cMultiSearcher = rb_define_class_under(mSearch, "MultiSearcher", cSearcher);
-    rb_define_alloc_func(cMultiSearcher, frb_data_alloc);
+    rb_define_alloc_func(cMultiSearcher, frb_ms_alloc);
     rb_define_method(cMultiSearcher, "initialize", frb_ms_init, -1);
 }