oj 3.11.5 → 3.16.5

data/ext/oj/fast.c

@@ -11,13 +11,15 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "dump.h"
 #include "encode.h"
+#include "mem.h"
 #include "oj.h"
 
 // maximum to allocate on the stack, arbitrary limit
 #define SMALL_JSON 65536
 #define MAX_STACK 100
-//#define BATCH_SIZE	(4096 / sizeof(struct _leaf) - 1)
+// #define BATCH_SIZE	(4096 / sizeof(struct _leaf) - 1)
 #define BATCH_SIZE 100
 
 // Support for compaction
@@ -31,25 +33,25 @@ typedef struct _batch {
     struct _batch *next;
     int            next_avail;
     struct _leaf   leaves[BATCH_SIZE];
-} * Batch;
+} *Batch;
 
 typedef struct _doc {
     Leaf          data;
-    Leaf *        where;                  // points to current location
+    Leaf         *where;                  // points to current location
     Leaf          where_path[MAX_STACK];  // points to head of path
-    char *        json;
+    char         *json;
     unsigned long size;  // number of leaves/branches in the doc
     VALUE         self;
     Batch         batches;
     struct _batch batch0;
-} * Doc;
+} *Doc;
 
 typedef struct _parseInfo {
     char *str;  // buffer being read from
     char *s;    // current position in buffer
     Doc   doc;
     void *stack_min;
-} * ParseInfo;
+} *ParseInfo;
 
 static void  leaf_init(Leaf leaf, int type);
 static Leaf  leaf_new(Doc doc, int type);
@@ -73,29 +75,13 @@ static char *read_quoted_value(ParseInfo pi);
 static void  skip_comment(ParseInfo pi);
 
 static VALUE protect_open_proc(VALUE x);
-static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated);
+static VALUE parse_json(VALUE clas, char *json, bool given);
 static void  each_leaf(Doc doc, VALUE self);
 static int   move_step(Doc doc, const char *path, int loc);
 static Leaf  get_doc_leaf(Doc doc, const char *path);
 static Leaf  get_leaf(Leaf *stack, Leaf *lp, const char *path);
 static void  each_value(Doc doc, Leaf leaf);
 
-static void  doc_init(Doc doc);
-static void  doc_free(Doc doc);
-static VALUE doc_open(VALUE clas, VALUE str);
-static VALUE doc_open_file(VALUE clas, VALUE filename);
-static VALUE doc_where(VALUE self);
-static VALUE doc_local_key(VALUE self);
-static VALUE doc_home(VALUE self);
-static VALUE doc_type(int argc, VALUE *argv, VALUE self);
-static VALUE doc_fetch(int argc, VALUE *argv, VALUE self);
-static VALUE doc_each_leaf(int argc, VALUE *argv, VALUE self);
-static VALUE doc_move(VALUE self, VALUE str);
-static VALUE doc_each_child(int argc, VALUE *argv, VALUE self);
-static VALUE doc_each_value(int argc, VALUE *argv, VALUE self);
-static VALUE doc_dump(int argc, VALUE *argv, VALUE self);
-static VALUE doc_size(VALUE self);
-
 VALUE oj_doc_class = Qundef;
 
 // This is only for CentOS 5.4 with Ruby 1.9.3-p0.
@@ -128,10 +114,7 @@ inline static char *ulong_fill(char *s, size_t num) {
     char *b = buf + sizeof(buf) - 1;
 
     *b-- = '\0';
-    for (; 0 < num; num /= 10, b--) {
-        *b = (num % 10) + '0';
-    }
-    b++;
+    b    = oj_longlong_to_string((long long)num, false, b);
     if ('\0' == *b) {
         b--;
         *b = '0';
@@ -175,7 +158,7 @@ inline static Leaf leaf_new(Doc doc, int type) {
     Leaf leaf;
 
     if (0 == doc->batches || BATCH_SIZE == doc->batches->next_avail) {
-        Batch b = ALLOC(struct _batch);
+        Batch b = OJ_R_ALLOC(struct _batch);
 
         // Initializes all leaves with a NO_VAL value_type
         memset(b, 0, sizeof(struct _batch));
@@ -216,9 +199,7 @@ static VALUE leaf_value(Doc doc, Leaf leaf) {
             break;
         case T_ARRAY: return leaf_array_value(doc, leaf); break;
         case T_HASH: return leaf_hash_value(doc, leaf); break;
-        default:
-            rb_raise(rb_const_get_at(Oj, rb_intern("Error")), "Unexpected type %02x.", leaf->rtype);
-            break;
+        default: rb_raise(rb_const_get_at(Oj, rb_intern("Error")), "Unexpected type %02x.", leaf->rtype); break;
         }
     }
     return leaf->value;
@@ -267,7 +248,7 @@ static void skip_comment(ParseInfo pi) {
 #endif
 
 static void leaf_fixnum_value(Leaf leaf) {
-    char *  s   = leaf->str;
+    char   *s   = leaf->str;
     int64_t n   = 0;
     int     neg = 0;
     int     big = 0;
@@ -373,7 +354,7 @@ static Leaf read_next(ParseInfo pi) {
 
 static Leaf read_obj(ParseInfo pi) {
     Leaf        h = leaf_new(pi->doc, T_HASH);
-    char *      end;
+    char       *end;
     const char *key = 0;
     Leaf        val = 0;
 
@@ -665,10 +646,11 @@ static void doc_free(Doc doc) {
         while (0 != (b = doc->batches)) {
             doc->batches = doc->batches->next;
             if (&doc->batch0 != b) {
-                xfree(b);
+                OJ_R_FREE(b);
             }
         }
-        // xfree(f);
+        OJ_R_FREE(doc->json);
+        OJ_R_FREE(doc);
     }
 }
 
@@ -688,27 +670,28 @@ static void free_doc_cb(void *x) {
     Doc doc = (Doc)x;
 
     if (0 != doc) {
-        xfree(doc->json);
         doc_free(doc);
     }
 }
 
 static void mark_leaf(Leaf leaf) {
-    switch (leaf->value_type) {
-    case COL_VAL:
-        if (NULL != leaf->elements) {
-            Leaf first = leaf->elements->next;
-            Leaf e     = first;
+    if (NULL != leaf) {
+        switch (leaf->value_type) {
+        case COL_VAL:
+            if (NULL != leaf->elements) {
+                Leaf first = leaf->elements->next;
+                Leaf e     = first;
 
-            do {
-                mark_leaf(e);
-                e = e->next;
-            } while (e != first);
-        }
-        break;
-    case RUBY_VAL: mark(leaf->value); break;
+                do {
+                    mark_leaf(e);
+                    e = e->next;
+                } while (e != first);
+            }
+            break;
+        case RUBY_VAL: mark(leaf->value); break;
 
-    default: break;
+        default: break;
+        }
     }
 }
 
@@ -764,20 +747,15 @@ static const rb_data_type_t oj_doc_type = {
     0,
 };
 
-static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
+static VALUE parse_json(VALUE clas, char *json, bool given) {
     struct _parseInfo pi;
     volatile VALUE    result = Qnil;
     Doc               doc;
     int               ex = 0;
     volatile VALUE    self;
 
-    // TBD are both needed? is stack allocation ever needed?
+    doc = OJ_R_ALLOC_N(struct _doc, 1);
 
-    if (given) {
-        doc = ALLOCA_N(struct _doc, 1);
-    } else {
-        doc = ALLOC(struct _doc);
-    }
     // skip UTF-8 BOM if present
     if (0xEF == (uint8_t)*json && 0xBB == (uint8_t)json[1] && 0xBF == (uint8_t)json[2]) {
         pi.str = json + 3;
@@ -787,9 +765,9 @@ static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
     pi.s = pi.str;
     doc_init(doc);
     pi.doc = doc;
-#if IS_WINDOWS
+#if IS_WINDOWS || !defined(HAVE_GETRLIMIT)
     // assume a 1M stack and give half to ruby
-    pi.stack_min = (void *)((char *)&pi - (512 * 1024));
+    pi.stack_min = (void *)((char *)&pi - (512L * 1024L));
 #else
     {
         struct rlimit lim;
@@ -802,18 +780,19 @@ static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
         }
     }
 #endif
-    self                = TypedData_Wrap_Struct(clas, &oj_doc_type, doc);
-    doc->self           = self;
-    doc->json           = json;
-    DATA_PTR(doc->self) = doc;
-    result              = rb_protect(protect_open_proc, (VALUE)&pi, &ex);
+    doc->json = json;
+    self      = TypedData_Wrap_Struct(clas, &oj_doc_type, doc);
+    doc->self = self;
+    result    = rb_protect(protect_open_proc, (VALUE)&pi, &ex);
     if (given || 0 != ex) {
         DATA_PTR(doc->self) = NULL;
+        // TBD is this needed?
+        /*
         doc_free(pi.doc);
-        if (allocated && 0 != ex) {  // will jump so caller will not free
-            xfree(json);
+        if (0 != ex) {  // will jump so caller will not free
+            OJ_R_FREE(json);
         }
-        rb_gc_enable();
+        */
     } else {
         result = doc->self;
     }
@@ -841,9 +820,7 @@ static Leaf get_doc_leaf(Doc doc, const char *path) {
             size_t cnt = doc->where - doc->where_path;
 
             if (MAX_STACK <= cnt) {
-                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")),
-                         "Path too deep. Limit is %d levels.",
-                         MAX_STACK);
+                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
             }
             memcpy(stack, doc->where_path, sizeof(Leaf) * (cnt + 1));
             lp = stack + cnt;
@@ -884,9 +861,7 @@ static Leaf get_leaf(Leaf *stack, Leaf *lp, const char *path) {
     Leaf leaf = *lp;
 
     if (MAX_STACK <= lp - stack) {
-        rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")),
-                 "Path too deep. Limit is %d levels.",
-                 MAX_STACK);
+        rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
     }
     if ('\0' != *path) {
         if ('.' == *path && '.' == *(path + 1)) {
@@ -899,12 +874,18 @@ static Leaf get_leaf(Leaf *stack, Leaf *lp, const char *path) {
             } else {
                 return 0;
             }
-        } else if (COL_VAL == leaf->value_type && 0 != leaf->elements) {
+        } else if (NULL == leaf->elements) {
+            leaf = NULL;
+        } else if (STR_VAL == leaf->value_type || RUBY_VAL == leaf->value_type) {
+            // We are trying to get a children of a leaf, which
+            // doesn't exist.
+            leaf = NULL;
+        } else if (COL_VAL == leaf->value_type) {
             Leaf first = leaf->elements->next;
             Leaf e     = first;
             int  type  = leaf->rtype;
 
-            leaf = 0;
+            leaf = NULL;
             if (T_ARRAY == type) {
                 int cnt = 0;
 
@@ -929,6 +910,7 @@ static Leaf get_leaf(Leaf *stack, Leaf *lp, const char *path) {
                 const char *slash = next_slash(path);
                 int         klen;
 
+                leaf = NULL;
                 if (0 == slash) {
                     klen = (int)strlen(key);
                     path += klen;
@@ -959,9 +941,7 @@ static void each_leaf(Doc doc, VALUE self) {
 
             doc->where++;
             if (MAX_STACK <= doc->where - doc->where_path) {
-                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")),
-                         "Path too deep. Limit is %d levels.",
-                         MAX_STACK);
+                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
             }
             do {
                 *doc->where = e;
@@ -977,9 +957,7 @@ static void each_leaf(Doc doc, VALUE self) {
 
 static int move_step(Doc doc, const char *path, int loc) {
     if (MAX_STACK <= doc->where - doc->where_path) {
-        rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")),
-                 "Path too deep. Limit is %d levels.",
-                 MAX_STACK);
+        rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
     }
     if ('\0' == *path) {
         loc = 0;
@@ -1104,31 +1082,23 @@ static void each_value(Doc doc, Leaf leaf) {
  *   doc.close()
  */
 static VALUE doc_open(VALUE clas, VALUE str) {
-    char *         json;
+    char          *json;
     size_t         len;
     volatile VALUE obj;
     int            given = rb_block_given_p();
-    int            allocate;
 
     Check_Type(str, T_STRING);
-    len      = (int)RSTRING_LEN(str) + 1;
-    allocate = (SMALL_JSON < len || !given);
-    if (allocate) {
-        json = ALLOC_N(char, len);
-    } else {
-        json = ALLOCA_N(char, len);
-    }
-    // It should not be necessaary to stop GC but if it is not stopped and a
-    // large string is parsed that string is corrupted or freed during
-    // parsing. I'm not sure what is going on exactly but disabling GC avoids
-    // the issue.
-    rb_gc_disable();
+    len  = (int)RSTRING_LEN(str) + 1;
+    json = OJ_R_ALLOC_N(char, len);
+
     memcpy(json, StringValuePtr(str), len);
-    obj = parse_json(clas, json, given, allocate);
-    rb_gc_enable();
-    if (given && allocate) {
-        xfree(json);
+    obj = parse_json(clas, json, given);
+    // TBD is this needed
+    /*
+    if (given) {
+        OJ_R_FREE(json);
     }
+    */
     return obj;
 }
 
@@ -1152,27 +1122,21 @@ static VALUE doc_open(VALUE clas, VALUE str) {
  *   doc.close()
  */
 static VALUE doc_open_file(VALUE clas, VALUE filename) {
-    char *         path;
-    char *         json;
-    FILE *         f;
+    char          *path;
+    char          *json;
+    FILE          *f;
     size_t         len;
     volatile VALUE obj;
     int            given = rb_block_given_p();
-    int            allocate;
 
-    Check_Type(filename, T_STRING);
     path = StringValuePtr(filename);
     if (0 == (f = fopen(path, "r"))) {
         rb_raise(rb_eIOError, "%s", strerror(errno));
     }
     fseek(f, 0, SEEK_END);
-    len      = ftell(f);
-    allocate = (SMALL_JSON < len || !given);
-    if (allocate) {
-        json = ALLOC_N(char, len + 1);
-    } else {
-        json = ALLOCA_N(char, len + 1);
-    }
+    len  = ftell(f);
+    json = OJ_R_ALLOC_N(char, len + 1);
+
     fseek(f, 0, SEEK_SET);
     if (len != fread(json, 1, len, f)) {
         fclose(f);
@@ -1183,12 +1147,13 @@ static VALUE doc_open_file(VALUE clas, VALUE filename) {
     }
     fclose(f);
     json[len] = '\0';
-    rb_gc_disable();
-    obj = parse_json(clas, json, given, allocate);
-    rb_gc_enable();
-    if (given && allocate) {
-        xfree(json);
+    obj       = parse_json(clas, json, given);
+    // TBD is this needed
+    /*
+    if (given) {
+        OJ_R_FREE(json);
     }
+    */
     return obj;
 }
 
@@ -1217,7 +1182,7 @@ static char *append_key(char *p, const char *key) {
  * @see Oj::Doc.open
  */
 
-/* @overload where?() => String
+/* @overload where() => String
  *
  * Returns a String that describes the absolute path to the current location
  * in the JSON document.
@@ -1228,11 +1193,11 @@ static VALUE doc_where(VALUE self) {
     if (0 == *doc->where_path || doc->where == doc->where_path) {
         return oj_slash_string;
     } else {
-        Leaf * lp;
+        Leaf  *lp;
         Leaf   leaf;
         size_t size = 3;  // leading / and terminating \0
-        char * path;
-        char * p;
+        char  *path;
+        char  *p;
 
         for (lp = doc->where_path; lp <= doc->where; lp++) {
             leaf = *lp;
@@ -1259,6 +1224,24 @@ static VALUE doc_where(VALUE self) {
     }
 }
 
+/* @overload where?() => String
+ * @deprecated
+ * Returns a String that describes the absolute path to the current location
+ * in the JSON document.
+ */
+static VALUE doc_where_q(VALUE self) {
+    return doc_where(self);
+}
+
+/* @overload path() => String
+ *
+ * Returns a String that describes the absolute path to the current location
+ * in the JSON document.
+ */
+static VALUE doc_path(VALUE self) {
+    return doc_where(self);
+}
+
 /* @overload local_key() => String, Fixnum, nil
  *
  * Returns the final key to the current location.
@@ -1317,7 +1300,6 @@ static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
     VALUE       type = Qnil;
 
     if (1 <= argc) {
-        Check_Type(*argv, T_STRING);
         path = StringValuePtr(*argv);
     }
     if (0 != (leaf = get_doc_leaf(doc, path))) {
@@ -1326,11 +1308,7 @@ static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
         case T_TRUE: type = rb_cTrueClass; break;
         case T_FALSE: type = rb_cFalseClass; break;
         case T_STRING: type = rb_cString; break;
-#ifdef RUBY_INTEGER_UNIFICATION
         case T_FIXNUM: type = rb_cInteger; break;
-#else
-        case T_FIXNUM: type = rb_cFixnum; break;
-#endif
         case T_FLOAT: type = rb_cFloat; break;
         case T_ARRAY: type = rb_cArray; break;
         case T_HASH: type = rb_cHash; break;
@@ -1340,14 +1318,14 @@ static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
     return type;
 }
 
-/* @overload fetch(path=nil) => nil, true, false, Fixnum, Float, String, Array,
+/* @overload fetch(path=nil,default=nil) => nil, true, false, Fixnum, Float, String, Array,
  * Hash
  *
  * Returns the value at the location identified by the path or the current
  * location if the path is nil or not provided. This method will create and
  * return an Array or Hash if that is the type of Object at the location
  * specified. This is more expensive than navigating to the leaves of the JSON
- * document.
+ * document. If a default is provided that is used if no value if found.
  *   @param [String] path path to the location to get the type of if provided
  * @example
  *   Oj::Doc.open('[1,2]') { |doc| doc.fetch() }      #=> [1, 2]
@@ -1357,11 +1335,10 @@ static VALUE doc_fetch(int argc, VALUE *argv, VALUE self) {
     Doc            doc;
     Leaf           leaf;
     volatile VALUE val  = Qnil;
-    const char *   path = 0;
+    const char    *path = 0;
 
     doc = self_doc(self);
     if (1 <= argc) {
-        Check_Type(*argv, T_STRING);
         path = StringValuePtr(*argv);
         if (2 == argc) {
             val = argv[1];
@@ -1373,6 +1350,27 @@ static VALUE doc_fetch(int argc, VALUE *argv, VALUE self) {
     return val;
 }
 
+/* @overload exists?(path) => true, false
+ *
+ * Returns true if the value at the location identified by the path exists.
+ *   @param [String] path path to the location
+ * @example
+ *   Oj::Doc.open('[1,2]') { |doc| doc.exists?('/1') }  #=> true
+ *   Oj::Doc.open('[1,2]') { |doc| doc.exists?('/3') }  #=> false
+ */
+static VALUE doc_exists(VALUE self, VALUE str) {
+    Doc  doc;
+    Leaf leaf;
+
+    doc = self_doc(self);
+    if (0 != (leaf = get_doc_leaf(doc, StringValuePtr(str)))) {
+        if (NULL != leaf) {
+            return Qtrue;
+        }
+    }
+    return Qfalse;
+}
+
 /* @overload each_leaf(path=nil) => nil
  *
  * Yields to the provided block for each leaf node with the identified
@@ -1401,7 +1399,6 @@ static VALUE doc_each_leaf(int argc, VALUE *argv, VALUE self) {
             memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
         }
         if (1 <= argc) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
             if ('/' == *path) {
                 doc->where = doc->where_path;
@@ -1436,7 +1433,6 @@ static VALUE doc_move(VALUE self, VALUE str) {
     const char *path;
     int         loc;
 
-    Check_Type(str, T_STRING);
     path = StringValuePtr(str);
     if ('/' == *path) {
         doc->where = doc->where_path;
@@ -1455,7 +1451,7 @@ static VALUE doc_move(VALUE self, VALUE str) {
  * to the block on yield is the Doc instance after moving to the child
  * location.
  *   @param [String] path if provided it identified the top of the branch to
- * process the chilren of
+ * process the children of
  * @yieldparam [Doc] Doc at the child location
  * @example
  *   Oj::Doc.open('[3,[2,1]]') { |doc|
@@ -1471,13 +1467,13 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
         Doc         doc  = self_doc(self);
         const char *path = 0;
         size_t      wlen;
+        Leaf       *where_orig = doc->where;
 
         wlen = doc->where - doc->where_path;
         if (0 < wlen) {
             memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
         }
         if (1 <= argc) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
             if ('/' == *path) {
                 doc->where = doc->where_path;
@@ -1487,9 +1483,13 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
                 if (0 < wlen) {
                     memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
                 }
+                doc->where = where_orig;
                 return Qnil;
             }
         }
+        if (NULL == doc->where || NULL == *doc->where) {
+            return Qnil;
+        }
         if (COL_VAL == (*doc->where)->value_type && 0 != (*doc->where)->elements) {
             Leaf first = (*doc->where)->elements->next;
             Leaf e     = first;
@@ -1504,6 +1504,7 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
         if (0 < wlen) {
             memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
         }
+        doc->where = where_orig;
     }
     return Qnil;
 }
@@ -1539,7 +1540,6 @@ static VALUE doc_each_value(int argc, VALUE *argv, VALUE self) {
         Leaf        leaf;
 
         if (1 <= argc) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
         }
         if (0 != (leaf = get_doc_leaf(doc, path))) {
@@ -1571,11 +1571,9 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
 
     if (1 <= argc) {
         if (Qnil != *argv) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
         }
         if (2 <= argc) {
-            Check_Type(argv[1], T_STRING);
             filename = StringValuePtr(argv[1]);
         }
     }
@@ -1583,18 +1581,15 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
         volatile VALUE rjson;
 
         if (0 == filename) {
-            char        buf[4096];
             struct _out out;
 
-            out.buf       = buf;
-            out.end       = buf + sizeof(buf) - 10;
-            out.allocated = false;
-            out.omit_nil  = oj_default_options.dump_opts.omit_nil;
+            oj_out_init(&out);
+
+            out.omit_nil = oj_default_options.dump_opts.omit_nil;
             oj_dump_leaf_to_json(leaf, &oj_default_options, &out);
             rjson = rb_str_new2(out.buf);
-            if (out.allocated) {
-                xfree(out.buf);
-            }
+
+            oj_out_free(&out);
         } else {
             oj_write_leaf_to_file(leaf, filename, &oj_default_options);
             rjson = Qnil;
@@ -1613,7 +1608,9 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
  *   Oj::Doc.open('[1,2,3]') { |doc| doc.size() }  #=> 4
  */
 static VALUE doc_size(VALUE self) {
-    return ULONG2NUM(((Doc)DATA_PTR(self))->size);
+    Doc d;
+    TypedData_Get_Struct(self, struct _doc, &oj_doc_type, d);
+    return ULONG2NUM(d->size);
 }
 
 /* @overload close() => nil
@@ -1629,11 +1626,9 @@ static VALUE doc_close(VALUE self) {
     Doc doc = self_doc(self);
 
     rb_gc_unregister_address(&doc->self);
-    DATA_PTR(doc->self) = 0;
+    DATA_PTR(doc->self) = NULL;
     if (0 != doc) {
-        xfree(doc->json);
         doc_free(doc);
-        xfree(doc);
     }
     return Qnil;
 }
@@ -1690,16 +1685,21 @@ static VALUE doc_not_implemented(VALUE self) {
  *   # Now try again using a path to Oj::Doc.fetch() directly and not using a
  * block. doc = Oj::Doc.open(json) doc.fetch('/2/three')  #=> 3 doc.close()
  */
-void oj_init_doc() {
+void oj_init_doc(void) {
     oj_doc_class = rb_define_class_under(Oj, "Doc", rb_cObject);
+    rb_gc_register_address(&oj_doc_class);
+    rb_undef_alloc_func(oj_doc_class);
     rb_define_singleton_method(oj_doc_class, "open", doc_open, 1);
     rb_define_singleton_method(oj_doc_class, "open_file", doc_open_file, 1);
     rb_define_singleton_method(oj_doc_class, "parse", doc_open, 1);
-    rb_define_method(oj_doc_class, "where?", doc_where, 0);
+    rb_define_method(oj_doc_class, "where?", doc_where_q, 0);
+    rb_define_method(oj_doc_class, "where", doc_where, 0);
+    rb_define_method(oj_doc_class, "path", doc_path, 0);
     rb_define_method(oj_doc_class, "local_key", doc_local_key, 0);
     rb_define_method(oj_doc_class, "home", doc_home, 0);
     rb_define_method(oj_doc_class, "type", doc_type, -1);
     rb_define_method(oj_doc_class, "fetch", doc_fetch, -1);
+    rb_define_method(oj_doc_class, "exists?", doc_exists, 1);
     rb_define_method(oj_doc_class, "each_leaf", doc_each_leaf, -1);
     rb_define_method(oj_doc_class, "move", doc_move, 1);
     rb_define_method(oj_doc_class, "each_child", doc_each_child, -1);