oj 3.13.0 → 3.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 659a7b0d5dc0fd786f01d8879cf94549d7ba1c7b893048222579b77455dc1654
-  data.tar.gz: 3413e8022bb3b6972a0c91acd63ca1d292bccebb9531fc8fb1f86aecfe675471
+  metadata.gz: a72c9edbd99e2e73392b5f0f5d19bee2e00187e7b999822c5c9a9086c25cc8a3
+  data.tar.gz: 7be23afd3d15f172d845ab1f852a134fe2c9d3700a197fc14ba75dd7423a4a59
 SHA512:
-  metadata.gz: 41123b593024773a786bdb12982820387da83a7dc6e385e2cd40f3a4a8b1779bbc3d2a15b8e9f52e4a69b54c4b086c453e745a33bcf21d7d237e22f1fd9e6b04
-  data.tar.gz: 4daa8aadb603184ab90b91dd91a81a74fc1c8bfcb85d77b342ffb8054bd48bda34b94d46990ace8eb07784e4e2221f4a836d304b3a1057bcf6fdb844b89997e5
+  metadata.gz: e6d92e4bff747161aa6da5619d5ece4faad452d7fd737f4c973e52808641973cbc6d56c684395f99947f222bcfc4797524d93e4f35ef55748770a32ba73d9c44
+  data.tar.gz: 9780a00f4baef37702a0ddda2e9b8c56475c69286295fdaafad6643e70825cfe8f8a69bb3dfb74791e5cc9685b6bacccb48ec23dfc250c698a19dadea19c9b71

data/ext/oj/custom.c

@@ -833,7 +833,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
             v = rb_struct_aref(obj, INT2FIX(i));
 #endif
             if (ma != Qnil) {
-                volatile VALUE s = rb_sym_to_s(rb_ary_entry(ma, i));
+                volatile VALUE s = rb_sym2str(rb_ary_entry(ma, i));
 
                 name = RSTRING_PTR(s);
                 len  = (int)RSTRING_LEN(s);

data/ext/oj/dump.c

@@ -717,10 +717,7 @@ void oj_dump_str(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 void oj_dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
-    // This causes a memory leak in 2.5.1. Maybe in other versions as well.
-    // const char	*sym = rb_id2name(SYM2ID(obj));
-
-    volatile VALUE s = rb_sym_to_s(obj);
+    volatile VALUE s = rb_sym2str(obj);
 
     oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 0, 0, out);
 }

data/ext/oj/dump_object.c

@@ -208,7 +208,7 @@ static void dump_str(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 static void dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
-    volatile VALUE s = rb_sym_to_s(obj);
+    volatile VALUE s = rb_sym2str(obj);
 
     oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 1, 0, out);
 }
@@ -694,7 +694,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
 
         *out->cur++ = '[';
         for (i = 0; i < cnt; i++) {
-            volatile VALUE s = rb_sym_to_s(rb_ary_entry(ma, i));
+            volatile VALUE s = rb_sym2str(rb_ary_entry(ma, i));
 
             name = RSTRING_PTR(s);
             len  = (int)RSTRING_LEN(s);

data/ext/oj/fast.c

@@ -200,9 +200,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;
@@ -773,7 +771,7 @@ static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
     pi.doc = doc;
 #if IS_WINDOWS
     // assume a 1M stack and give half to ruby
-    pi.stack_min = (void *)((char *)&pi - (512 * 1024));
+    pi.stack_min = (void*)((char*)&pi - (512 * 1024));
 #else
     {
         struct rlimit lim;
@@ -825,9 +823,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;
@@ -868,9 +864,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)) {
@@ -946,9 +940,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;
@@ -964,9 +956,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;
@@ -1264,7 +1254,6 @@ static VALUE doc_path(VALUE self) {
     return doc_where(self);
 }
 
-
 /* @overload local_key() => String, Fixnum, nil
  *
  * Returns the final key to the current location.

data/ext/oj/parser.c

@@ -1,24 +1,8 @@
 // Copyright (c) 2020, 2021, Peter Ohler, All rights reserved.
 
-#include "parser.h"
-
-#include <errno.h>
 #include <fcntl.h>
-#include <limits.h>
-#include <math.h>
-#include <pthread.h>
-#include <signal.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <time.h>
-#include <unistd.h>
 
+#include "parser.h"
 #include "oj.h"
 
 #define DEBUG 0
@@ -1217,7 +1201,7 @@ static VALUE parser_new(VALUE self, VALUE mode) {
 
         switch (rb_type(mode)) {
         case RUBY_T_SYMBOL:
-            mode = rb_sym_to_s(mode);
+            mode = rb_sym2str(mode);
             // fall through
         case RUBY_T_STRING: ms = RSTRING_PTR(mode); break;
         default:
@@ -1290,7 +1274,7 @@ static VALUE parser_missing(int argc, VALUE *argv, VALUE self) {
 #endif
     switch (rb_type(rkey)) {
     case RUBY_T_SYMBOL:
-        rkey = rb_sym_to_s(rkey);
+        rkey = rb_sym2str(rkey);
         // fall through
     case RUBY_T_STRING: key = rb_string_value_ptr(&rkey); break;
     default: rb_raise(rb_eArgError, "option method must be a symbol or string");

data/ext/oj/rails.c

@@ -157,7 +157,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     assure_size(out, 2);
     *out->cur++ = '{';
     for (i = 0; i < cnt; i++) {
-        volatile VALUE s = rb_sym_to_s(rb_ary_entry(ma, i));
+        volatile VALUE s = rb_sym2str(rb_ary_entry(ma, i));
 
         name = RSTRING_PTR(s);
         len  = (int)RSTRING_LEN(s);

data/ext/oj/usual.c

@@ -903,7 +903,7 @@ static VALUE opt_decimal_set(ojParser p, VALUE value) {
     switch (rb_type(value)) {
     case T_STRING: mode = RSTRING_PTR(value); break;
     case T_SYMBOL:
-        s    = rb_sym_to_s(value);
+        s    = rb_sym2str(value);
         mode = RSTRING_PTR(s);
         break;
     default:
@@ -1020,7 +1020,7 @@ static VALUE opt_missing_class_set(ojParser p, VALUE value) {
     switch (rb_type(value)) {
     case T_STRING: mode = RSTRING_PTR(value); break;
     case T_SYMBOL:
-        s    = rb_sym_to_s(value);
+        s    = rb_sym2str(value);
         mode = RSTRING_PTR(s);
         break;
     default:

data/lib/oj/version.rb

@@ -1,5 +1,5 @@
 
 module Oj
   # Current version of the module.
-  VERSION = '3.13.0'
+  VERSION = '3.13.1'
 end

data/test/json_gem/json_common_interface_test.rb

@@ -23,7 +23,7 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
       'h' => 1000.0,
       'i' => 0.001
     }
-    # Tired of chasing floating point rounding and precision. Oj not uses the
+    # Tired of chasing floating point rounding and precision. Oj now uses the
     # Ruby float parser in compat mode yet on i386 machines there are issues
     # with this test when the float is included.
     #@json = '{"a":2,"b":5.23683071,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 3.13.0
+  version: 3.13.1
 platform: ruby
 authors:
 - Peter Ohler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-08 00:00:00.000000000 Z
+date: 2021-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -116,7 +116,6 @@ files:
 - ext/oj/err.h
 - ext/oj/extconf.rb
 - ext/oj/fast.c
-- ext/oj/hash_test.c
 - ext/oj/intern.c
 - ext/oj/intern.h
 - ext/oj/mimic_json.c

data/ext/oj/hash_test.c

@@ -1,464 +0,0 @@
-// Copyright (c) 2011 Peter Ohler. All rights reserved.
-// Licensed under the MIT License. See LICENSE file in the project root for license details.
-
-// if windows, comment out the whole file. It's only a performance test.
-#ifndef _WIN32
-#include "intern.h"
-
-#include <stdint.h>
-#include <sys/time.h>
-#include <time.h>
-
-/* Define printf formats for standard types, like PRIu64 for uint64_t. */
-#define __STDC_FORMAT_MACROS
-#include <inttypes.h>
-
-typedef struct _strLen {
-    const char *str;
-    size_t      len;
-} * StrLen;
-
-static struct _strLen data[] = {{"Gem::Version", 12},
-                                {"TracePoint", 10},
-                                {"Complex::compatible", 19},
-                                {"Complex", 7},
-                                {"Rational::compatible", 20},
-                                {"Rational", 8},
-                                {"FiberError", 10},
-                                {"Fiber", 5},
-                                {"ThreadError", 11},
-                                {"Mutex", 5},
-                                {"ThreadGroup", 11},
-                                {"RubyVM::InstructionSequence", 27},
-                                {"Thread::Backtrace::Location", 27},
-                                {"Thread::Backtrace", 17},
-                                {"Thread", 6},
-                                {"RubyVM::Env", 11},
-                                {"RubyVM", 6},
-                                {"Enumerator::Yielder", 19},
-                                {"Enumerator::Generator", 21},
-                                {"StopIteration", 13},
-                                {"Enumerator::Lazy", 16},
-                                {"Enumerator", 10},
-                                {"ObjectSpace::WeakMap", 20},
-                                {"Math::DomainError", 17},
-                                {"Binding", 7},
-                                {"UnboundMethod", 13},
-                                {"Method", 6},
-                                {"SystemStackError", 16},
-                                {"LocalJumpError", 14},
-                                {"Proc", 4},
-                                {"Struct::Tms", 11},
-                                {"Process::Status", 15},
-                                {"Random", 6},
-                                {"Time", 4},
-                                {"Dir", 3},
-                                {"File::Stat", 10},
-                                {"File", 4},
-                                {"ARGF.class", 10},
-                                {"IO", 2},
-                                {"EOFError", 8},
-                                {"IOError", 7},
-                                {"Range", 5},
-                                {"Encoding::Converter", 19},
-                                {"Encoding::ConverterNotFoundError", 32},
-                                {"Encoding::InvalidByteSequenceError", 34},
-                                {"Encoding::UndefinedConversionError", 34},
-                                {"MatchData", 9},
-                                {"Regexp", 6},
-                                {"RegexpError", 11},
-                                {"Struct", 6},
-                                {"Hash", 4},
-                                {"Array", 5},
-                                {"Errno::ERPCMISMATCH", 19},
-                                {"Errno::EPROGUNAVAIL", 19},
-                                {"Errno::EPROGMISMATCH", 20},
-                                {"Errno::EPROCUNAVAIL", 19},
-                                {"Errno::EPROCLIM", 15},
-                                {"Errno::ENOTSUP", 14},
-                                {"Errno::ENOATTR", 14},
-                                {"Errno::ENEEDAUTH", 16},
-                                {"Errno::EFTYPE", 13},
-                                {"Errno::EBADRPC", 14},
-                                {"Errno::EAUTH", 12},
-                                {"Errno::EOWNERDEAD", 17},
-                                {"Errno::ENOTRECOVERABLE", 22},
-                                {"Errno::ECANCELED", 16},
-                                {"Errno::EDQUOT", 13},
-                                {"Errno::ESTALE", 13},
-                                {"Errno::EINPROGRESS", 18},
-                                {"Errno::EALREADY", 15},
-                                {"Errno::EHOSTUNREACH", 19},
-                                {"Errno::EHOSTDOWN", 16},
-                                {"Errno::ECONNREFUSED", 19},
-                                {"Errno::ETIMEDOUT", 16},
-                                {"Errno::ETOOMANYREFS", 19},
-                                {"Errno::ESHUTDOWN", 16},
-                                {"Errno::ENOTCONN", 15},
-                                {"Errno::EISCONN", 14},
-                                {"Errno::ENOBUFS", 14},
-                                {"Errno::ECONNRESET", 17},
-                                {"Errno::ECONNABORTED", 19},
-                                {"Errno::ENETRESET", 16},
-                                {"Errno::ENETUNREACH", 18},
-                                {"Errno::ENETDOWN", 15},
-                                {"Errno::EADDRNOTAVAIL", 20},
-                                {"Errno::EADDRINUSE", 17},
-                                {"Errno::EAFNOSUPPORT", 19},
-                                {"Errno::EPFNOSUPPORT", 19},
-                                {"Errno::EOPNOTSUPP", 17},
-                                {"Errno::ESOCKTNOSUPPORT", 22},
-                                {"Errno::EPROTONOSUPPORT", 22},
-                                {"Errno::ENOPROTOOPT", 18},
-                                {"Errno::EPROTOTYPE", 17},
-                                {"Errno::EMSGSIZE", 15},
-                                {"Errno::EDESTADDRREQ", 19},
-                                {"Errno::ENOTSOCK", 15},
-                                {"Errno::EUSERS", 13},
-                                {"Errno::EILSEQ", 13},
-                                {"Errno::EOVERFLOW", 16},
-                                {"Errno::EBADMSG", 14},
-                                {"Errno::EMULTIHOP", 16},
-                                {"Errno::EPROTO", 13},
-                                {"Errno::ENOLINK", 14},
-                                {"Errno::EREMOTE", 14},
-                                {"Errno::ENOSR", 12},
-                                {"Errno::ETIME", 12},
-                                {"Errno::ENODATA", 14},
-                                {"Errno::ENOSTR", 13},
-                                {"Errno::EIDRM", 12},
-                                {"Errno::ENOMSG", 13},
-                                {"Errno::ELOOP", 12},
-                                {"Errno::ENOTEMPTY", 16},
-                                {"Errno::ENOSYS", 13},
-                                {"Errno::ENOLCK", 13},
-                                {"Errno::ENAMETOOLONG", 19},
-                                {"Errno::EDEADLK", 14},
-                                {"Errno::ERANGE", 13},
-                                {"Errno::EDOM", 11},
-                                {"Errno::EPIPE", 12},
-                                {"Errno::EMLINK", 13},
-                                {"Errno::EROFS", 12},
-                                {"Errno::ESPIPE", 13},
-                                {"Errno::ENOSPC", 13},
-                                {"Errno::EFBIG", 12},
-                                {"Errno::ETXTBSY", 14},
-                                {"Errno::ENOTTY", 13},
-                                {"Errno::EMFILE", 13},
-                                {"Errno::ENFILE", 13},
-                                {"Errno::EINVAL", 13},
-                                {"Errno::EISDIR", 13},
-                                {"Errno::ENOTDIR", 14},
-                                {"Errno::ENODEV", 13},
-                                {"Errno::EXDEV", 12},
-                                {"Errno::EEXIST", 13},
-                                {"Errno::EBUSY", 12},
-                                {"Errno::ENOTBLK", 14},
-                                {"Errno::EFAULT", 13},
-                                {"Errno::EACCES", 13},
-                                {"Errno::ENOMEM", 13},
-                                {"Errno::EAGAIN", 13},
-                                {"Errno::ECHILD", 13},
-                                {"Errno::EBADF", 12},
-                                {"Errno::ENOEXEC", 14},
-                                {"Errno::E2BIG", 12},
-                                {"Errno::ENXIO", 12},
-                                {"Errno::EIO", 10},
-                                {"Errno::EINTR", 12},
-                                {"Errno::ESRCH", 12},
-                                {"Errno::ENOENT", 13},
-                                {"Errno::EPERM", 12},
-                                {"Errno::NOERROR", 14},
-                                {"Bignum", 6},
-                                {"Float", 5},
-                                {"Fixnum", 6},
-                                {"Integer", 7},
-                                {"Numeric", 7},
-                                {"FloatDomainError", 16},
-                                {"ZeroDivisionError", 17},
-                                {"SystemCallError", 15},
-                                {"Encoding::CompatibilityError", 28},
-                                {"EncodingError", 13},
-                                {"NoMemoryError", 13},
-                                {"SecurityError", 13},
-                                {"RuntimeError", 12},
-                                {"NoMethodError", 13},
-                                {"NameError::message", 18},
-                                {"NameError", 9},
-                                {"NotImplementedError", 19},
-                                {"LoadError", 9},
-                                {"SyntaxError", 11},
-                                {"ScriptError", 11},
-                                {"RangeError", 10},
-                                {"KeyError", 8},
-                                {"IndexError", 10},
-                                {"ArgumentError", 13},
-                                {"TypeError", 9},
-                                {"StandardError", 13},
-                                {"Interrupt", 9},
-                                {"SignalException", 15},
-                                {"SystemExit", 10},
-                                {"Exception", 9},
-                                {"Symbol", 6},
-                                {"String", 6},
-                                {"Encoding", 8},
-                                {"FalseClass", 10},
-                                {"TrueClass", 9},
-                                {"Data", 4},
-                                {"NilClass", 8},
-                                {"Class", 5},
-                                {"Module", 6},
-                                {"Object", 6},
-                                {"BasicObject", 11},
-                                {"Gem::Requirement::BadRequirementError", 37},
-                                {"Gem::Requirement", 16},
-                                {"Gem::SourceFetchProblem", 23},
-                                {"Gem::PlatformMismatch", 21},
-                                {"Gem::ErrorReason", 16},
-                                {"Gem::LoadError", 14},
-                                {"Gem::RemoteSourceException", 26},
-                                {"Gem::RemoteInstallationSkipped", 30},
-                                {"Gem::RemoteInstallationCancelled", 32},
-                                {"Gem::RemoteError", 16},
-                                {"Gem::OperationNotSupportedError", 31},
-                                {"Gem::InvalidSpecificationException", 34},
-                                {"Gem::InstallError", 17},
-                                {"Gem::Specification", 18},
-                                {"Date", 4},
-                                {"Gem::Platform", 13},
-                                {"Gem::SpecificGemNotFoundException", 33},
-                                {"Gem::GemNotFoundException", 25},
-                                {"Gem::FormatException", 20},
-                                {"Gem::FilePermissionError", 24},
-                                {"Gem::EndOfYAMLException", 23},
-                                {"Gem::DocumentError", 18},
-                                {"Gem::GemNotInHomeException", 26},
-                                {"Gem::DependencyRemovalException", 31},
-                                {"Gem::DependencyError", 20},
-                                {"Gem::CommandLineError", 21},
-                                {"Gem::Exception", 14},
-                                {"IRB::SLex", 9},
-                                {"IRB::Notifier::NoMsgNotifier", 28},
-                                {"IRB::Notifier::LeveledNotifier", 30},
-                                {"IRB::Notifier::CompositeNotifier", 32},
-                                {"IRB::Notifier::AbstractNotifier", 31},
-                                {"IRB::Notifier::ErrUnrecognizedLevel", 35},
-                                {"IRB::Notifier::ErrUndefinedNotifier", 35},
-                                {"IRB::StdioOutputMethod", 22},
-                                {"IRB::OutputMethod::NotImplementedError", 38},
-                                {"IRB::OutputMethod", 17},
-                                {"IRB::IllegalRCGenerator", 23},
-                                {"IRB::UndefinedPromptMode", 24},
-                                {"IRB::CantChangeBinding", 22},
-                                {"IRB::CantShiftToMultiIrbMode", 28},
-                                {"IRB::NoSuchJob", 14},
-                                {"IRB::IrbSwitchedToCurrentThread", 31},
-                                {"IRB::IrbAlreadyDead", 19},
-                                {"IRB::IllegalParameter", 21},
-                                {"IRB::CantReturnToNormalMode", 27},
-                                {"IRB::NotImplementedError", 24},
-                                {"IRB::UnrecognizedSwitch", 23},
-                                {"IRB::Irb", 8},
-                                {"IRB::Abort", 10},
-                                {"IRB::Locale", 11},
-                                {"IRB::SLex::ErrNodeNothing", 25},
-                                {"IRB::SLex::ErrNodeAlreadyExists", 31},
-                                {"RubyLex", 7},
-                                {"IRB::SLex::Node", 15},
-                                {"Gem::SystemExitException", 24},
-                                {"Gem::VerificationError", 22},
-                                {"RubyToken::TkError", 18},
-                                {"RubyToken::TkUnknownChar", 24},
-                                {"RubyToken::TkOPASGN", 19},
-                                {"RubyToken::TkOp", 15},
-                                {"RubyToken::TkVal", 16},
-                                {"RubyToken::TkId", 15},
-                                {"RubyToken::TkNode", 17},
-                                {"RubyToken::Token", 16},
-                                {"RubyToken::TkUNDEF", 18},
-                                {"RubyToken::TkDEF", 16},
-                                {"RubyToken::TkMODULE", 19},
-                                {"RubyToken::TkCLASS", 18},
-                                {"RubyToken::TkWHILE", 18},
-                                {"RubyToken::TkWHEN", 17},
-                                {"RubyToken::TkCASE", 17},
-                                {"RubyToken::TkELSE", 17},
-                                {"RubyToken::TkELSIF", 18},
-                                {"RubyToken::TkTHEN", 17},
-                                {"RubyToken::TkUNLESS", 19},
-                                {"RubyToken::TkIF", 15},
-                                {"RubyToken::TkEND", 16},
-                                {"RubyToken::TkENSURE", 19},
-                                {"RubyToken::TkRESCUE", 19},
-                                {"RubyToken::TkBEGIN", 18},
-                                {"RubyToken::TkDO", 15},
-                                {"RubyToken::TkIN", 15},
-                                {"RubyToken::TkRETRY", 18},
-                                {"RubyToken::TkREDO", 17},
-                                {"RubyToken::TkNEXT", 17},
-                                {"RubyToken::TkBREAK", 18},
-                                {"RubyToken::TkFOR", 16},
-                                {"RubyToken::TkUNTIL", 18},
-                                {"RubyToken::TkTRUE", 17},
-                                {"RubyToken::TkNIL", 16},
-                                {"RubyToken::TkSELF", 17},
-                                {"RubyToken::TkSUPER", 18},
-                                {"RubyToken::TkYIELD", 18},
-                                {"RubyToken::TkRETURN", 19},
-                                {"RubyToken::TkAND", 16},
-                                {"RubyToken::TkFALSE", 18},
-                                {"RubyToken::TkUNLESS_MOD", 23},
-                                {"RubyToken::TkIF_MOD", 19},
-                                {"RubyToken::TkNOT", 16},
-                                {"RubyToken::TkOR", 15},
-                                {"RubyToken::TkALIAS", 18},
-                                {"RubyToken::TkUNTIL_MOD", 22},
-                                {"RubyToken::TkWHILE_MOD", 22},
-                                {"RubyToken::TkGVAR", 17},
-                                {"RubyToken::TkFID", 16},
-                                {"RubyToken::TkIDENTIFIER", 23},
-                                {"RubyToken::Tk__FILE__", 21},
-                                {"RubyToken::Tk__LINE__", 21},
-                                {"RubyToken::TklEND", 17},
-                                {"RubyToken::TklBEGIN", 19},
-                                {"RubyToken::TkDEFINED", 20},
-                                {"RubyToken::TkDREGEXP", 20},
-                                {"RubyToken::TkDXSTRING", 21},
-                                {"RubyToken::TkDSTRING", 20},
-                                {"RubyToken::TkSYMBOL", 19},
-                                {"RubyToken::TkREGEXP", 19},
-                                {"RubyToken::TkXSTRING", 20},
-                                {"RubyToken::TkSTRING", 19},
-                                {"RubyToken::TkFLOAT", 18},
-                                {"RubyToken::TkINTEGER", 20},
-                                {"RubyToken::TkCONSTANT", 21},
-                                {"RubyToken::TkIVAR", 17},
-                                {"RubyToken::TkCVAR", 17},
-                                {"RubyToken::TkNEQ", 16},
-                                {"RubyToken::TkEQQ", 16},
-                                {"RubyToken::TkEQ", 15},
-                                {"RubyToken::TkCMP", 16},
-                                {"RubyToken::TkPOW", 16},
-                                {"RubyToken::TkUMINUS", 19},
-                                {"RubyToken::TkUPLUS", 18},
-                                {"Exception2MessageMapper::ErrNotRegisteredException", 50},
-                                {"RubyToken::TkBACK_REF", 21},
-                                {"RubyToken::TkNTH_REF", 20},
-                                {"RubyToken::TkLSHFT", 18},
-                                {"RubyToken::TkASET", 17},
-                                {"RubyToken::TkAREF", 17},
-                                {"RubyToken::TkDOT3", 17},
-                                {"RubyToken::TkDOT2", 17},
-                                {"RubyToken::TkNMATCH", 19},
-                                {"RubyToken::TkMATCH", 18},
-                                {"RubyToken::TkOROP", 17},
-                                {"RubyToken::TkANDOP", 18},
-                                {"RubyToken::TkLEQ", 16},
-                                {"RubyToken::TkGEQ", 16},
-                                {"RubyToken::TkAMPER", 18},
-                                {"RubyToken::TkSTAR", 17},
-                                {"RubyToken::TkfLBRACE", 20},
-                                {"RubyToken::TkfLBRACK", 20},
-                                {"RubyToken::TkfLPAREN", 20},
-                                {"RubyToken::TkCOLON", 18},
-                                {"RubyToken::TkQUESTION", 21},
-                                {"RubyToken::TkASSOC", 18},
-                                {"RubyToken::TkCOLON3", 19},
-                                {"RubyToken::TkCOLON2", 19},
-                                {"RubyToken::TkRSHFT", 18},
-                                {"RubyToken::TkBITAND", 19},
-                                {"RubyToken::TkBITXOR", 19},
-                                {"RubyToken::TkBITOR", 18},
-                                {"RubyToken::TkMOD", 16},
-                                {"RubyToken::TkDIV", 16},
-                                {"RubyToken::TkMULT", 17},
-                                {"RubyToken::TkMINUS", 18},
-                                {"RubyToken::TkPLUS", 17},
-                                {"RubyToken::TkLT", 15},
-                                {"RubyToken::TkGT", 15},
-                                {"RubyToken::TkSYMBEG", 19},
-                                {"IRB::DefaultEncodings", 21},
-                                {"RubyToken::TkRPAREN", 19},
-                                {"RubyToken::TkLBRACE", 19},
-                                {"RubyToken::TkLBRACK", 19},
-                                {"RubyToken::TkLPAREN", 19},
-                                {"RubyToken::TkDOT", 16},
-                                {"RubyToken::TkASSIGN", 19},
-                                {"RubyToken::TkBACKQUOTE", 22},
-                                {"RubyToken::TkNOTOP", 18},
-                                {"RubyToken::TkBITNOT", 19},
-                                {"RubyToken::TkDOLLAR", 19},
-                                {"RubyToken::TkAT", 15},
-                                {"RubyToken::TkBACKSLASH", 22},
-                                {"RubyToken::TkEND_OF_SCRIPT", 26},
-                                {"RubyToken::TkNL", 15},
-                                {"RubyToken::TkSPACE", 18},
-                                {"RubyToken::TkRD_COMMENT", 23},
-                                {"RubyToken::TkCOMMENT", 20},
-                                {"RubyToken::TkSEMICOLON", 22},
-                                {"RubyToken::TkCOMMA", 18},
-                                {"RubyToken::TkRBRACE", 19},
-                                {"RubyToken::TkRBRACK", 19},
-                                {"RubyLex::TerminateLineInput", 27},
-                                {"RubyLex::SyntaxError", 20},
-                                {"RubyLex::TkReading2TokenDuplicateError", 38},
-                                {"RubyLex::TkSymbol2TokenNoKey", 28},
-                                {"RubyLex::TkReading2TokenNoKey", 29},
-                                {"RubyLex::AlreadyDefinedToken", 28},
-                                {"IRB::FileInputMethod", 20},
-                                {"IRB::StdioInputMethod", 21},
-                                {"IRB::InputMethod", 16},
-                                {"IRB::ReadlineInputMethod", 24},
-                                {"IRB::Context", 12},
-                                {"IRB::Inspector", 14},
-                                {"IRB::WorkSpace", 14},
-                                {0, 0}};
-
-static uint64_t micro_time() {
-    struct timeval tv;
-
-    gettimeofday(&tv, NULL);
-
-    return (uint64_t)tv.tv_sec * 1000000ULL + (uint64_t)tv.tv_usec;
-}
-
-static void perf() {
-    StrLen   d;
-    uint64_t dt, start;
-    int      i, iter = 1000000;
-    int      dataCnt = sizeof(data) / sizeof(*data);
-
-    oj_hash_init();
-    start = micro_time();
-    for (i = iter; 0 < i; i--) {
-        for (d = data; 0 != d->str; d++) {
-	    oj_class_intern(d->str, d->len, false, NULL, false, Qnil);
-        }
-    }
-    dt = micro_time() - start;
-#if IS_WINDOWS
-    printf("%d iterations took %ld msecs, %ld gets/msec\n",
-           iter,
-           (long)(dt / 1000),
-           (long)(iter * dataCnt / (dt / 1000)));
-#else
-    printf("%d iterations took %" PRIu64 " msecs, %ld gets/msec\n",
-           iter,
-           dt / 1000,
-           (long)(iter * dataCnt / (dt / 1000)));
-#endif
-}
-
-void oj_hash_test() {
-    StrLen d;
-
-    oj_hash_init();
-    for (d = data; 0 != d->str; d++) {
-	oj_class_intern(d->str, d->len, false, NULL, false, Qnil);
-        /*oj_hash_print(c);*/
-    }
-    printf("*** ---------- hash table ------------\n");
-    oj_hash_print();
-    perf();
-}
-#endif