json 2.6.3 → 2.13.0

data/ext/json/ext/parser/parser.c

@@ -1,3347 +1,1507 @@
-/* This file is automatically generated from parser.rl by using ragel */
-#line 1 "parser.rl"
-#include "../fbuffer/fbuffer.h"
-#include "parser.h"
-
-#if defined HAVE_RUBY_ENCODING_H
-# define EXC_ENCODING rb_utf8_encoding(),
-# ifndef HAVE_RB_ENC_RAISE
-static void
-enc_raise(rb_encoding *enc, VALUE exc, const char *fmt, ...)
-{
-	va_list args;
-	VALUE mesg;
+#include "ruby.h"
+#include "ruby/encoding.h"
 
-	va_start(args, fmt);
-	mesg = rb_enc_vsprintf(enc, fmt, args);
-	va_end(args);
+/* shims */
+/* This is the fallback definition from Ruby 3.4 */
 
-	rb_exc_raise(rb_exc_new3(exc, mesg));
-}
-#   define rb_enc_raise enc_raise
+#ifndef RBIMPL_STDBOOL_H
+#if defined(__cplusplus)
+# if defined(HAVE_STDBOOL_H) && (__cplusplus >= 201103L)
+#  include <cstdbool>
 # endif
-#else
-# define EXC_ENCODING /* nothing */
-# define rb_enc_raise rb_raise
+#elif defined(HAVE_STDBOOL_H)
+# include <stdbool.h>
+#elif !defined(HAVE__BOOL)
+typedef unsigned char _Bool;
+# define bool  _Bool
+# define true  ((_Bool)+1)
+# define false ((_Bool)+0)
+# define __bool_true_false_are_defined
+#endif
 #endif
 
-/* unicode */
-
-static const signed char digit_values[256] = {
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1,
-	-1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1
-};
+#include "../simd/simd.h"
 
-static UTF32 unescape_unicode(const unsigned char *p)
-{
-	signed char b;
-	UTF32 result = 0;
-	b = digit_values[p[0]];
-	if (b < 0) return UNI_REPLACEMENT_CHAR;
-	result = (result << 4) | (unsigned char)b;
-	b = digit_values[p[1]];
-	if (b < 0) return UNI_REPLACEMENT_CHAR;
-	result = (result << 4) | (unsigned char)b;
-	b = digit_values[p[2]];
-	if (b < 0) return UNI_REPLACEMENT_CHAR;
-	result = (result << 4) | (unsigned char)b;
-	b = digit_values[p[3]];
-	if (b < 0) return UNI_REPLACEMENT_CHAR;
-	result = (result << 4) | (unsigned char)b;
-	return result;
-}
+#ifndef RB_UNLIKELY
+#define RB_UNLIKELY(expr) expr
+#endif
 
-static int convert_UTF32_to_UTF8(char *buf, UTF32 ch)
-{
-	int len = 1;
-	if (ch <= 0x7F) {
-		buf[0] = (char) ch;
-	} else if (ch <= 0x07FF) {
-		buf[0] = (char) ((ch >> 6) | 0xC0);
-		buf[1] = (char) ((ch & 0x3F) | 0x80);
-		len++;
-	} else if (ch <= 0xFFFF) {
-		buf[0] = (char) ((ch >> 12) | 0xE0);
-		buf[1] = (char) (((ch >> 6) & 0x3F) | 0x80);
-		buf[2] = (char) ((ch & 0x3F) | 0x80);
-		len += 2;
-	} else if (ch <= 0x1fffff) {
-		buf[0] =(char) ((ch >> 18) | 0xF0);
-		buf[1] =(char) (((ch >> 12) & 0x3F) | 0x80);
-		buf[2] =(char) (((ch >> 6) & 0x3F) | 0x80);
-		buf[3] =(char) ((ch & 0x3F) | 0x80);
-		len += 3;
-	} else {
-		buf[0] = '?';
-	}
-	return len;
-}
+#ifndef RB_LIKELY
+#define RB_LIKELY(expr) expr
+#endif
 
-static VALUE mJSON, mExt, cParser, eParserError, eNestingError;
+static VALUE mJSON, eNestingError, Encoding_UTF_8;
 static VALUE CNaN, CInfinity, CMinusInfinity;
 
-static ID i_json_creatable_p, i_json_create, i_create_id, i_create_additions,
-i_chr, i_max_nesting, i_allow_nan, i_symbolize_names,
-i_object_class, i_array_class, i_decimal_class, i_key_p,
-i_deep_const_get, i_match, i_match_string, i_aset, i_aref,
-i_leftshift, i_new, i_try_convert, i_freeze, i_uminus;
-
+static ID i_chr, i_aset, i_aref,
+          i_leftshift, i_new, i_try_convert, i_uminus, i_encode;
 
-#line 125 "parser.rl"
+static VALUE sym_max_nesting, sym_allow_nan, sym_allow_trailing_comma, sym_symbolize_names, sym_freeze,
+             sym_decimal_class, sym_on_load, sym_allow_duplicate_key;
 
+static int binary_encindex;
+static int utf8_encindex;
 
+#ifndef HAVE_RB_HASH_BULK_INSERT
+// For TruffleRuby
+void
+rb_hash_bulk_insert(long count, const VALUE *pairs, VALUE hash)
+{
+    long index = 0;
+    while (index < count) {
+        VALUE name = pairs[index++];
+        VALUE value = pairs[index++];
+        rb_hash_aset(hash, name, value);
+    }
+    RB_GC_GUARD(hash);
+}
+#endif
 
-enum {JSON_object_start = 1};
-enum {JSON_object_first_final = 27};
-enum {JSON_object_error = 0};
+#ifndef HAVE_RB_HASH_NEW_CAPA
+#define rb_hash_new_capa(n) rb_hash_new()
+#endif
 
-enum {JSON_object_en_main = 1};
 
-static const char MAYBE_UNUSED(_JSON_object_nfa_targs)[] = {
-	0, 0
-};
+/* name cache */
 
-static const char MAYBE_UNUSED(_JSON_object_nfa_offsets)[] = {
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0
-};
+#include <string.h>
+#include <ctype.h>
 
-static const char MAYBE_UNUSED(_JSON_object_nfa_push_actions)[] = {
-	0, 0
-};
+// Object names are likely to be repeated, and are frozen.
+// As such we can re-use them if we keep a cache of the ones we've seen so far,
+// and save much more expensive lookups into the global fstring table.
+// This cache implementation is deliberately simple, as we're optimizing for compactness,
+// to be able to fit safely on the stack.
+// As such, binary search into a sorted array gives a good tradeoff between compactness and
+// performance.
+#define JSON_RVALUE_CACHE_CAPA 63
+typedef struct rvalue_cache_struct {
+    int length;
+    VALUE entries[JSON_RVALUE_CACHE_CAPA];
+} rvalue_cache;
 
-static const char MAYBE_UNUSED(_JSON_object_nfa_pop_trans)[] = {
-	0, 0
-};
+static rb_encoding *enc_utf8;
 
+#define JSON_RVALUE_CACHE_MAX_ENTRY_LENGTH 55
 
-#line 167 "parser.rl"
+static inline VALUE build_interned_string(const char *str, const long length)
+{
+# ifdef HAVE_RB_ENC_INTERNED_STR
+    return rb_enc_interned_str(str, length, enc_utf8);
+# else
+    VALUE rstring = rb_utf8_str_new(str, length);
+    return rb_funcall(rb_str_freeze(rstring), i_uminus, 0);
+# endif
+}
 
+static inline VALUE build_symbol(const char *str, const long length)
+{
+    return rb_str_intern(build_interned_string(str, length));
+}
 
-static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting)
+static void rvalue_cache_insert_at(rvalue_cache *cache, int index, VALUE rstring)
 {
-	int cs = EVIL;
-	VALUE last_name = Qnil;
-	VALUE object_class = json->object_class;
-
-	if (json->max_nesting && current_nesting > json->max_nesting) {
-		rb_raise(eNestingError, "nesting of %d is too deep", current_nesting);
-	}
-
-	*result = NIL_P(object_class) ? rb_hash_new() : rb_class_new_instance(0, 0, object_class);
-
-
-	{
-		cs = (int)JSON_object_start;
-	}
-
-	#line 182 "parser.rl"
-
-
-	{
-		if ( p == pe )
-		goto _test_eof;
-		switch ( cs )
-		{
-			case 1:
-			goto st_case_1;
-			case 0:
-			goto st_case_0;
-			case 2:
-			goto st_case_2;
-			case 3:
-			goto st_case_3;
-			case 4:
-			goto st_case_4;
-			case 5:
-			goto st_case_5;
-			case 6:
-			goto st_case_6;
-			case 7:
-			goto st_case_7;
-			case 8:
-			goto st_case_8;
-			case 9:
-			goto st_case_9;
-			case 10:
-			goto st_case_10;
-			case 11:
-			goto st_case_11;
-			case 12:
-			goto st_case_12;
-			case 13:
-			goto st_case_13;
-			case 14:
-			goto st_case_14;
-			case 15:
-			goto st_case_15;
-			case 16:
-			goto st_case_16;
-			case 17:
-			goto st_case_17;
-			case 18:
-			goto st_case_18;
-			case 27:
-			goto st_case_27;
-			case 19:
-			goto st_case_19;
-			case 20:
-			goto st_case_20;
-			case 21:
-			goto st_case_21;
-			case 22:
-			goto st_case_22;
-			case 23:
-			goto st_case_23;
-			case 24:
-			goto st_case_24;
-			case 25:
-			goto st_case_25;
-			case 26:
-			goto st_case_26;
-		}
-		goto st_out;
-		st_case_1:
-		if ( ( (*( p))) == 123 ) {
-			goto st2;
-		}
-		{
-			goto st0;
-		}
-		st_case_0:
-		st0:
-		cs = 0;
-		goto _out;
-		st2:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof2;
-		st_case_2:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st2;
-			}
-			case 32: {
-				goto st2;
-			}
-			case 34: {
-				goto ctr2;
-			}
-			case 47: {
-				goto st23;
-			}
-			case 125: {
-				goto ctr4;
-			}
-		}
-		if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
-			goto st2;
-		}
-		{
-			goto st0;
-		}
-		ctr2:
-		{
-			#line 149 "parser.rl"
-
-			char *np;
-			json->parsing_name = 1;
-			np = JSON_parse_string(json, p, pe, &last_name);
-			json->parsing_name = 0;
-			if (np == NULL) { {p = p - 1; } {p+= 1; cs = 3; goto _out;} } else {p = (( np))-1;}
-
-		}
-
-		goto st3;
-		st3:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof3;
-		st_case_3:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st3;
-			}
-			case 32: {
-				goto st3;
-			}
-			case 47: {
-				goto st4;
-			}
-			case 58: {
-				goto st8;
-			}
-		}
-		if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
-			goto st3;
-		}
-		{
-			goto st0;
-		}
-		st4:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof4;
-		st_case_4:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st5;
-			}
-			case 47: {
-				goto st7;
-			}
-		}
-		{
-			goto st0;
-		}
-		st5:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof5;
-		st_case_5:
-		if ( ( (*( p))) == 42 ) {
-			goto st6;
-		}
-		{
-			goto st5;
-		}
-		st6:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof6;
-		st_case_6:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st6;
-			}
-			case 47: {
-				goto st3;
-			}
-		}
-		{
-			goto st5;
-		}
-		st7:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof7;
-		st_case_7:
-		if ( ( (*( p))) == 10 ) {
-			goto st3;
-		}
-		{
-			goto st7;
-		}
-		st8:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof8;
-		st_case_8:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st8;
-			}
-			case 32: {
-				goto st8;
-			}
-			case 34: {
-				goto ctr11;
-			}
-			case 45: {
-				goto ctr11;
-			}
-			case 47: {
-				goto st19;
-			}
-			case 73: {
-				goto ctr11;
-			}
-			case 78: {
-				goto ctr11;
-			}
-			case 91: {
-				goto ctr11;
-			}
-			case 102: {
-				goto ctr11;
-			}
-			case 110: {
-				goto ctr11;
-			}
-			case 116: {
-				goto ctr11;
-			}
-			case 123: {
-				goto ctr11;
-			}
-		}
-		if ( ( (*( p))) > 10 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto ctr11;
-			}
-		} else if ( ( (*( p))) >= 9 ) {
-			goto st8;
-		}
-		{
-			goto st0;
-		}
-		ctr11:
-		{
-			#line 133 "parser.rl"
-
-			VALUE v = Qnil;
-			char *np = JSON_parse_value(json, p, pe, &v, current_nesting);
-			if (np == NULL) {
-				{p = p - 1; } {p+= 1; cs = 9; goto _out;}
-			} else {
-				if (NIL_P(json->object_class)) {
-					OBJ_FREEZE(last_name);
-					rb_hash_aset(*result, last_name, v);
-				} else {
-					rb_funcall(*result, i_aset, 2, last_name, v);
-				}
-				{p = (( np))-1;}
-
-			}
-		}
-
-		goto st9;
-		st9:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof9;
-		st_case_9:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st9;
-			}
-			case 32: {
-				goto st9;
-			}
-			case 44: {
-				goto st10;
-			}
-			case 47: {
-				goto st15;
-			}
-			case 125: {
-				goto ctr4;
-			}
-		}
-		if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
-			goto st9;
-		}
-		{
-			goto st0;
-		}
-		st10:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof10;
-		st_case_10:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st10;
-			}
-			case 32: {
-				goto st10;
-			}
-			case 34: {
-				goto ctr2;
-			}
-			case 47: {
-				goto st11;
-			}
-		}
-		if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
-			goto st10;
-		}
-		{
-			goto st0;
-		}
-		st11:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof11;
-		st_case_11:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st12;
-			}
-			case 47: {
-				goto st14;
-			}
-		}
-		{
-			goto st0;
-		}
-		st12:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof12;
-		st_case_12:
-		if ( ( (*( p))) == 42 ) {
-			goto st13;
-		}
-		{
-			goto st12;
-		}
-		st13:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof13;
-		st_case_13:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st13;
-			}
-			case 47: {
-				goto st10;
-			}
-		}
-		{
-			goto st12;
-		}
-		st14:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof14;
-		st_case_14:
-		if ( ( (*( p))) == 10 ) {
-			goto st10;
-		}
-		{
-			goto st14;
-		}
-		st15:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof15;
-		st_case_15:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st16;
-			}
-			case 47: {
-				goto st18;
-			}
-		}
-		{
-			goto st0;
-		}
-		st16:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof16;
-		st_case_16:
-		if ( ( (*( p))) == 42 ) {
-			goto st17;
-		}
-		{
-			goto st16;
-		}
-		st17:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof17;
-		st_case_17:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st17;
-			}
-			case 47: {
-				goto st9;
-			}
-		}
-		{
-			goto st16;
-		}
-		st18:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof18;
-		st_case_18:
-		if ( ( (*( p))) == 10 ) {
-			goto st9;
-		}
-		{
-			goto st18;
-		}
-		ctr4:
-		{
-			#line 157 "parser.rl"
-			{p = p - 1; } {p+= 1; cs = 27; goto _out;} }
-
-		goto st27;
-		st27:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof27;
-		st_case_27:
-		{
-			goto st0;
-		}
-		st19:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof19;
-		st_case_19:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st20;
-			}
-			case 47: {
-				goto st22;
-			}
-		}
-		{
-			goto st0;
-		}
-		st20:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof20;
-		st_case_20:
-		if ( ( (*( p))) == 42 ) {
-			goto st21;
-		}
-		{
-			goto st20;
-		}
-		st21:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof21;
-		st_case_21:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st21;
-			}
-			case 47: {
-				goto st8;
-			}
-		}
-		{
-			goto st20;
-		}
-		st22:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof22;
-		st_case_22:
-		if ( ( (*( p))) == 10 ) {
-			goto st8;
-		}
-		{
-			goto st22;
-		}
-		st23:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof23;
-		st_case_23:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st24;
-			}
-			case 47: {
-				goto st26;
-			}
-		}
-		{
-			goto st0;
-		}
-		st24:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof24;
-		st_case_24:
-		if ( ( (*( p))) == 42 ) {
-			goto st25;
-		}
-		{
-			goto st24;
-		}
-		st25:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof25;
-		st_case_25:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st25;
-			}
-			case 47: {
-				goto st2;
-			}
-		}
-		{
-			goto st24;
-		}
-		st26:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof26;
-		st_case_26:
-		if ( ( (*( p))) == 10 ) {
-			goto st2;
-		}
-		{
-			goto st26;
-		}
-		st_out:
-		_test_eof2: cs = 2; goto _test_eof;
-		_test_eof3: cs = 3; goto _test_eof;
-		_test_eof4: cs = 4; goto _test_eof;
-		_test_eof5: cs = 5; goto _test_eof;
-		_test_eof6: cs = 6; goto _test_eof;
-		_test_eof7: cs = 7; goto _test_eof;
-		_test_eof8: cs = 8; goto _test_eof;
-		_test_eof9: cs = 9; goto _test_eof;
-		_test_eof10: cs = 10; goto _test_eof;
-		_test_eof11: cs = 11; goto _test_eof;
-		_test_eof12: cs = 12; goto _test_eof;
-		_test_eof13: cs = 13; goto _test_eof;
-		_test_eof14: cs = 14; goto _test_eof;
-		_test_eof15: cs = 15; goto _test_eof;
-		_test_eof16: cs = 16; goto _test_eof;
-		_test_eof17: cs = 17; goto _test_eof;
-		_test_eof18: cs = 18; goto _test_eof;
-		_test_eof27: cs = 27; goto _test_eof;
-		_test_eof19: cs = 19; goto _test_eof;
-		_test_eof20: cs = 20; goto _test_eof;
-		_test_eof21: cs = 21; goto _test_eof;
-		_test_eof22: cs = 22; goto _test_eof;
-		_test_eof23: cs = 23; goto _test_eof;
-		_test_eof24: cs = 24; goto _test_eof;
-		_test_eof25: cs = 25; goto _test_eof;
-		_test_eof26: cs = 26; goto _test_eof;
-
-		_test_eof: {}
-		_out: {}
-	}
-
-	#line 183 "parser.rl"
-
-
-	if (cs >= JSON_object_first_final) {
-		if (json->create_additions) {
-			VALUE klassname;
-			if (NIL_P(json->object_class)) {
-				klassname = rb_hash_aref(*result, json->create_id);
-			} else {
-				klassname = rb_funcall(*result, i_aref, 1, json->create_id);
-			}
-			if (!NIL_P(klassname)) {
-				VALUE klass = rb_funcall(mJSON, i_deep_const_get, 1, klassname);
-				if (RTEST(rb_funcall(klass, i_json_creatable_p, 0))) {
-					*result = rb_funcall(klass, i_json_create, 1, *result);
-				}
-			}
-		}
-		return p + 1;
-	} else {
-		return NULL;
-	}
+    MEMMOVE(&cache->entries[index + 1], &cache->entries[index], VALUE, cache->length - index);
+    cache->length++;
+    cache->entries[index] = rstring;
 }
 
+static inline int rstring_cache_cmp(const char *str, const long length, VALUE rstring)
+{
+    long rstring_length = RSTRING_LEN(rstring);
+    if (length == rstring_length) {
+        return memcmp(str, RSTRING_PTR(rstring), length);
+    } else {
+        return (int)(length - rstring_length);
+    }
+}
 
+static VALUE rstring_cache_fetch(rvalue_cache *cache, const char *str, const long length)
+{
+    if (RB_UNLIKELY(length > JSON_RVALUE_CACHE_MAX_ENTRY_LENGTH)) {
+        // Common names aren't likely to be very long. So we just don't
+        // cache names above an arbitrary threshold.
+        return Qfalse;
+    }
+
+    if (RB_UNLIKELY(!isalpha((unsigned char)str[0]))) {
+        // Simple heuristic, if the first character isn't a letter,
+        // we're much less likely to see this string again.
+        // We mostly want to cache strings that are likely to be repeated.
+        return Qfalse;
+    }
+
+    int low = 0;
+    int high = cache->length - 1;
+    int mid = 0;
+    int last_cmp = 0;
+
+    while (low <= high) {
+        mid = (high + low) >> 1;
+        VALUE entry = cache->entries[mid];
+        last_cmp = rstring_cache_cmp(str, length, entry);
+
+        if (last_cmp == 0) {
+            return entry;
+        } else if (last_cmp > 0) {
+            low = mid + 1;
+        } else {
+            high = mid - 1;
+        }
+    }
+
+    if (RB_UNLIKELY(memchr(str, '\\', length))) {
+        // We assume the overwhelming majority of names don't need to be escaped.
+        // But if they do, we have to fallback to the slow path.
+        return Qfalse;
+    }
+
+    VALUE rstring = build_interned_string(str, length);
+
+    if (cache->length < JSON_RVALUE_CACHE_CAPA) {
+        if (last_cmp > 0) {
+            mid += 1;
+        }
+
+        rvalue_cache_insert_at(cache, mid, rstring);
+    }
+    return rstring;
+}
 
-enum {JSON_value_start = 1};
-enum {JSON_value_first_final = 29};
-enum {JSON_value_error = 0};
+static VALUE rsymbol_cache_fetch(rvalue_cache *cache, const char *str, const long length)
+{
+    if (RB_UNLIKELY(length > JSON_RVALUE_CACHE_MAX_ENTRY_LENGTH)) {
+        // Common names aren't likely to be very long. So we just don't
+        // cache names above an arbitrary threshold.
+        return Qfalse;
+    }
+
+    if (RB_UNLIKELY(!isalpha((unsigned char)str[0]))) {
+        // Simple heuristic, if the first character isn't a letter,
+        // we're much less likely to see this string again.
+        // We mostly want to cache strings that are likely to be repeated.
+        return Qfalse;
+    }
+
+    int low = 0;
+    int high = cache->length - 1;
+    int mid = 0;
+    int last_cmp = 0;
+
+    while (low <= high) {
+        mid = (high + low) >> 1;
+        VALUE entry = cache->entries[mid];
+        last_cmp = rstring_cache_cmp(str, length, rb_sym2str(entry));
+
+        if (last_cmp == 0) {
+            return entry;
+        } else if (last_cmp > 0) {
+            low = mid + 1;
+        } else {
+            high = mid - 1;
+        }
+    }
+
+    if (RB_UNLIKELY(memchr(str, '\\', length))) {
+        // We assume the overwhelming majority of names don't need to be escaped.
+        // But if they do, we have to fallback to the slow path.
+        return Qfalse;
+    }
+
+    VALUE rsymbol = build_symbol(str, length);
+
+    if (cache->length < JSON_RVALUE_CACHE_CAPA) {
+        if (last_cmp > 0) {
+            mid += 1;
+        }
+
+        rvalue_cache_insert_at(cache, mid, rsymbol);
+    }
+    return rsymbol;
+}
 
-enum {JSON_value_en_main = 1};
+/* rvalue stack */
 
-static const char MAYBE_UNUSED(_JSON_value_nfa_targs)[] = {
-	0, 0
-};
+#define RVALUE_STACK_INITIAL_CAPA 128
 
-static const char MAYBE_UNUSED(_JSON_value_nfa_offsets)[] = {
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0
+enum rvalue_stack_type {
+    RVALUE_STACK_HEAP_ALLOCATED = 0,
+    RVALUE_STACK_STACK_ALLOCATED = 1,
 };
 
-static const char MAYBE_UNUSED(_JSON_value_nfa_push_actions)[] = {
-	0, 0
-};
+typedef struct rvalue_stack_struct {
+    enum rvalue_stack_type type;
+    long capa;
+    long head;
+    VALUE *ptr;
+} rvalue_stack;
 
-static const char MAYBE_UNUSED(_JSON_value_nfa_pop_trans)[] = {
-	0, 0
-};
+static rvalue_stack *rvalue_stack_spill(rvalue_stack *old_stack, VALUE *handle, rvalue_stack **stack_ref);
 
+static rvalue_stack *rvalue_stack_grow(rvalue_stack *stack, VALUE *handle, rvalue_stack **stack_ref)
+{
+    long required = stack->capa * 2;
+
+    if (stack->type == RVALUE_STACK_STACK_ALLOCATED) {
+        stack = rvalue_stack_spill(stack, handle, stack_ref);
+    } else {
+        REALLOC_N(stack->ptr, VALUE, required);
+        stack->capa = required;
+    }
+    return stack;
+}
 
-#line 283 "parser.rl"
+static VALUE rvalue_stack_push(rvalue_stack *stack, VALUE value, VALUE *handle, rvalue_stack **stack_ref)
+{
+    if (RB_UNLIKELY(stack->head >= stack->capa)) {
+        stack = rvalue_stack_grow(stack, handle, stack_ref);
+    }
+    stack->ptr[stack->head] = value;
+    stack->head++;
+    return value;
+}
 
+static inline VALUE *rvalue_stack_peek(rvalue_stack *stack, long count)
+{
+    return stack->ptr + (stack->head - count);
+}
 
-static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting)
+static inline void rvalue_stack_pop(rvalue_stack *stack, long count)
 {
-	int cs = EVIL;
-
-
-	{
-		cs = (int)JSON_value_start;
-	}
-
-	#line 290 "parser.rl"
-
-
-	{
-		if ( p == pe )
-		goto _test_eof;
-		switch ( cs )
-		{
-			case 1:
-			goto st_case_1;
-			case 0:
-			goto st_case_0;
-			case 29:
-			goto st_case_29;
-			case 2:
-			goto st_case_2;
-			case 3:
-			goto st_case_3;
-			case 4:
-			goto st_case_4;
-			case 5:
-			goto st_case_5;
-			case 6:
-			goto st_case_6;
-			case 7:
-			goto st_case_7;
-			case 8:
-			goto st_case_8;
-			case 9:
-			goto st_case_9;
-			case 10:
-			goto st_case_10;
-			case 11:
-			goto st_case_11;
-			case 12:
-			goto st_case_12;
-			case 13:
-			goto st_case_13;
-			case 14:
-			goto st_case_14;
-			case 15:
-			goto st_case_15;
-			case 16:
-			goto st_case_16;
-			case 17:
-			goto st_case_17;
-			case 18:
-			goto st_case_18;
-			case 19:
-			goto st_case_19;
-			case 20:
-			goto st_case_20;
-			case 21:
-			goto st_case_21;
-			case 22:
-			goto st_case_22;
-			case 23:
-			goto st_case_23;
-			case 24:
-			goto st_case_24;
-			case 25:
-			goto st_case_25;
-			case 26:
-			goto st_case_26;
-			case 27:
-			goto st_case_27;
-			case 28:
-			goto st_case_28;
-		}
-		goto st_out;
-		st1:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof1;
-		st_case_1:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st1;
-			}
-			case 32: {
-				goto st1;
-			}
-			case 34: {
-				goto ctr2;
-			}
-			case 45: {
-				goto ctr3;
-			}
-			case 47: {
-				goto st6;
-			}
-			case 73: {
-				goto st10;
-			}
-			case 78: {
-				goto st17;
-			}
-			case 91: {
-				goto ctr7;
-			}
-			case 102: {
-				goto st19;
-			}
-			case 110: {
-				goto st23;
-			}
-			case 116: {
-				goto st26;
-			}
-			case 123: {
-				goto ctr11;
-			}
-		}
-		if ( ( (*( p))) > 10 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto ctr3;
-			}
-		} else if ( ( (*( p))) >= 9 ) {
-			goto st1;
-		}
-		{
-			goto st0;
-		}
-		st_case_0:
-		st0:
-		cs = 0;
-		goto _out;
-		ctr2:
-		{
-			#line 235 "parser.rl"
-
-			char *np = JSON_parse_string(json, p, pe, result);
-			if (np == NULL) { {p = p - 1; } {p+= 1; cs = 29; goto _out;} } else {p = (( np))-1;}
-
-		}
-
-		goto st29;
-		ctr3:
-		{
-			#line 240 "parser.rl"
-
-			char *np;
-			if(pe > p + 8 && !strncmp(MinusInfinity, p, 9)) {
-				if (json->allow_nan) {
-					*result = CMinusInfinity;
-					{p = (( p + 10))-1;}
-
-					{p = p - 1; } {p+= 1; cs = 29; goto _out;}
-				} else {
-					rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p);
-				}
-			}
-			np = JSON_parse_float(json, p, pe, result);
-			if (np != NULL) {p = (( np))-1;}
-
-			np = JSON_parse_integer(json, p, pe, result);
-			if (np != NULL) {p = (( np))-1;}
-
-			{p = p - 1; } {p+= 1; cs = 29; goto _out;}
-		}
-
-		goto st29;
-		ctr7:
-		{
-			#line 258 "parser.rl"
-
-			char *np;
-			np = JSON_parse_array(json, p, pe, result, current_nesting + 1);
-			if (np == NULL) { {p = p - 1; } {p+= 1; cs = 29; goto _out;} } else {p = (( np))-1;}
-
-		}
-
-		goto st29;
-		ctr11:
-		{
-			#line 264 "parser.rl"
-
-			char *np;
-			np =  JSON_parse_object(json, p, pe, result, current_nesting + 1);
-			if (np == NULL) { {p = p - 1; } {p+= 1; cs = 29; goto _out;} } else {p = (( np))-1;}
-
-		}
-
-		goto st29;
-		ctr25:
-		{
-			#line 228 "parser.rl"
-
-			if (json->allow_nan) {
-				*result = CInfinity;
-			} else {
-				rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p - 8);
-			}
-		}
-
-		goto st29;
-		ctr27:
-		{
-			#line 221 "parser.rl"
-
-			if (json->allow_nan) {
-				*result = CNaN;
-			} else {
-				rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p - 2);
-			}
-		}
-
-		goto st29;
-		ctr31:
-		{
-			#line 215 "parser.rl"
-
-			*result = Qfalse;
-		}
-
-		goto st29;
-		ctr34:
-		{
-			#line 212 "parser.rl"
-
-			*result = Qnil;
-		}
-
-		goto st29;
-		ctr37:
-		{
-			#line 218 "parser.rl"
-
-			*result = Qtrue;
-		}
-
-		goto st29;
-		st29:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof29;
-		st_case_29:
-		{
-			#line 270 "parser.rl"
-			{p = p - 1; } {p+= 1; cs = 29; goto _out;} }
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st29;
-			}
-			case 32: {
-				goto st29;
-			}
-			case 47: {
-				goto st2;
-			}
-		}
-		if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
-			goto st29;
-		}
-		{
-			goto st0;
-		}
-		st2:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof2;
-		st_case_2:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st3;
-			}
-			case 47: {
-				goto st5;
-			}
-		}
-		{
-			goto st0;
-		}
-		st3:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof3;
-		st_case_3:
-		if ( ( (*( p))) == 42 ) {
-			goto st4;
-		}
-		{
-			goto st3;
-		}
-		st4:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof4;
-		st_case_4:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st4;
-			}
-			case 47: {
-				goto st29;
-			}
-		}
-		{
-			goto st3;
-		}
-		st5:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof5;
-		st_case_5:
-		if ( ( (*( p))) == 10 ) {
-			goto st29;
-		}
-		{
-			goto st5;
-		}
-		st6:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof6;
-		st_case_6:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st7;
-			}
-			case 47: {
-				goto st9;
-			}
-		}
-		{
-			goto st0;
-		}
-		st7:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof7;
-		st_case_7:
-		if ( ( (*( p))) == 42 ) {
-			goto st8;
-		}
-		{
-			goto st7;
-		}
-		st8:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof8;
-		st_case_8:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st8;
-			}
-			case 47: {
-				goto st1;
-			}
-		}
-		{
-			goto st7;
-		}
-		st9:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof9;
-		st_case_9:
-		if ( ( (*( p))) == 10 ) {
-			goto st1;
-		}
-		{
-			goto st9;
-		}
-		st10:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof10;
-		st_case_10:
-		if ( ( (*( p))) == 110 ) {
-			goto st11;
-		}
-		{
-			goto st0;
-		}
-		st11:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof11;
-		st_case_11:
-		if ( ( (*( p))) == 102 ) {
-			goto st12;
-		}
-		{
-			goto st0;
-		}
-		st12:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof12;
-		st_case_12:
-		if ( ( (*( p))) == 105 ) {
-			goto st13;
-		}
-		{
-			goto st0;
-		}
-		st13:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof13;
-		st_case_13:
-		if ( ( (*( p))) == 110 ) {
-			goto st14;
-		}
-		{
-			goto st0;
-		}
-		st14:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof14;
-		st_case_14:
-		if ( ( (*( p))) == 105 ) {
-			goto st15;
-		}
-		{
-			goto st0;
-		}
-		st15:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof15;
-		st_case_15:
-		if ( ( (*( p))) == 116 ) {
-			goto st16;
-		}
-		{
-			goto st0;
-		}
-		st16:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof16;
-		st_case_16:
-		if ( ( (*( p))) == 121 ) {
-			goto ctr25;
-		}
-		{
-			goto st0;
-		}
-		st17:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof17;
-		st_case_17:
-		if ( ( (*( p))) == 97 ) {
-			goto st18;
-		}
-		{
-			goto st0;
-		}
-		st18:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof18;
-		st_case_18:
-		if ( ( (*( p))) == 78 ) {
-			goto ctr27;
-		}
-		{
-			goto st0;
-		}
-		st19:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof19;
-		st_case_19:
-		if ( ( (*( p))) == 97 ) {
-			goto st20;
-		}
-		{
-			goto st0;
-		}
-		st20:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof20;
-		st_case_20:
-		if ( ( (*( p))) == 108 ) {
-			goto st21;
-		}
-		{
-			goto st0;
-		}
-		st21:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof21;
-		st_case_21:
-		if ( ( (*( p))) == 115 ) {
-			goto st22;
-		}
-		{
-			goto st0;
-		}
-		st22:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof22;
-		st_case_22:
-		if ( ( (*( p))) == 101 ) {
-			goto ctr31;
-		}
-		{
-			goto st0;
-		}
-		st23:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof23;
-		st_case_23:
-		if ( ( (*( p))) == 117 ) {
-			goto st24;
-		}
-		{
-			goto st0;
-		}
-		st24:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof24;
-		st_case_24:
-		if ( ( (*( p))) == 108 ) {
-			goto st25;
-		}
-		{
-			goto st0;
-		}
-		st25:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof25;
-		st_case_25:
-		if ( ( (*( p))) == 108 ) {
-			goto ctr34;
-		}
-		{
-			goto st0;
-		}
-		st26:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof26;
-		st_case_26:
-		if ( ( (*( p))) == 114 ) {
-			goto st27;
-		}
-		{
-			goto st0;
-		}
-		st27:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof27;
-		st_case_27:
-		if ( ( (*( p))) == 117 ) {
-			goto st28;
-		}
-		{
-			goto st0;
-		}
-		st28:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof28;
-		st_case_28:
-		if ( ( (*( p))) == 101 ) {
-			goto ctr37;
-		}
-		{
-			goto st0;
-		}
-		st_out:
-		_test_eof1: cs = 1; goto _test_eof;
-		_test_eof29: cs = 29; goto _test_eof;
-		_test_eof2: cs = 2; goto _test_eof;
-		_test_eof3: cs = 3; goto _test_eof;
-		_test_eof4: cs = 4; goto _test_eof;
-		_test_eof5: cs = 5; goto _test_eof;
-		_test_eof6: cs = 6; goto _test_eof;
-		_test_eof7: cs = 7; goto _test_eof;
-		_test_eof8: cs = 8; goto _test_eof;
-		_test_eof9: cs = 9; goto _test_eof;
-		_test_eof10: cs = 10; goto _test_eof;
-		_test_eof11: cs = 11; goto _test_eof;
-		_test_eof12: cs = 12; goto _test_eof;
-		_test_eof13: cs = 13; goto _test_eof;
-		_test_eof14: cs = 14; goto _test_eof;
-		_test_eof15: cs = 15; goto _test_eof;
-		_test_eof16: cs = 16; goto _test_eof;
-		_test_eof17: cs = 17; goto _test_eof;
-		_test_eof18: cs = 18; goto _test_eof;
-		_test_eof19: cs = 19; goto _test_eof;
-		_test_eof20: cs = 20; goto _test_eof;
-		_test_eof21: cs = 21; goto _test_eof;
-		_test_eof22: cs = 22; goto _test_eof;
-		_test_eof23: cs = 23; goto _test_eof;
-		_test_eof24: cs = 24; goto _test_eof;
-		_test_eof25: cs = 25; goto _test_eof;
-		_test_eof26: cs = 26; goto _test_eof;
-		_test_eof27: cs = 27; goto _test_eof;
-		_test_eof28: cs = 28; goto _test_eof;
-
-		_test_eof: {}
-		_out: {}
-	}
-
-	#line 291 "parser.rl"
-
-
-	if (json->freeze) {
-		OBJ_FREEZE(*result);
-	}
-
-	if (cs >= JSON_value_first_final) {
-		return p;
-	} else {
-		return NULL;
-	}
+    stack->head -= count;
 }
 
+static void rvalue_stack_mark(void *ptr)
+{
+    rvalue_stack *stack = (rvalue_stack *)ptr;
+    long index;
+    for (index = 0; index < stack->head; index++) {
+        rb_gc_mark(stack->ptr[index]);
+    }
+}
 
-enum {JSON_integer_start = 1};
-enum {JSON_integer_first_final = 3};
-enum {JSON_integer_error = 0};
+static void rvalue_stack_free(void *ptr)
+{
+    rvalue_stack *stack = (rvalue_stack *)ptr;
+    if (stack) {
+        ruby_xfree(stack->ptr);
+        ruby_xfree(stack);
+    }
+}
 
-enum {JSON_integer_en_main = 1};
+static size_t rvalue_stack_memsize(const void *ptr)
+{
+    const rvalue_stack *stack = (const rvalue_stack *)ptr;
+    return sizeof(rvalue_stack) + sizeof(VALUE) * stack->capa;
+}
 
-static const char MAYBE_UNUSED(_JSON_integer_nfa_targs)[] = {
-	0, 0
+static const rb_data_type_t JSON_Parser_rvalue_stack_type = {
+    "JSON::Ext::Parser/rvalue_stack",
+    {
+        .dmark = rvalue_stack_mark,
+        .dfree = rvalue_stack_free,
+        .dsize = rvalue_stack_memsize,
+    },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-static const char MAYBE_UNUSED(_JSON_integer_nfa_offsets)[] = {
-	0, 0, 0, 0, 0, 0, 0
-};
+static rvalue_stack *rvalue_stack_spill(rvalue_stack *old_stack, VALUE *handle, rvalue_stack **stack_ref)
+{
+    rvalue_stack *stack;
+    *handle = TypedData_Make_Struct(0, rvalue_stack, &JSON_Parser_rvalue_stack_type, stack);
+    *stack_ref = stack;
+    MEMCPY(stack, old_stack, rvalue_stack, 1);
+
+    stack->capa = old_stack->capa << 1;
+    stack->ptr = ALLOC_N(VALUE, stack->capa);
+    stack->type = RVALUE_STACK_HEAP_ALLOCATED;
+    MEMCPY(stack->ptr, old_stack->ptr, VALUE, old_stack->head);
+    return stack;
+}
 
-static const char MAYBE_UNUSED(_JSON_integer_nfa_push_actions)[] = {
-	0, 0
-};
+static void rvalue_stack_eagerly_release(VALUE handle)
+{
+    if (handle) {
+        rvalue_stack *stack;
+        TypedData_Get_Struct(handle, rvalue_stack, &JSON_Parser_rvalue_stack_type, stack);
+        RTYPEDDATA_DATA(handle) = NULL;
+        rvalue_stack_free(stack);
+    }
+}
 
-static const char MAYBE_UNUSED(_JSON_integer_nfa_pop_trans)[] = {
-	0, 0
-};
 
+#ifndef HAVE_STRNLEN
+static size_t strnlen(const char *s, size_t maxlen)
+{
+    char *p;
+    return ((p = memchr(s, '\0', maxlen)) ? p - s : maxlen);
+}
+#endif
 
-#line 311 "parser.rl"
+static int convert_UTF32_to_UTF8(char *buf, uint32_t ch)
+{
+    int len = 1;
+    if (ch <= 0x7F) {
+        buf[0] = (char) ch;
+    } else if (ch <= 0x07FF) {
+        buf[0] = (char) ((ch >> 6) | 0xC0);
+        buf[1] = (char) ((ch & 0x3F) | 0x80);
+        len++;
+    } else if (ch <= 0xFFFF) {
+        buf[0] = (char) ((ch >> 12) | 0xE0);
+        buf[1] = (char) (((ch >> 6) & 0x3F) | 0x80);
+        buf[2] = (char) ((ch & 0x3F) | 0x80);
+        len += 2;
+    } else if (ch <= 0x1fffff) {
+        buf[0] =(char) ((ch >> 18) | 0xF0);
+        buf[1] =(char) (((ch >> 12) & 0x3F) | 0x80);
+        buf[2] =(char) (((ch >> 6) & 0x3F) | 0x80);
+        buf[3] =(char) ((ch & 0x3F) | 0x80);
+        len += 3;
+    } else {
+        buf[0] = '?';
+    }
+    return len;
+}
 
+enum duplicate_key_action {
+    JSON_DEPRECATED = 0,
+    JSON_IGNORE,
+    JSON_RAISE,
+};
 
-static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result)
+typedef struct JSON_ParserStruct {
+    VALUE on_load_proc;
+    VALUE decimal_class;
+    ID decimal_method_id;
+    enum duplicate_key_action on_duplicate_key;
+    int max_nesting;
+    bool allow_nan;
+    bool allow_trailing_comma;
+    bool parsing_name;
+    bool symbolize_names;
+    bool freeze;
+} JSON_ParserConfig;
+
+typedef struct JSON_ParserStateStruct {
+    VALUE stack_handle;
+    const char *start;
+    const char *cursor;
+    const char *end;
+    rvalue_stack *stack;
+    rvalue_cache name_cache;
+    int in_array;
+    int current_nesting;
+} JSON_ParserState;
+
+static void cursor_position(JSON_ParserState *state, long *line_out, long *column_out)
 {
-	int cs = EVIL;
-
-
-	{
-		cs = (int)JSON_integer_start;
-	}
-
-	#line 318 "parser.rl"
-
-	json->memo = p;
-
-	{
-		if ( p == pe )
-		goto _test_eof;
-		switch ( cs )
-		{
-			case 1:
-			goto st_case_1;
-			case 0:
-			goto st_case_0;
-			case 2:
-			goto st_case_2;
-			case 3:
-			goto st_case_3;
-			case 4:
-			goto st_case_4;
-			case 5:
-			goto st_case_5;
-		}
-		goto st_out;
-		st_case_1:
-		switch( ( (*( p))) ) {
-			case 45: {
-				goto st2;
-			}
-			case 48: {
-				goto st3;
-			}
-		}
-		if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st5;
-		}
-		{
-			goto st0;
-		}
-		st_case_0:
-		st0:
-		cs = 0;
-		goto _out;
-		st2:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof2;
-		st_case_2:
-		if ( ( (*( p))) == 48 ) {
-			goto st3;
-		}
-		if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st5;
-		}
-		{
-			goto st0;
-		}
-		st3:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof3;
-		st_case_3:
-		if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st0;
-		}
-		{
-			goto ctr4;
-		}
-		ctr4:
-		{
-			#line 308 "parser.rl"
-			{p = p - 1; } {p+= 1; cs = 4; goto _out;} }
-
-		goto st4;
-		st4:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof4;
-		st_case_4:
-		{
-			goto st0;
-		}
-		st5:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof5;
-		st_case_5:
-		if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st5;
-		}
-		{
-			goto ctr4;
-		}
-		st_out:
-		_test_eof2: cs = 2; goto _test_eof;
-		_test_eof3: cs = 3; goto _test_eof;
-		_test_eof4: cs = 4; goto _test_eof;
-		_test_eof5: cs = 5; goto _test_eof;
-
-		_test_eof: {}
-		_out: {}
-	}
-
-	#line 320 "parser.rl"
-
-
-	if (cs >= JSON_integer_first_final) {
-		long len = p - json->memo;
-		fbuffer_clear(json->fbuffer);
-		fbuffer_append(json->fbuffer, json->memo, len);
-		fbuffer_append_char(json->fbuffer, '\0');
-		*result = rb_cstr2inum(FBUFFER_PTR(json->fbuffer), 10);
-		return p + 1;
-	} else {
-		return NULL;
-	}
+    const char *cursor = state->cursor;
+    long column = 0;
+    long line = 1;
+
+    while (cursor >= state->start) {
+        if (*cursor-- == '\n') {
+            break;
+        }
+        column++;
+    }
+
+    while (cursor >= state->start) {
+        if (*cursor-- == '\n') {
+            line++;
+        }
+    }
+    *line_out = line;
+    *column_out = column;
 }
 
+static void emit_parse_warning(const char *message, JSON_ParserState *state)
+{
+    long line, column;
+    cursor_position(state, &line, &column);
 
-enum {JSON_float_start = 1};
-enum {JSON_float_first_final = 8};
-enum {JSON_float_error = 0};
+    rb_warn("%s at line %ld column %ld", message, line, column);
+}
 
-enum {JSON_float_en_main = 1};
+#define PARSE_ERROR_FRAGMENT_LEN 32
+#ifdef RBIMPL_ATTR_NORETURN
+RBIMPL_ATTR_NORETURN()
+#endif
+static void raise_parse_error(const char *format, JSON_ParserState *state)
+{
+    unsigned char buffer[PARSE_ERROR_FRAGMENT_LEN + 3];
+    long line, column;
+    cursor_position(state, &line, &column);
+
+    const char *ptr = "EOF";
+    if (state->cursor && state->cursor < state->end) {
+        ptr = state->cursor;
+        size_t len = 0;
+        while (len < PARSE_ERROR_FRAGMENT_LEN) {
+            char ch = ptr[len];
+            if (!ch || ch == '\n' || ch == ' ' || ch == '\t' || ch == '\r') {
+                break;
+            }
+            len++;
+        }
+
+        if (len) {
+            buffer[0] = '\'';
+            MEMCPY(buffer + 1, ptr, char, len);
+
+            while (buffer[len] >= 0x80 && buffer[len] < 0xC0) { // Is continuation byte
+                len--;
+            }
+
+            if (buffer[len] >= 0xC0) { // multibyte character start
+                len--;
+            }
+
+            buffer[len + 1] = '\'';
+            buffer[len + 2] = '\0';
+            ptr = (const char *)buffer;
+        }
+    }
+
+    VALUE msg = rb_sprintf(format, ptr);
+    VALUE message = rb_enc_sprintf(enc_utf8, "%s at line %ld column %ld", RSTRING_PTR(msg), line, column);
+    RB_GC_GUARD(msg);
+
+    VALUE exc = rb_exc_new_str(rb_path2class("JSON::ParserError"), message);
+    rb_ivar_set(exc, rb_intern("@line"), LONG2NUM(line));
+    rb_ivar_set(exc, rb_intern("@column"), LONG2NUM(column));
+    rb_exc_raise(exc);
+}
 
-static const char MAYBE_UNUSED(_JSON_float_nfa_targs)[] = {
-	0, 0
-};
+#ifdef RBIMPL_ATTR_NORETURN
+RBIMPL_ATTR_NORETURN()
+#endif
+static void raise_parse_error_at(const char *format, JSON_ParserState *state, const char *at)
+{
+    state->cursor = at;
+    raise_parse_error(format, state);
+}
 
-static const char MAYBE_UNUSED(_JSON_float_nfa_offsets)[] = {
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0
-};
+/* unicode */
 
-static const char MAYBE_UNUSED(_JSON_float_nfa_push_actions)[] = {
-	0, 0
+static const signed char digit_values[256] = {
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1,
+    -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1
 };
 
-static const char MAYBE_UNUSED(_JSON_float_nfa_pop_trans)[] = {
-	0, 0
-};
+static uint32_t unescape_unicode(JSON_ParserState *state, const unsigned char *p)
+{
+    signed char b;
+    uint32_t result = 0;
+    b = digit_values[p[0]];
+    if (b < 0) raise_parse_error_at("incomplete unicode character escape sequence at %s", state, (char *)p - 2);
+    result = (result << 4) | (unsigned char)b;
+    b = digit_values[p[1]];
+    if (b < 0) raise_parse_error_at("incomplete unicode character escape sequence at %s", state, (char *)p - 2);
+    result = (result << 4) | (unsigned char)b;
+    b = digit_values[p[2]];
+    if (b < 0) raise_parse_error_at("incomplete unicode character escape sequence at %s", state, (char *)p - 2);
+    result = (result << 4) | (unsigned char)b;
+    b = digit_values[p[3]];
+    if (b < 0) raise_parse_error_at("incomplete unicode character escape sequence at %s", state, (char *)p - 2);
+    result = (result << 4) | (unsigned char)b;
+    return result;
+}
 
+#define GET_PARSER_CONFIG                          \
+    JSON_ParserConfig *config;                      \
+    TypedData_Get_Struct(self, JSON_ParserConfig, &JSON_ParserConfig_type, config)
 
-#line 345 "parser.rl"
+static const rb_data_type_t JSON_ParserConfig_type;
 
+static const bool whitespace[256] = {
+    [' '] = 1,
+    ['\t'] = 1,
+    ['\n'] = 1,
+    ['\r'] = 1,
+    ['/'] = 1,
+};
 
-static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result)
+static void
+json_eat_comments(JSON_ParserState *state)
 {
-	int cs = EVIL;
-
-
-	{
-		cs = (int)JSON_float_start;
-	}
-
-	#line 352 "parser.rl"
-
-	json->memo = p;
-
-	{
-		if ( p == pe )
-		goto _test_eof;
-		switch ( cs )
-		{
-			case 1:
-			goto st_case_1;
-			case 0:
-			goto st_case_0;
-			case 2:
-			goto st_case_2;
-			case 3:
-			goto st_case_3;
-			case 4:
-			goto st_case_4;
-			case 8:
-			goto st_case_8;
-			case 9:
-			goto st_case_9;
-			case 5:
-			goto st_case_5;
-			case 6:
-			goto st_case_6;
-			case 10:
-			goto st_case_10;
-			case 7:
-			goto st_case_7;
-		}
-		goto st_out;
-		st_case_1:
-		switch( ( (*( p))) ) {
-			case 45: {
-				goto st2;
-			}
-			case 48: {
-				goto st3;
-			}
-		}
-		if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st7;
-		}
-		{
-			goto st0;
-		}
-		st_case_0:
-		st0:
-		cs = 0;
-		goto _out;
-		st2:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof2;
-		st_case_2:
-		if ( ( (*( p))) == 48 ) {
-			goto st3;
-		}
-		if ( 49 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st7;
-		}
-		{
-			goto st0;
-		}
-		st3:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof3;
-		st_case_3:
-		switch( ( (*( p))) ) {
-			case 46: {
-				goto st4;
-			}
-			case 69: {
-				goto st5;
-			}
-			case 101: {
-				goto st5;
-			}
-		}
-		{
-			goto st0;
-		}
-		st4:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof4;
-		st_case_4:
-		if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st8;
-		}
-		{
-			goto st0;
-		}
-		st8:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof8;
-		st_case_8:
-		switch( ( (*( p))) ) {
-			case 69: {
-				goto st5;
-			}
-			case 101: {
-				goto st5;
-			}
-		}
-		if ( ( (*( p))) > 46 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto st8;
-			}
-		} else if ( ( (*( p))) >= 45 ) {
-			goto st0;
-		}
-		{
-			goto ctr9;
-		}
-		ctr9:
-		{
-			#line 339 "parser.rl"
-			{p = p - 1; } {p+= 1; cs = 9; goto _out;} }
-
-		goto st9;
-		st9:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof9;
-		st_case_9:
-		{
-			goto st0;
-		}
-		st5:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof5;
-		st_case_5:
-		switch( ( (*( p))) ) {
-			case 43: {
-				goto st6;
-			}
-			case 45: {
-				goto st6;
-			}
-		}
-		if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st10;
-		}
-		{
-			goto st0;
-		}
-		st6:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof6;
-		st_case_6:
-		if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st10;
-		}
-		{
-			goto st0;
-		}
-		st10:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof10;
-		st_case_10:
-		switch( ( (*( p))) ) {
-			case 69: {
-				goto st0;
-			}
-			case 101: {
-				goto st0;
-			}
-		}
-		if ( ( (*( p))) > 46 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto st10;
-			}
-		} else if ( ( (*( p))) >= 45 ) {
-			goto st0;
-		}
-		{
-			goto ctr9;
-		}
-		st7:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof7;
-		st_case_7:
-		switch( ( (*( p))) ) {
-			case 46: {
-				goto st4;
-			}
-			case 69: {
-				goto st5;
-			}
-			case 101: {
-				goto st5;
-			}
-		}
-		if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-			goto st7;
-		}
-		{
-			goto st0;
-		}
-		st_out:
-		_test_eof2: cs = 2; goto _test_eof;
-		_test_eof3: cs = 3; goto _test_eof;
-		_test_eof4: cs = 4; goto _test_eof;
-		_test_eof8: cs = 8; goto _test_eof;
-		_test_eof9: cs = 9; goto _test_eof;
-		_test_eof5: cs = 5; goto _test_eof;
-		_test_eof6: cs = 6; goto _test_eof;
-		_test_eof10: cs = 10; goto _test_eof;
-		_test_eof7: cs = 7; goto _test_eof;
-
-		_test_eof: {}
-		_out: {}
-	}
-
-	#line 354 "parser.rl"
-
-
-	if (cs >= JSON_float_first_final) {
-		VALUE mod = Qnil;
-		ID method_id = 0;
-		if (rb_respond_to(json->decimal_class, i_try_convert)) {
-			mod = json->decimal_class;
-			method_id = i_try_convert;
-		} else if (rb_respond_to(json->decimal_class, i_new)) {
-			mod = json->decimal_class;
-			method_id = i_new;
-		} else if (RB_TYPE_P(json->decimal_class, T_CLASS)) {
-			VALUE name = rb_class_name(json->decimal_class);
-			const char *name_cstr = RSTRING_PTR(name);
-			const char *last_colon = strrchr(name_cstr, ':');
-			if (last_colon) {
-				const char *mod_path_end = last_colon - 1;
-				VALUE mod_path = rb_str_substr(name, 0, mod_path_end - name_cstr);
-				mod = rb_path_to_class(mod_path);
-
-				const char *method_name_beg = last_colon + 1;
-				long before_len = method_name_beg - name_cstr;
-				long len = RSTRING_LEN(name) - before_len;
-				VALUE method_name = rb_str_substr(name, before_len, len);
-				method_id = SYM2ID(rb_str_intern(method_name));
-			} else {
-				mod = rb_mKernel;
-				method_id = SYM2ID(rb_str_intern(name));
-			}
-		}
-
-		long len = p - json->memo;
-		fbuffer_clear(json->fbuffer);
-		fbuffer_append(json->fbuffer, json->memo, len);
-		fbuffer_append_char(json->fbuffer, '\0');
-
-		if (method_id) {
-			VALUE text = rb_str_new2(FBUFFER_PTR(json->fbuffer));
-			*result = rb_funcallv(mod, method_id, 1, &text);
-		} else {
-			*result = DBL2NUM(rb_cstr_to_dbl(FBUFFER_PTR(json->fbuffer), 1));
-		}
-
-		return p + 1;
-	} else {
-		return NULL;
-	}
+    if (state->cursor + 1 < state->end) {
+        switch (state->cursor[1]) {
+            case '/': {
+                state->cursor = memchr(state->cursor, '\n', state->end - state->cursor);
+                if (!state->cursor) {
+                    state->cursor = state->end;
+                } else {
+                    state->cursor++;
+                }
+                break;
+            }
+            case '*': {
+                state->cursor += 2;
+                while (true) {
+                    state->cursor = memchr(state->cursor, '*', state->end - state->cursor);
+                    if (!state->cursor) {
+                        raise_parse_error_at("unexpected end of input, expected closing '*/'", state, state->end);
+                    } else {
+                        state->cursor++;
+                        if (state->cursor < state->end && *state->cursor == '/') {
+                            state->cursor++;
+                            break;
+                        }
+                    }
+                }
+                break;
+            }
+            default:
+                raise_parse_error("unexpected token %s", state);
+                break;
+        }
+    } else {
+        raise_parse_error("unexpected token %s", state);
+    }
 }
 
+static inline void
+json_eat_whitespace(JSON_ParserState *state)
+{
+    while (state->cursor < state->end && RB_UNLIKELY(whitespace[(unsigned char)*state->cursor])) {
+        if (RB_LIKELY(*state->cursor != '/')) {
+            state->cursor++;
+        } else {
+            json_eat_comments(state);
+        }
+    }
+}
 
+static inline VALUE build_string(const char *start, const char *end, bool intern, bool symbolize)
+{
+    if (symbolize) {
+        intern = true;
+    }
+    VALUE result;
+# ifdef HAVE_RB_ENC_INTERNED_STR
+    if (intern) {
+      result = rb_enc_interned_str(start, (long)(end - start), enc_utf8);
+    } else {
+      result = rb_utf8_str_new(start, (long)(end - start));
+    }
+# else
+    result = rb_utf8_str_new(start, (long)(end - start));
+    if (intern) {
+        result = rb_funcall(rb_str_freeze(result), i_uminus, 0);
+    }
+# endif
 
-enum {JSON_array_start = 1};
-enum {JSON_array_first_final = 17};
-enum {JSON_array_error = 0};
-
-enum {JSON_array_en_main = 1};
-
-static const char MAYBE_UNUSED(_JSON_array_nfa_targs)[] = {
-	0, 0
-};
-
-static const char MAYBE_UNUSED(_JSON_array_nfa_offsets)[] = {
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0
-};
+    if (symbolize) {
+      result = rb_str_intern(result);
+    }
 
-static const char MAYBE_UNUSED(_JSON_array_nfa_push_actions)[] = {
-	0, 0
-};
+    return result;
+}
 
-static const char MAYBE_UNUSED(_JSON_array_nfa_pop_trans)[] = {
-	0, 0
-};
+static inline VALUE json_string_fastpath(JSON_ParserState *state, const char *string, const char *stringEnd, bool is_name, bool intern, bool symbolize)
+{
+    size_t bufferSize = stringEnd - string;
+
+    if (is_name && state->in_array) {
+        VALUE cached_key;
+        if (RB_UNLIKELY(symbolize)) {
+            cached_key = rsymbol_cache_fetch(&state->name_cache, string, bufferSize);
+        } else {
+            cached_key = rstring_cache_fetch(&state->name_cache, string, bufferSize);
+        }
+
+        if (RB_LIKELY(cached_key)) {
+            return cached_key;
+        }
+    }
+
+    return build_string(string, stringEnd, intern, symbolize);
+}
 
+static VALUE json_string_unescape(JSON_ParserState *state, const char *string, const char *stringEnd, bool is_name, bool intern, bool symbolize)
+{
+    size_t bufferSize = stringEnd - string;
+    const char *p = string, *pe = string, *unescape, *bufferStart;
+    char *buffer;
+    int unescape_len;
+    char buf[4];
+
+    if (is_name && state->in_array) {
+        VALUE cached_key;
+        if (RB_UNLIKELY(symbolize)) {
+            cached_key = rsymbol_cache_fetch(&state->name_cache, string, bufferSize);
+        } else {
+            cached_key = rstring_cache_fetch(&state->name_cache, string, bufferSize);
+        }
+
+        if (RB_LIKELY(cached_key)) {
+            return cached_key;
+        }
+    }
+
+    VALUE result = rb_str_buf_new(bufferSize);
+    rb_enc_associate_index(result, utf8_encindex);
+    buffer = RSTRING_PTR(result);
+    bufferStart = buffer;
+
+    while (pe < stringEnd && (pe = memchr(pe, '\\', stringEnd - pe))) {
+        unescape = (char *) "?";
+        unescape_len = 1;
+        if (pe > p) {
+          MEMCPY(buffer, p, char, pe - p);
+          buffer += pe - p;
+        }
+        switch (*++pe) {
+            case 'n':
+                unescape = (char *) "\n";
+                break;
+            case 'r':
+                unescape = (char *) "\r";
+                break;
+            case 't':
+                unescape = (char *) "\t";
+                break;
+            case '"':
+                unescape = (char *) "\"";
+                break;
+            case '\\':
+                unescape = (char *) "\\";
+                break;
+            case 'b':
+                unescape = (char *) "\b";
+                break;
+            case 'f':
+                unescape = (char *) "\f";
+                break;
+            case 'u':
+                if (pe > stringEnd - 5) {
+                    raise_parse_error_at("incomplete unicode character escape sequence at %s", state, p);
+                } else {
+                    uint32_t ch = unescape_unicode(state, (unsigned char *) ++pe);
+                    pe += 3;
+                    /* To handle values above U+FFFF, we take a sequence of
+                     * \uXXXX escapes in the U+D800..U+DBFF then
+                     * U+DC00..U+DFFF ranges, take the low 10 bits from each
+                     * to make a 20-bit number, then add 0x10000 to get the
+                     * final codepoint.
+                     *
+                     * See Unicode 15: 3.8 "Surrogates", 5.3 "Handling
+                     * Surrogate Pairs in UTF-16", and 23.6 "Surrogates
+                     * Area".
+                     */
+                    if ((ch & 0xFC00) == 0xD800) {
+                        pe++;
+                        if (pe > stringEnd - 6) {
+                            raise_parse_error_at("incomplete surrogate pair at %s", state, p);
+                        }
+                        if (pe[0] == '\\' && pe[1] == 'u') {
+                            uint32_t sur = unescape_unicode(state, (unsigned char *) pe + 2);
+                            ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
+                                    | (sur & 0x3FF));
+                            pe += 5;
+                        } else {
+                            unescape = (char *) "?";
+                            break;
+                        }
+                    }
+                    unescape_len = convert_UTF32_to_UTF8(buf, ch);
+                    unescape = buf;
+                }
+                break;
+            default:
+                p = pe;
+                continue;
+        }
+        MEMCPY(buffer, unescape, char, unescape_len);
+        buffer += unescape_len;
+        p = ++pe;
+    }
+
+    if (stringEnd > p) {
+      MEMCPY(buffer, p, char, stringEnd - p);
+      buffer += stringEnd - p;
+    }
+    rb_str_set_len(result, buffer - bufferStart);
+
+    if (symbolize) {
+        result = rb_str_intern(result);
+    } else if (intern) {
+        result = rb_funcall(rb_str_freeze(result), i_uminus, 0);
+    }
+
+    return result;
+}
 
-#line 432 "parser.rl"
+#define MAX_FAST_INTEGER_SIZE 18
+static inline VALUE fast_decode_integer(const char *p, const char *pe)
+{
+    bool negative = false;
+    if (*p == '-') {
+        negative = true;
+        p++;
+    }
+
+    long long memo = 0;
+    while (p < pe) {
+        memo *= 10;
+        memo += *p - '0';
+        p++;
+    }
+
+    if (negative) {
+        memo = -memo;
+    }
+    return LL2NUM(memo);
+}
 
+static VALUE json_decode_large_integer(const char *start, long len)
+{
+    VALUE buffer_v;
+    char *buffer = RB_ALLOCV_N(char, buffer_v, len + 1);
+    MEMCPY(buffer, start, char, len);
+    buffer[len] = '\0';
+    VALUE number = rb_cstr2inum(buffer, 10);
+    RB_ALLOCV_END(buffer_v);
+    return number;
+}
 
-static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting)
+static inline VALUE
+json_decode_integer(const char *start, const char *end)
 {
-	int cs = EVIL;
-	VALUE array_class = json->array_class;
-
-	if (json->max_nesting && current_nesting > json->max_nesting) {
-		rb_raise(eNestingError, "nesting of %d is too deep", current_nesting);
-	}
-	*result = NIL_P(array_class) ? rb_ary_new() : rb_class_new_instance(0, 0, array_class);
-
-
-	{
-		cs = (int)JSON_array_start;
-	}
-
-	#line 445 "parser.rl"
-
-
-	{
-		if ( p == pe )
-		goto _test_eof;
-		switch ( cs )
-		{
-			case 1:
-			goto st_case_1;
-			case 0:
-			goto st_case_0;
-			case 2:
-			goto st_case_2;
-			case 3:
-			goto st_case_3;
-			case 4:
-			goto st_case_4;
-			case 5:
-			goto st_case_5;
-			case 6:
-			goto st_case_6;
-			case 7:
-			goto st_case_7;
-			case 8:
-			goto st_case_8;
-			case 9:
-			goto st_case_9;
-			case 10:
-			goto st_case_10;
-			case 11:
-			goto st_case_11;
-			case 12:
-			goto st_case_12;
-			case 17:
-			goto st_case_17;
-			case 13:
-			goto st_case_13;
-			case 14:
-			goto st_case_14;
-			case 15:
-			goto st_case_15;
-			case 16:
-			goto st_case_16;
-		}
-		goto st_out;
-		st_case_1:
-		if ( ( (*( p))) == 91 ) {
-			goto st2;
-		}
-		{
-			goto st0;
-		}
-		st_case_0:
-		st0:
-		cs = 0;
-		goto _out;
-		st2:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof2;
-		st_case_2:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st2;
-			}
-			case 32: {
-				goto st2;
-			}
-			case 34: {
-				goto ctr2;
-			}
-			case 45: {
-				goto ctr2;
-			}
-			case 47: {
-				goto st13;
-			}
-			case 73: {
-				goto ctr2;
-			}
-			case 78: {
-				goto ctr2;
-			}
-			case 91: {
-				goto ctr2;
-			}
-			case 93: {
-				goto ctr4;
-			}
-			case 102: {
-				goto ctr2;
-			}
-			case 110: {
-				goto ctr2;
-			}
-			case 116: {
-				goto ctr2;
-			}
-			case 123: {
-				goto ctr2;
-			}
-		}
-		if ( ( (*( p))) > 10 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto ctr2;
-			}
-		} else if ( ( (*( p))) >= 9 ) {
-			goto st2;
-		}
-		{
-			goto st0;
-		}
-		ctr2:
-		{
-			#line 409 "parser.rl"
-
-			VALUE v = Qnil;
-			char *np = JSON_parse_value(json, p, pe, &v, current_nesting);
-			if (np == NULL) {
-				{p = p - 1; } {p+= 1; cs = 3; goto _out;}
-			} else {
-				if (NIL_P(json->array_class)) {
-					rb_ary_push(*result, v);
-				} else {
-					rb_funcall(*result, i_leftshift, 1, v);
-				}
-				{p = (( np))-1;}
-
-			}
-		}
-
-		goto st3;
-		st3:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof3;
-		st_case_3:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st3;
-			}
-			case 32: {
-				goto st3;
-			}
-			case 44: {
-				goto st4;
-			}
-			case 47: {
-				goto st9;
-			}
-			case 93: {
-				goto ctr4;
-			}
-		}
-		if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
-			goto st3;
-		}
-		{
-			goto st0;
-		}
-		st4:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof4;
-		st_case_4:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st4;
-			}
-			case 32: {
-				goto st4;
-			}
-			case 34: {
-				goto ctr2;
-			}
-			case 45: {
-				goto ctr2;
-			}
-			case 47: {
-				goto st5;
-			}
-			case 73: {
-				goto ctr2;
-			}
-			case 78: {
-				goto ctr2;
-			}
-			case 91: {
-				goto ctr2;
-			}
-			case 102: {
-				goto ctr2;
-			}
-			case 110: {
-				goto ctr2;
-			}
-			case 116: {
-				goto ctr2;
-			}
-			case 123: {
-				goto ctr2;
-			}
-		}
-		if ( ( (*( p))) > 10 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto ctr2;
-			}
-		} else if ( ( (*( p))) >= 9 ) {
-			goto st4;
-		}
-		{
-			goto st0;
-		}
-		st5:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof5;
-		st_case_5:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st6;
-			}
-			case 47: {
-				goto st8;
-			}
-		}
-		{
-			goto st0;
-		}
-		st6:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof6;
-		st_case_6:
-		if ( ( (*( p))) == 42 ) {
-			goto st7;
-		}
-		{
-			goto st6;
-		}
-		st7:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof7;
-		st_case_7:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st7;
-			}
-			case 47: {
-				goto st4;
-			}
-		}
-		{
-			goto st6;
-		}
-		st8:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof8;
-		st_case_8:
-		if ( ( (*( p))) == 10 ) {
-			goto st4;
-		}
-		{
-			goto st8;
-		}
-		st9:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof9;
-		st_case_9:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st10;
-			}
-			case 47: {
-				goto st12;
-			}
-		}
-		{
-			goto st0;
-		}
-		st10:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof10;
-		st_case_10:
-		if ( ( (*( p))) == 42 ) {
-			goto st11;
-		}
-		{
-			goto st10;
-		}
-		st11:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof11;
-		st_case_11:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st11;
-			}
-			case 47: {
-				goto st3;
-			}
-		}
-		{
-			goto st10;
-		}
-		st12:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof12;
-		st_case_12:
-		if ( ( (*( p))) == 10 ) {
-			goto st3;
-		}
-		{
-			goto st12;
-		}
-		ctr4:
-		{
-			#line 424 "parser.rl"
-			{p = p - 1; } {p+= 1; cs = 17; goto _out;} }
-
-		goto st17;
-		st17:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof17;
-		st_case_17:
-		{
-			goto st0;
-		}
-		st13:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof13;
-		st_case_13:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st14;
-			}
-			case 47: {
-				goto st16;
-			}
-		}
-		{
-			goto st0;
-		}
-		st14:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof14;
-		st_case_14:
-		if ( ( (*( p))) == 42 ) {
-			goto st15;
-		}
-		{
-			goto st14;
-		}
-		st15:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof15;
-		st_case_15:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st15;
-			}
-			case 47: {
-				goto st2;
-			}
-		}
-		{
-			goto st14;
-		}
-		st16:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof16;
-		st_case_16:
-		if ( ( (*( p))) == 10 ) {
-			goto st2;
-		}
-		{
-			goto st16;
-		}
-		st_out:
-		_test_eof2: cs = 2; goto _test_eof;
-		_test_eof3: cs = 3; goto _test_eof;
-		_test_eof4: cs = 4; goto _test_eof;
-		_test_eof5: cs = 5; goto _test_eof;
-		_test_eof6: cs = 6; goto _test_eof;
-		_test_eof7: cs = 7; goto _test_eof;
-		_test_eof8: cs = 8; goto _test_eof;
-		_test_eof9: cs = 9; goto _test_eof;
-		_test_eof10: cs = 10; goto _test_eof;
-		_test_eof11: cs = 11; goto _test_eof;
-		_test_eof12: cs = 12; goto _test_eof;
-		_test_eof17: cs = 17; goto _test_eof;
-		_test_eof13: cs = 13; goto _test_eof;
-		_test_eof14: cs = 14; goto _test_eof;
-		_test_eof15: cs = 15; goto _test_eof;
-		_test_eof16: cs = 16; goto _test_eof;
-
-		_test_eof: {}
-		_out: {}
-	}
-
-	#line 446 "parser.rl"
-
-
-	if(cs >= JSON_array_first_final) {
-		return p + 1;
-	} else {
-		rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p);
-		return NULL;
-	}
+        long len = end - start;
+        if (RB_LIKELY(len < MAX_FAST_INTEGER_SIZE)) {
+            return fast_decode_integer(start, end);
+        }
+        return json_decode_large_integer(start, len);
 }
 
-static const size_t MAX_STACK_BUFFER_SIZE = 128;
-static VALUE json_string_unescape(char *string, char *stringEnd, int intern, int symbolize)
+static VALUE json_decode_large_float(const char *start, long len)
 {
-	VALUE result = Qnil;
-	size_t bufferSize = stringEnd - string;
-	char *p = string, *pe = string, *unescape, *bufferStart, *buffer;
-	int unescape_len;
-	char buf[4];
+    VALUE buffer_v;
+    char *buffer = RB_ALLOCV_N(char, buffer_v, len + 1);
+    MEMCPY(buffer, start, char, len);
+    buffer[len] = '\0';
+    VALUE number = DBL2NUM(rb_cstr_to_dbl(buffer, 1));
+    RB_ALLOCV_END(buffer_v);
+    return number;
+}
 
-	if (bufferSize > MAX_STACK_BUFFER_SIZE) {
-# ifdef HAVE_RB_ENC_INTERNED_STR
-		bufferStart = buffer = ALLOC_N(char, bufferSize ? bufferSize : 1);
-# else
-		bufferStart = buffer = ALLOC_N(char, bufferSize);
-# endif
-	} else {
-# ifdef HAVE_RB_ENC_INTERNED_STR
-		bufferStart = buffer = ALLOCA_N(char, bufferSize ? bufferSize : 1);
-# else
-		bufferStart = buffer = ALLOCA_N(char, bufferSize);
-# endif
-	}
-
-	while (pe < stringEnd) {
-		if (*pe == '\\') {
-			unescape = (char *) "?";
-			unescape_len = 1;
-			if (pe > p) {
-				MEMCPY(buffer, p, char, pe - p);
-				buffer += pe - p;
-			}
-			switch (*++pe) {
-				case 'n':
-				unescape = (char *) "\n";
-				break;
-				case 'r':
-				unescape = (char *) "\r";
-				break;
-				case 't':
-				unescape = (char *) "\t";
-				break;
-				case '"':
-				unescape = (char *) "\"";
-				break;
-				case '\\':
-				unescape = (char *) "\\";
-				break;
-				case 'b':
-				unescape = (char *) "\b";
-				break;
-				case 'f':
-				unescape = (char *) "\f";
-				break;
-				case 'u':
-				if (pe > stringEnd - 4) {
-					if (bufferSize > MAX_STACK_BUFFER_SIZE) {
-						free(bufferStart);
-					}
-					rb_enc_raise(
-					EXC_ENCODING eParserError,
-					"incomplete unicode character escape sequence at '%s'", p
-					);
-				} else {
-					UTF32 ch = unescape_unicode((unsigned char *) ++pe);
-					pe += 3;
-					if (UNI_SUR_HIGH_START == (ch & 0xFC00)) {
-						pe++;
-						if (pe > stringEnd - 6) {
-							if (bufferSize > MAX_STACK_BUFFER_SIZE) {
-								free(bufferStart);
-							}
-							rb_enc_raise(
-							EXC_ENCODING eParserError,
-							"incomplete surrogate pair at '%s'", p
-							);
-						}
-						if (pe[0] == '\\' && pe[1] == 'u') {
-							UTF32 sur = unescape_unicode((unsigned char *) pe + 2);
-							ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
-							| (sur & 0x3FF));
-							pe += 5;
-						} else {
-							unescape = (char *) "?";
-							break;
-						}
-					}
-					unescape_len = convert_UTF32_to_UTF8(buf, ch);
-					unescape = buf;
-				}
-				break;
-				default:
-				p = pe;
-				continue;
-			}
-			MEMCPY(buffer, unescape, char, unescape_len);
-			buffer += unescape_len;
-			p = ++pe;
-		} else {
-			pe++;
-		}
-	}
-
-	if (pe > p) {
-		MEMCPY(buffer, p, char, pe - p);
-		buffer += pe - p;
-	}
-
-	# ifdef HAVE_RB_ENC_INTERNED_STR
-	if (intern) {
-		result = rb_enc_interned_str(bufferStart, (long)(buffer - bufferStart), rb_utf8_encoding());
-	} else {
-		result = rb_utf8_str_new(bufferStart, (long)(buffer - bufferStart));
-	}
-	if (bufferSize > MAX_STACK_BUFFER_SIZE) {
-		free(bufferStart);
-	}
-	# else
-	result = rb_utf8_str_new(bufferStart, (long)(buffer - bufferStart));
-
-	if (bufferSize > MAX_STACK_BUFFER_SIZE) {
-		free(bufferStart);
-	}
-
-	if (intern) {
-		# if STR_UMINUS_DEDUPE_FROZEN
-		// Starting from MRI 2.8 it is preferable to freeze the string
-		// before deduplication so that it can be interned directly
-		// otherwise it would be duplicated first which is wasteful.
-		result = rb_funcall(rb_str_freeze(result), i_uminus, 0);
-		# elif STR_UMINUS_DEDUPE
-		// MRI 2.5 and older do not deduplicate strings that are already
-		// frozen.
-		result = rb_funcall(result, i_uminus, 0);
-		# else
-		result = rb_str_freeze(result);
-		# endif
-	}
-	# endif
-
-	if (symbolize) {
-		result = rb_str_intern(result);
-	}
-
-	return result;
+static VALUE json_decode_float(JSON_ParserConfig *config, const char *start, const char *end)
+{
+    long len = end - start;
+
+    if (RB_UNLIKELY(config->decimal_class)) {
+        VALUE text = rb_str_new(start, len);
+        return rb_funcallv(config->decimal_class, config->decimal_method_id, 1, &text);
+    } else if (RB_LIKELY(len < 64)) {
+        char buffer[64];
+        MEMCPY(buffer, start, char, len);
+        buffer[len] = '\0';
+        return DBL2NUM(rb_cstr_to_dbl(buffer, 1));
+    } else {
+        return json_decode_large_float(start, len);
+    }
 }
 
+static inline VALUE json_decode_array(JSON_ParserState *state, JSON_ParserConfig *config, long count)
+{
+    VALUE array = rb_ary_new_from_values(count, rvalue_stack_peek(state->stack, count));
+    rvalue_stack_pop(state->stack, count);
+
+    if (config->freeze) {
+        RB_OBJ_FREEZE(array);
+    }
 
-enum {JSON_string_start = 1};
-enum {JSON_string_first_final = 8};
-enum {JSON_string_error = 0};
+    return array;
+}
 
-enum {JSON_string_en_main = 1};
+static inline VALUE json_decode_object(JSON_ParserState *state, JSON_ParserConfig *config, size_t count)
+{
+    size_t entries_count = count / 2;
+    VALUE object = rb_hash_new_capa(entries_count);
+    rb_hash_bulk_insert(count, rvalue_stack_peek(state->stack, count), object);
+
+    if (RB_UNLIKELY(RHASH_SIZE(object) < entries_count)) {
+        switch (config->on_duplicate_key) {
+            case JSON_IGNORE:
+                break;
+            case JSON_DEPRECATED:
+                emit_parse_warning("detected duplicate keys in JSON object. This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`", state);
+                break;
+            case JSON_RAISE:
+                raise_parse_error("duplicate key", state);
+                break;
+        }
+    }
+
+    rvalue_stack_pop(state->stack, count);
+
+    if (config->freeze) {
+        RB_OBJ_FREEZE(object);
+    }
+
+    return object;
+}
 
-static const char MAYBE_UNUSED(_JSON_string_nfa_targs)[] = {
-	0, 0
-};
+static inline VALUE json_decode_string(JSON_ParserState *state, JSON_ParserConfig *config, const char *start, const char *end, bool escaped, bool is_name)
+{
+    VALUE string;
+    bool intern = is_name || config->freeze;
+    bool symbolize = is_name && config->symbolize_names;
+    if (escaped) {
+        string = json_string_unescape(state, start, end, is_name, intern, symbolize);
+    } else {
+        string = json_string_fastpath(state, start, end, is_name, intern, symbolize);
+    }
+
+    return string;
+}
 
-static const char MAYBE_UNUSED(_JSON_string_nfa_offsets)[] = {
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0
-};
+static inline VALUE json_push_value(JSON_ParserState *state, JSON_ParserConfig *config, VALUE value)
+{
+    if (RB_UNLIKELY(config->on_load_proc)) {
+        value = rb_proc_call_with_block(config->on_load_proc, 1, &value, Qnil);
+    }
+    rvalue_stack_push(state->stack, value, &state->stack_handle, &state->stack);
+    return value;
+}
 
-static const char MAYBE_UNUSED(_JSON_string_nfa_push_actions)[] = {
-	0, 0
+static const bool string_scan_table[256] = {
+    // ASCII Control Characters
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    // ASCII Characters
+     0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // '"'
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, // '\\'
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 };
 
-static const char MAYBE_UNUSED(_JSON_string_nfa_pop_trans)[] = {
-	0, 0
-};
+#if (defined(__GNUC__ ) || defined(__clang__))
+#define FORCE_INLINE __attribute__((always_inline))
+#else
+#define FORCE_INLINE
+#endif
 
+#ifdef HAVE_SIMD
+static SIMD_Implementation simd_impl = SIMD_NONE;
+#endif /* HAVE_SIMD */
 
-#line 612 "parser.rl"
+static inline bool FORCE_INLINE string_scan(JSON_ParserState *state)
+{
+#ifdef HAVE_SIMD
+#if defined(HAVE_SIMD_NEON)
+
+    uint64_t mask = 0;
+    if (string_scan_simd_neon(&state->cursor, state->end, &mask)) {
+        state->cursor += trailing_zeros64(mask) >> 2;
+        return 1;
+    }
+
+#elif defined(HAVE_SIMD_SSE2)
+    if (simd_impl == SIMD_SSE2) {
+        int mask = 0;
+        if (string_scan_simd_sse2(&state->cursor, state->end, &mask)) {
+            state->cursor += trailing_zeros(mask);
+            return 1;
+        }
+    }
+#endif /* HAVE_SIMD_NEON or HAVE_SIMD_SSE2 */
+#endif /* HAVE_SIMD */
+
+    while (state->cursor < state->end) {
+        if (RB_UNLIKELY(string_scan_table[(unsigned char)*state->cursor])) {
+            return 1;
+        }
+        *state->cursor++;
+    }
+    return 0;
+}
 
+static inline VALUE json_parse_string(JSON_ParserState *state, JSON_ParserConfig *config, bool is_name)
+{
+    state->cursor++;
+    const char *start = state->cursor;
+    bool escaped = false;
+
+    while (RB_UNLIKELY(string_scan(state))) {
+        switch (*state->cursor) {
+            case '"': {
+                VALUE string = json_decode_string(state, config, start, state->cursor, escaped, is_name);
+                state->cursor++;
+                return json_push_value(state, config, string);
+            }
+            case '\\': {
+                state->cursor++;
+                escaped = true;
+                if ((unsigned char)*state->cursor < 0x20) {
+                    raise_parse_error("invalid ASCII control character in string: %s", state);
+                }
+                break;
+            }
+            default:
+                raise_parse_error("invalid ASCII control character in string: %s", state);
+                break;
+        }
+
+        state->cursor++;
+    }
+
+    raise_parse_error("unexpected end of input, expected closing \"", state);
+    return Qfalse;
+}
 
-static int
-match_i(VALUE regexp, VALUE klass, VALUE memo)
+static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
 {
-	if (regexp == Qundef) return ST_STOP;
-	if (RTEST(rb_funcall(klass, i_json_creatable_p, 0)) &&
-	RTEST(rb_funcall(regexp, i_match, 1, rb_ary_entry(memo, 0)))) {
-		rb_ary_push(memo, klass);
-		return ST_STOP;
-	}
-	return ST_CONTINUE;
+    json_eat_whitespace(state);
+    if (state->cursor >= state->end) {
+        raise_parse_error("unexpected end of input", state);
+    }
+
+    switch (*state->cursor) {
+        case 'n':
+            if ((state->end - state->cursor >= 4) && (memcmp(state->cursor, "null", 4) == 0)) {
+                state->cursor += 4;
+                return json_push_value(state, config, Qnil);
+            }
+
+            raise_parse_error("unexpected token %s", state);
+            break;
+        case 't':
+            if ((state->end - state->cursor >= 4) && (memcmp(state->cursor, "true", 4) == 0)) {
+                state->cursor += 4;
+                return json_push_value(state, config, Qtrue);
+            }
+
+            raise_parse_error("unexpected token %s", state);
+            break;
+        case 'f':
+            // Note: memcmp with a small power of two compile to an integer comparison
+            if ((state->end - state->cursor >= 5) && (memcmp(state->cursor + 1, "alse", 4) == 0)) {
+                state->cursor += 5;
+                return json_push_value(state, config, Qfalse);
+            }
+
+            raise_parse_error("unexpected token %s", state);
+            break;
+        case 'N':
+            // Note: memcmp with a small power of two compile to an integer comparison
+            if (config->allow_nan && (state->end - state->cursor >= 3) && (memcmp(state->cursor + 1, "aN", 2) == 0)) {
+                state->cursor += 3;
+                return json_push_value(state, config, CNaN);
+            }
+
+            raise_parse_error("unexpected token %s", state);
+            break;
+        case 'I':
+            if (config->allow_nan && (state->end - state->cursor >= 8) && (memcmp(state->cursor, "Infinity", 8) == 0)) {
+                state->cursor += 8;
+                return json_push_value(state, config, CInfinity);
+            }
+
+            raise_parse_error("unexpected token %s", state);
+            break;
+        case '-':
+            // Note: memcmp with a small power of two compile to an integer comparison
+            if ((state->end - state->cursor >= 9) && (memcmp(state->cursor + 1, "Infinity", 8) == 0)) {
+                if (config->allow_nan) {
+                    state->cursor += 9;
+                    return json_push_value(state, config, CMinusInfinity);
+                } else {
+                    raise_parse_error("unexpected token %s", state);
+                }
+            }
+            // Fallthrough
+        case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': {
+            bool integer = true;
+
+            // /\A-?(0|[1-9]\d*)(\.\d+)?([Ee][-+]?\d+)?/
+            const char *start = state->cursor;
+            state->cursor++;
+
+            while ((state->cursor < state->end) && (*state->cursor >= '0') && (*state->cursor <= '9')) {
+                state->cursor++;
+            }
+
+            long integer_length = state->cursor - start;
+
+            if (RB_UNLIKELY(start[0] == '0' && integer_length > 1)) {
+                raise_parse_error_at("invalid number: %s", state, start);
+            } else if (RB_UNLIKELY(integer_length > 2 && start[0] == '-' && start[1] == '0')) {
+                raise_parse_error_at("invalid number: %s", state, start);
+            } else if (RB_UNLIKELY(integer_length == 1 && start[0] == '-')) {
+                raise_parse_error_at("invalid number: %s", state, start);
+            }
+
+            if ((state->cursor < state->end) && (*state->cursor == '.')) {
+                integer = false;
+                state->cursor++;
+
+                if (state->cursor == state->end || *state->cursor < '0' || *state->cursor > '9') {
+                    raise_parse_error("invalid number: %s", state);
+                }
+
+                while ((state->cursor < state->end) && (*state->cursor >= '0') && (*state->cursor <= '9')) {
+                    state->cursor++;
+                }
+            }
+
+            if ((state->cursor < state->end) && ((*state->cursor == 'e') || (*state->cursor == 'E'))) {
+                integer = false;
+                state->cursor++;
+                if ((state->cursor < state->end) && ((*state->cursor == '+') || (*state->cursor == '-'))) {
+                    state->cursor++;
+                }
+
+                if (state->cursor == state->end || *state->cursor < '0' || *state->cursor > '9') {
+                    raise_parse_error("invalid number: %s", state);
+                }
+
+                while ((state->cursor < state->end) && (*state->cursor >= '0') && (*state->cursor <= '9')) {
+                    state->cursor++;
+                }
+            }
+
+            if (integer) {
+                return json_push_value(state, config, json_decode_integer(start, state->cursor));
+            }
+            return json_push_value(state, config, json_decode_float(config, start, state->cursor));
+        }
+        case '"': {
+            // %r{\A"[^"\\\t\n\x00]*(?:\\[bfnrtu\\/"][^"\\]*)*"}
+            return json_parse_string(state, config, false);
+            break;
+        }
+        case '[': {
+            state->cursor++;
+            json_eat_whitespace(state);
+            long stack_head = state->stack->head;
+
+            if ((state->cursor < state->end) && (*state->cursor == ']')) {
+                state->cursor++;
+                return json_push_value(state, config, json_decode_array(state, config, 0));
+            } else {
+                state->current_nesting++;
+                if (RB_UNLIKELY(config->max_nesting && (config->max_nesting < state->current_nesting))) {
+                    rb_raise(eNestingError, "nesting of %d is too deep", state->current_nesting);
+                }
+                state->in_array++;
+                json_parse_any(state, config);
+            }
+
+            while (true) {
+                json_eat_whitespace(state);
+
+                if (state->cursor < state->end) {
+                    if (*state->cursor == ']') {
+                        state->cursor++;
+                        long count = state->stack->head - stack_head;
+                        state->current_nesting--;
+                        state->in_array--;
+                        return json_push_value(state, config, json_decode_array(state, config, count));
+                    }
+
+                    if (*state->cursor == ',') {
+                        state->cursor++;
+                        if (config->allow_trailing_comma) {
+                            json_eat_whitespace(state);
+                            if ((state->cursor < state->end) && (*state->cursor == ']')) {
+                                continue;
+                            }
+                        }
+                        json_parse_any(state, config);
+                        continue;
+                    }
+                }
+
+                raise_parse_error("expected ',' or ']' after array value", state);
+            }
+            break;
+        }
+        case '{': {
+            const char *object_start_cursor = state->cursor;
+
+            state->cursor++;
+            json_eat_whitespace(state);
+            long stack_head = state->stack->head;
+
+            if ((state->cursor < state->end) && (*state->cursor == '}')) {
+                state->cursor++;
+                return json_push_value(state, config, json_decode_object(state, config, 0));
+            } else {
+                state->current_nesting++;
+                if (RB_UNLIKELY(config->max_nesting && (config->max_nesting < state->current_nesting))) {
+                    rb_raise(eNestingError, "nesting of %d is too deep", state->current_nesting);
+                }
+
+                if (*state->cursor != '"') {
+                    raise_parse_error("expected object key, got %s", state);
+                }
+                json_parse_string(state, config, true);
+
+                json_eat_whitespace(state);
+                if ((state->cursor >= state->end) || (*state->cursor != ':')) {
+                    raise_parse_error("expected ':' after object key", state);
+                }
+                state->cursor++;
+
+                json_parse_any(state, config);
+            }
+
+            while (true) {
+                json_eat_whitespace(state);
+
+                if (state->cursor < state->end) {
+                    if (*state->cursor == '}') {
+                        state->cursor++;
+                        state->current_nesting--;
+                        size_t count = state->stack->head - stack_head;
+
+                        // Temporary rewind cursor in case an error is raised
+                        const char *final_cursor = state->cursor;
+                        state->cursor = object_start_cursor;
+                        VALUE object = json_decode_object(state, config, count);
+                        state->cursor = final_cursor;
+
+                        return json_push_value(state, config, object);
+                    }
+
+                    if (*state->cursor == ',') {
+                        state->cursor++;
+                        json_eat_whitespace(state);
+
+                        if (config->allow_trailing_comma) {
+                            if ((state->cursor < state->end) && (*state->cursor == '}')) {
+                                continue;
+                            }
+                        }
+
+                        if (*state->cursor != '"') {
+                            raise_parse_error("expected object key, got: %s", state);
+                        }
+                        json_parse_string(state, config, true);
+
+                        json_eat_whitespace(state);
+                        if ((state->cursor >= state->end) || (*state->cursor != ':')) {
+                            raise_parse_error("expected ':' after object key, got: %s", state);
+                        }
+                        state->cursor++;
+
+                        json_parse_any(state, config);
+
+                        continue;
+                    }
+                }
+
+                raise_parse_error("expected ',' or '}' after object value, got: %s", state);
+            }
+            break;
+        }
+
+        default:
+            raise_parse_error("unexpected character: %s", state);
+            break;
+    }
+
+    raise_parse_error("unreacheable: %s", state);
 }
 
-static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result)
+static void json_ensure_eof(JSON_ParserState *state)
 {
-	int cs = EVIL;
-	VALUE match_string;
-
-
-	{
-		cs = (int)JSON_string_start;
-	}
-
-	#line 632 "parser.rl"
-
-	json->memo = p;
-
-	{
-		if ( p == pe )
-		goto _test_eof;
-		switch ( cs )
-		{
-			case 1:
-			goto st_case_1;
-			case 0:
-			goto st_case_0;
-			case 2:
-			goto st_case_2;
-			case 8:
-			goto st_case_8;
-			case 3:
-			goto st_case_3;
-			case 4:
-			goto st_case_4;
-			case 5:
-			goto st_case_5;
-			case 6:
-			goto st_case_6;
-			case 7:
-			goto st_case_7;
-		}
-		goto st_out;
-		st_case_1:
-		if ( ( (*( p))) == 34 ) {
-			goto st2;
-		}
-		{
-			goto st0;
-		}
-		st_case_0:
-		st0:
-		cs = 0;
-		goto _out;
-		st2:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof2;
-		st_case_2:
-		switch( ( (*( p))) ) {
-			case 34: {
-				goto ctr2;
-			}
-			case 92: {
-				goto st3;
-			}
-		}
-		if ( 0 <= (signed char)(*(p)) && (*(p)) <= 31 ) {
-			goto st0;
-		}
-		{
-			goto st2;
-		}
-		ctr2:
-		{
-			#line 599 "parser.rl"
-
-			*result = json_string_unescape(json->memo + 1, p, json->parsing_name || json-> freeze, json->parsing_name && json->symbolize_names);
-			if (NIL_P(*result)) {
-				{p = p - 1; }
-				{p+= 1; cs = 8; goto _out;}
-			} else {
-				{p = (( p + 1))-1;}
-
-			}
-		}
-		{
-			#line 609 "parser.rl"
-			{p = p - 1; } {p+= 1; cs = 8; goto _out;} }
-
-		goto st8;
-		st8:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof8;
-		st_case_8:
-		{
-			goto st0;
-		}
-		st3:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof3;
-		st_case_3:
-		if ( ( (*( p))) == 117 ) {
-			goto st4;
-		}
-		if ( 0 <= (signed char)(*(p)) && (*(p)) <= 31 ) {
-			goto st0;
-		}
-		{
-			goto st2;
-		}
-		st4:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof4;
-		st_case_4:
-		if ( ( (*( p))) < 65 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto st5;
-			}
-		} else if ( ( (*( p))) > 70 ) {
-			if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
-				goto st5;
-			}
-		} else {
-			goto st5;
-		}
-		{
-			goto st0;
-		}
-		st5:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof5;
-		st_case_5:
-		if ( ( (*( p))) < 65 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto st6;
-			}
-		} else if ( ( (*( p))) > 70 ) {
-			if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
-				goto st6;
-			}
-		} else {
-			goto st6;
-		}
-		{
-			goto st0;
-		}
-		st6:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof6;
-		st_case_6:
-		if ( ( (*( p))) < 65 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto st7;
-			}
-		} else if ( ( (*( p))) > 70 ) {
-			if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
-				goto st7;
-			}
-		} else {
-			goto st7;
-		}
-		{
-			goto st0;
-		}
-		st7:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof7;
-		st_case_7:
-		if ( ( (*( p))) < 65 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto st2;
-			}
-		} else if ( ( (*( p))) > 70 ) {
-			if ( 97 <= ( (*( p))) && ( (*( p))) <= 102 ) {
-				goto st2;
-			}
-		} else {
-			goto st2;
-		}
-		{
-			goto st0;
-		}
-		st_out:
-		_test_eof2: cs = 2; goto _test_eof;
-		_test_eof8: cs = 8; goto _test_eof;
-		_test_eof3: cs = 3; goto _test_eof;
-		_test_eof4: cs = 4; goto _test_eof;
-		_test_eof5: cs = 5; goto _test_eof;
-		_test_eof6: cs = 6; goto _test_eof;
-		_test_eof7: cs = 7; goto _test_eof;
-
-		_test_eof: {}
-		_out: {}
-	}
-
-	#line 634 "parser.rl"
-
-
-	if (json->create_additions && RTEST(match_string = json->match_string)) {
-		VALUE klass;
-		VALUE memo = rb_ary_new2(2);
-		rb_ary_push(memo, *result);
-		rb_hash_foreach(match_string, match_i, memo);
-		klass = rb_ary_entry(memo, 1);
-		if (RTEST(klass)) {
-			*result = rb_funcall(klass, i_json_create, 1, *result);
-		}
-	}
-
-	if (cs >= JSON_string_first_final) {
-		return p + 1;
-	} else {
-		return NULL;
-	}
+    json_eat_whitespace(state);
+    if (state->cursor != state->end) {
+        raise_parse_error("unexpected token at end of stream %s", state);
+    }
 }
 
 /*
-* Document-class: JSON::Ext::Parser
-*
-* This is the JSON parser implemented as a C extension. It can be configured
-* to be used by setting
-*
-*  JSON.parser = JSON::Ext::Parser
-*
-* with the method parser= in JSON.
-*
-*/
+ * Document-class: JSON::Ext::Parser
+ *
+ * This is the JSON parser implemented as a C extension. It can be configured
+ * to be used by setting
+ *
+ *  JSON.parser = JSON::Ext::Parser
+ *
+ * with the method parser= in JSON.
+ *
+ */
 
 static VALUE convert_encoding(VALUE source)
 {
-	#ifdef HAVE_RUBY_ENCODING_H
-	rb_encoding *enc = rb_enc_get(source);
-	if (enc == rb_ascii8bit_encoding()) {
-		if (OBJ_FROZEN(source)) {
-			source = rb_str_dup(source);
-		}
-		FORCE_UTF8(source);
-	} else {
-		source = rb_str_conv_enc(source, rb_enc_get(source), rb_utf8_encoding());
-	}
-	#endif
-	return source;
+  int encindex = RB_ENCODING_GET(source);
+
+  if (RB_LIKELY(encindex == utf8_encindex)) {
+    return source;
+  }
+
+ if (encindex == binary_encindex) {
+    // For historical reason, we silently reinterpret binary strings as UTF-8
+    return rb_enc_associate_index(rb_str_dup(source), utf8_encindex);
+  }
+
+  return rb_funcall(source, i_encode, 1, Encoding_UTF_8);
 }
 
-/*
-* call-seq: new(source, opts => {})
-*
-* Creates a new JSON::Ext::Parser instance for the string _source_.
-*
-* Creates a new JSON::Ext::Parser instance for the string _source_.
-*
-* It will be configured by the _opts_ hash. _opts_ can have the following
-* keys:
-*
-* _opts_ can have the following keys:
-* * *max_nesting*: The maximum depth of nesting allowed in the parsed data
-*   structures. Disable depth checking with :max_nesting => false|nil|0, it
-*   defaults to 100.
-* * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
-*   defiance of RFC 4627 to be parsed by the Parser. This option defaults to
-*   false.
-* * *symbolize_names*: If set to true, returns symbols for the names
-*   (keys) in a JSON object. Otherwise strings are returned, which is
-*   also the default. It's not possible to use this option in
-*   conjunction with the *create_additions* option.
-* * *create_additions*: If set to false, the Parser doesn't create
-*   additions even if a matching class and create_id was found. This option
-*   defaults to false.
-* * *object_class*: Defaults to Hash
-* * *array_class*: Defaults to Array
-*/
-static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
+static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
 {
-	VALUE source, opts;
-	GET_PARSER_INIT;
-
-	if (json->Vsource) {
-		rb_raise(rb_eTypeError, "already initialized instance");
-	}
-	#ifdef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
-	rb_scan_args(argc, argv, "1:", &source, &opts);
-	#else
-	rb_scan_args(argc, argv, "11", &source, &opts);
-	#endif
-	if (!NIL_P(opts)) {
-		#ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
-		opts = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
-		if (NIL_P(opts)) {
-			rb_raise(rb_eArgError, "opts needs to be like a hash");
-		} else {
-			#endif
-			VALUE tmp = ID2SYM(i_max_nesting);
-			if (option_given_p(opts, tmp)) {
-				VALUE max_nesting = rb_hash_aref(opts, tmp);
-				if (RTEST(max_nesting)) {
-					Check_Type(max_nesting, T_FIXNUM);
-					json->max_nesting = FIX2INT(max_nesting);
-				} else {
-					json->max_nesting = 0;
-				}
-			} else {
-				json->max_nesting = 100;
-			}
-			tmp = ID2SYM(i_allow_nan);
-			if (option_given_p(opts, tmp)) {
-				json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
-			} else {
-				json->allow_nan = 0;
-			}
-			tmp = ID2SYM(i_symbolize_names);
-			if (option_given_p(opts, tmp)) {
-				json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
-			} else {
-				json->symbolize_names = 0;
-			}
-			tmp = ID2SYM(i_freeze);
-			if (option_given_p(opts, tmp)) {
-				json->freeze = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
-			} else {
-				json->freeze = 0;
-			}
-			tmp = ID2SYM(i_create_additions);
-			if (option_given_p(opts, tmp)) {
-				json->create_additions = RTEST(rb_hash_aref(opts, tmp));
-			} else {
-				json->create_additions = 0;
-			}
-			if (json->symbolize_names && json->create_additions) {
-				rb_raise(rb_eArgError,
-				"options :symbolize_names and :create_additions cannot be "
-				" used in conjunction");
-			}
-			tmp = ID2SYM(i_create_id);
-			if (option_given_p(opts, tmp)) {
-				json->create_id = rb_hash_aref(opts, tmp);
-			} else {
-				json->create_id = rb_funcall(mJSON, i_create_id, 0);
-			}
-			tmp = ID2SYM(i_object_class);
-			if (option_given_p(opts, tmp)) {
-				json->object_class = rb_hash_aref(opts, tmp);
-			} else {
-				json->object_class = Qnil;
-			}
-			tmp = ID2SYM(i_array_class);
-			if (option_given_p(opts, tmp)) {
-				json->array_class = rb_hash_aref(opts, tmp);
-			} else {
-				json->array_class = Qnil;
-			}
-			tmp = ID2SYM(i_decimal_class);
-			if (option_given_p(opts, tmp)) {
-				json->decimal_class = rb_hash_aref(opts, tmp);
-			} else {
-				json->decimal_class = Qnil;
-			}
-			tmp = ID2SYM(i_match_string);
-			if (option_given_p(opts, tmp)) {
-				VALUE match_string = rb_hash_aref(opts, tmp);
-				json->match_string = RTEST(match_string) ? match_string : Qnil;
-			} else {
-				json->match_string = Qnil;
-			}
-			#ifndef HAVE_RB_SCAN_ARGS_OPTIONAL_HASH
-		}
-		#endif
-	} else {
-		json->max_nesting = 100;
-		json->allow_nan = 0;
-		json->create_additions = 0;
-		json->create_id = rb_funcall(mJSON, i_create_id, 0);
-		json->object_class = Qnil;
-		json->array_class = Qnil;
-		json->decimal_class = Qnil;
-	}
-	source = convert_encoding(StringValue(source));
-	StringValue(source);
-	json->len = RSTRING_LEN(source);
-	json->source = RSTRING_PTR(source);;
-	json->Vsource = source;
-	return self;
+    JSON_ParserConfig *config = (JSON_ParserConfig *)data;
+
+         if (key == sym_max_nesting)          { config->max_nesting = RTEST(val) ? FIX2INT(val) : 0; }
+    else if (key == sym_allow_nan)            { config->allow_nan = RTEST(val); }
+    else if (key == sym_allow_trailing_comma) { config->allow_trailing_comma = RTEST(val); }
+    else if (key == sym_symbolize_names)      { config->symbolize_names = RTEST(val); }
+    else if (key == sym_freeze)               { config->freeze = RTEST(val); }
+    else if (key == sym_on_load)              { config->on_load_proc = RTEST(val) ? val : Qfalse; }
+    else if (key == sym_allow_duplicate_key) { config->on_duplicate_key = RTEST(val) ? JSON_IGNORE : JSON_RAISE; }
+    else if (key == sym_decimal_class)        {
+        if (RTEST(val)) {
+            if (rb_respond_to(val, i_try_convert)) {
+                config->decimal_class = val;
+                config->decimal_method_id = i_try_convert;
+            } else if (rb_respond_to(val, i_new)) {
+                config->decimal_class = val;
+                config->decimal_method_id = i_new;
+            } else if (RB_TYPE_P(val, T_CLASS)) {
+                VALUE name = rb_class_name(val);
+                const char *name_cstr = RSTRING_PTR(name);
+                const char *last_colon = strrchr(name_cstr, ':');
+                if (last_colon) {
+                    const char *mod_path_end = last_colon - 1;
+                    VALUE mod_path = rb_str_substr(name, 0, mod_path_end - name_cstr);
+                    config->decimal_class = rb_path_to_class(mod_path);
+
+                    const char *method_name_beg = last_colon + 1;
+                    long before_len = method_name_beg - name_cstr;
+                    long len = RSTRING_LEN(name) - before_len;
+                    VALUE method_name = rb_str_substr(name, before_len, len);
+                    config->decimal_method_id = SYM2ID(rb_str_intern(method_name));
+                } else {
+                    config->decimal_class = rb_mKernel;
+                    config->decimal_method_id = SYM2ID(rb_str_intern(name));
+                }
+            }
+        }
+    }
+
+    return ST_CONTINUE;
 }
 
+static void parser_config_init(JSON_ParserConfig *config, VALUE opts)
+{
+    config->max_nesting = 100;
 
-enum {JSON_start = 1};
-enum {JSON_first_final = 10};
-enum {JSON_error = 0};
+    if (!NIL_P(opts)) {
+        Check_Type(opts, T_HASH);
+        if (RHASH_SIZE(opts) > 0) {
+            // We assume in most cases few keys are set so it's faster to go over
+            // the provided keys than to check all possible keys.
+            rb_hash_foreach(opts, parser_config_init_i, (VALUE)config);
+        }
 
-enum {JSON_en_main = 1};
+    }
+}
 
-static const char MAYBE_UNUSED(_JSON_nfa_targs)[] = {
-	0, 0
-};
+/*
+ * call-seq: new(opts => {})
+ *
+ * Creates a new JSON::Ext::ParserConfig instance.
+ *
+ * It will be configured by the _opts_ hash. _opts_ can have the following
+ * keys:
+ *
+ * _opts_ can have the following keys:
+ * * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+ *   structures. Disable depth checking with :max_nesting => false|nil|0, it
+ *   defaults to 100.
+ * * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+ *   defiance of RFC 4627 to be parsed by the Parser. This option defaults to
+ *   false.
+ * * *symbolize_names*: If set to true, returns symbols for the names
+ *   (keys) in a JSON object. Otherwise strings are returned, which is
+ *   also the default. It's not possible to use this option in
+ *   conjunction with the *create_additions* option.
+ * * *decimal_class*: Specifies which class to use instead of the default
+ *    (Float) when parsing decimal numbers. This class must accept a single
+ *    string argument in its constructor.
+ */
+static VALUE cParserConfig_initialize(VALUE self, VALUE opts)
+{
+    GET_PARSER_CONFIG;
 
-static const char MAYBE_UNUSED(_JSON_nfa_offsets)[] = {
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0
-};
+    parser_config_init(config, opts);
 
-static const char MAYBE_UNUSED(_JSON_nfa_push_actions)[] = {
-	0, 0
-};
+    RB_OBJ_WRITTEN(self, Qundef, config->decimal_class);
 
-static const char MAYBE_UNUSED(_JSON_nfa_pop_trans)[] = {
-	0, 0
-};
+    return self;
+}
+
+static VALUE cParser_parse(JSON_ParserConfig *config, VALUE Vsource)
+{
+    Vsource = convert_encoding(StringValue(Vsource));
+    StringValue(Vsource);
 
+    VALUE rvalue_stack_buffer[RVALUE_STACK_INITIAL_CAPA];
+    rvalue_stack stack = {
+        .type = RVALUE_STACK_STACK_ALLOCATED,
+        .ptr = rvalue_stack_buffer,
+        .capa = RVALUE_STACK_INITIAL_CAPA,
+    };
 
-#line 835 "parser.rl"
+    long len;
+    const char *start;
+    RSTRING_GETMEM(Vsource, start, len);
 
+    JSON_ParserState _state = {
+        .start = start,
+        .cursor = start,
+        .end = start + len,
+        .stack = &stack,
+    };
+    JSON_ParserState *state = &_state;
+
+    VALUE result = json_parse_any(state, config);
+
+    // This may be skipped in case of exception, but
+    // it won't cause a leak.
+    rvalue_stack_eagerly_release(state->stack_handle);
+
+    json_ensure_eof(state);
+
+    return result;
+}
 
 /*
-* call-seq: parse()
-*
-*  Parses the current JSON text _source_ and returns the complete data
-*  structure as a result.
-*  It raises JSON::ParseError if fail to parse.
-*/
-static VALUE cParser_parse(VALUE self)
+ * call-seq: parse(source)
+ *
+ *  Parses the current JSON text _source_ and returns the complete data
+ *  structure as a result.
+ *  It raises JSON::ParserError if fail to parse.
+ */
+static VALUE cParserConfig_parse(VALUE self, VALUE Vsource)
 {
-	char *p, *pe;
-	int cs = EVIL;
-	VALUE result = Qnil;
-	GET_PARSER;
-
-
-	{
-		cs = (int)JSON_start;
-	}
-
-	#line 851 "parser.rl"
-
-	p = json->source;
-	pe = p + json->len;
-
-	{
-		if ( p == pe )
-		goto _test_eof;
-		switch ( cs )
-		{
-			case 1:
-			goto st_case_1;
-			case 0:
-			goto st_case_0;
-			case 10:
-			goto st_case_10;
-			case 2:
-			goto st_case_2;
-			case 3:
-			goto st_case_3;
-			case 4:
-			goto st_case_4;
-			case 5:
-			goto st_case_5;
-			case 6:
-			goto st_case_6;
-			case 7:
-			goto st_case_7;
-			case 8:
-			goto st_case_8;
-			case 9:
-			goto st_case_9;
-		}
-		goto st_out;
-		st1:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof1;
-		st_case_1:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st1;
-			}
-			case 32: {
-				goto st1;
-			}
-			case 34: {
-				goto ctr2;
-			}
-			case 45: {
-				goto ctr2;
-			}
-			case 47: {
-				goto st6;
-			}
-			case 73: {
-				goto ctr2;
-			}
-			case 78: {
-				goto ctr2;
-			}
-			case 91: {
-				goto ctr2;
-			}
-			case 102: {
-				goto ctr2;
-			}
-			case 110: {
-				goto ctr2;
-			}
-			case 116: {
-				goto ctr2;
-			}
-			case 123: {
-				goto ctr2;
-			}
-		}
-		if ( ( (*( p))) > 10 ) {
-			if ( 48 <= ( (*( p))) && ( (*( p))) <= 57 ) {
-				goto ctr2;
-			}
-		} else if ( ( (*( p))) >= 9 ) {
-			goto st1;
-		}
-		{
-			goto st0;
-		}
-		st_case_0:
-		st0:
-		cs = 0;
-		goto _out;
-		ctr2:
-		{
-			#line 827 "parser.rl"
-
-			char *np = JSON_parse_value(json, p, pe, &result, 0);
-			if (np == NULL) { {p = p - 1; } {p+= 1; cs = 10; goto _out;} } else {p = (( np))-1;}
-
-		}
-
-		goto st10;
-		st10:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof10;
-		st_case_10:
-		switch( ( (*( p))) ) {
-			case 13: {
-				goto st10;
-			}
-			case 32: {
-				goto st10;
-			}
-			case 47: {
-				goto st2;
-			}
-		}
-		if ( 9 <= ( (*( p))) && ( (*( p))) <= 10 ) {
-			goto st10;
-		}
-		{
-			goto st0;
-		}
-		st2:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof2;
-		st_case_2:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st3;
-			}
-			case 47: {
-				goto st5;
-			}
-		}
-		{
-			goto st0;
-		}
-		st3:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof3;
-		st_case_3:
-		if ( ( (*( p))) == 42 ) {
-			goto st4;
-		}
-		{
-			goto st3;
-		}
-		st4:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof4;
-		st_case_4:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st4;
-			}
-			case 47: {
-				goto st10;
-			}
-		}
-		{
-			goto st3;
-		}
-		st5:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof5;
-		st_case_5:
-		if ( ( (*( p))) == 10 ) {
-			goto st10;
-		}
-		{
-			goto st5;
-		}
-		st6:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof6;
-		st_case_6:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st7;
-			}
-			case 47: {
-				goto st9;
-			}
-		}
-		{
-			goto st0;
-		}
-		st7:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof7;
-		st_case_7:
-		if ( ( (*( p))) == 42 ) {
-			goto st8;
-		}
-		{
-			goto st7;
-		}
-		st8:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof8;
-		st_case_8:
-		switch( ( (*( p))) ) {
-			case 42: {
-				goto st8;
-			}
-			case 47: {
-				goto st1;
-			}
-		}
-		{
-			goto st7;
-		}
-		st9:
-		p+= 1;
-		if ( p == pe )
-		goto _test_eof9;
-		st_case_9:
-		if ( ( (*( p))) == 10 ) {
-			goto st1;
-		}
-		{
-			goto st9;
-		}
-		st_out:
-		_test_eof1: cs = 1; goto _test_eof;
-		_test_eof10: cs = 10; goto _test_eof;
-		_test_eof2: cs = 2; goto _test_eof;
-		_test_eof3: cs = 3; goto _test_eof;
-		_test_eof4: cs = 4; goto _test_eof;
-		_test_eof5: cs = 5; goto _test_eof;
-		_test_eof6: cs = 6; goto _test_eof;
-		_test_eof7: cs = 7; goto _test_eof;
-		_test_eof8: cs = 8; goto _test_eof;
-		_test_eof9: cs = 9; goto _test_eof;
-
-		_test_eof: {}
-		_out: {}
-	}
-
-	#line 854 "parser.rl"
-
-
-	if (cs >= JSON_first_final && p == pe) {
-		return result;
-	} else {
-		rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p);
-		return Qnil;
-	}
+    GET_PARSER_CONFIG;
+    return cParser_parse(config, Vsource);
 }
 
-static void JSON_mark(void *ptr)
+static VALUE cParser_m_parse(VALUE klass, VALUE Vsource, VALUE opts)
 {
-	JSON_Parser *json = ptr;
-	rb_gc_mark_maybe(json->Vsource);
-	rb_gc_mark_maybe(json->create_id);
-	rb_gc_mark_maybe(json->object_class);
-	rb_gc_mark_maybe(json->array_class);
-	rb_gc_mark_maybe(json->decimal_class);
-	rb_gc_mark_maybe(json->match_string);
+    Vsource = convert_encoding(StringValue(Vsource));
+    StringValue(Vsource);
+
+    JSON_ParserConfig _config = {0};
+    JSON_ParserConfig *config = &_config;
+    parser_config_init(config, opts);
+
+    return cParser_parse(config, Vsource);
 }
 
-static void JSON_free(void *ptr)
+static void JSON_ParserConfig_mark(void *ptr)
 {
-	JSON_Parser *json = ptr;
-	fbuffer_free(json->fbuffer);
-	ruby_xfree(json);
+    JSON_ParserConfig *config = ptr;
+    rb_gc_mark(config->on_load_proc);
+    rb_gc_mark(config->decimal_class);
 }
 
-static size_t JSON_memsize(const void *ptr)
+static void JSON_ParserConfig_free(void *ptr)
 {
-	const JSON_Parser *json = ptr;
-	return sizeof(*json) + FBUFFER_CAPA(json->fbuffer);
+    JSON_ParserConfig *config = ptr;
+    ruby_xfree(config);
 }
 
-#ifdef NEW_TYPEDDATA_WRAPPER
-static const rb_data_type_t JSON_Parser_type = {
-	"JSON/Parser",
-	{JSON_mark, JSON_free, JSON_memsize,},
-	#ifdef RUBY_TYPED_FREE_IMMEDIATELY
-	0, 0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
-	#endif
-};
-#endif
-
-static VALUE cJSON_parser_s_allocate(VALUE klass)
+static size_t JSON_ParserConfig_memsize(const void *ptr)
 {
-	JSON_Parser *json;
-	VALUE obj = TypedData_Make_Struct(klass, JSON_Parser, &JSON_Parser_type, json);
-	json->fbuffer = fbuffer_alloc(0);
-	return obj;
+    return sizeof(JSON_ParserConfig);
 }
 
-/*
-* call-seq: source()
-*
-* Returns a copy of the current _source_ string, that was used to construct
-* this Parser.
-*/
-static VALUE cParser_source(VALUE self)
+static const rb_data_type_t JSON_ParserConfig_type = {
+    "JSON::Ext::Parser/ParserConfig",
+    {
+        JSON_ParserConfig_mark,
+        JSON_ParserConfig_free,
+        JSON_ParserConfig_memsize,
+    },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static VALUE cJSON_parser_s_allocate(VALUE klass)
 {
-	GET_PARSER;
-	return rb_str_dup(json->Vsource);
+    JSON_ParserConfig *config;
+    return TypedData_Make_Struct(klass, JSON_ParserConfig, &JSON_ParserConfig_type, config);
 }
 
 void Init_parser(void)
 {
-	#ifdef HAVE_RB_EXT_RACTOR_SAFE
-	rb_ext_ractor_safe(true);
-	#endif
-
-	#undef rb_intern
-	rb_require("json/common");
-	mJSON = rb_define_module("JSON");
-	mExt = rb_define_module_under(mJSON, "Ext");
-	cParser = rb_define_class_under(mExt, "Parser", rb_cObject);
-	eParserError = rb_path2class("JSON::ParserError");
-	eNestingError = rb_path2class("JSON::NestingError");
-	rb_gc_register_mark_object(eParserError);
-	rb_gc_register_mark_object(eNestingError);
-	rb_define_alloc_func(cParser, cJSON_parser_s_allocate);
-	rb_define_method(cParser, "initialize", cParser_initialize, -1);
-	rb_define_method(cParser, "parse", cParser_parse, 0);
-	rb_define_method(cParser, "source", cParser_source, 0);
-
-	CNaN = rb_const_get(mJSON, rb_intern("NaN"));
-	rb_gc_register_mark_object(CNaN);
-
-	CInfinity = rb_const_get(mJSON, rb_intern("Infinity"));
-	rb_gc_register_mark_object(CInfinity);
-
-	CMinusInfinity = rb_const_get(mJSON, rb_intern("MinusInfinity"));
-	rb_gc_register_mark_object(CMinusInfinity);
-
-	i_json_creatable_p = rb_intern("json_creatable?");
-	i_json_create = rb_intern("json_create");
-	i_create_id = rb_intern("create_id");
-	i_create_additions = rb_intern("create_additions");
-	i_chr = rb_intern("chr");
-	i_max_nesting = rb_intern("max_nesting");
-	i_allow_nan = rb_intern("allow_nan");
-	i_symbolize_names = rb_intern("symbolize_names");
-	i_object_class = rb_intern("object_class");
-	i_array_class = rb_intern("array_class");
-	i_decimal_class = rb_intern("decimal_class");
-	i_match = rb_intern("match");
-	i_match_string = rb_intern("match_string");
-	i_key_p = rb_intern("key?");
-	i_deep_const_get = rb_intern("deep_const_get");
-	i_aset = rb_intern("[]=");
-	i_aref = rb_intern("[]");
-	i_leftshift = rb_intern("<<");
-	i_new = rb_intern("new");
-	i_try_convert = rb_intern("try_convert");
-	i_freeze = rb_intern("freeze");
-	i_uminus = rb_intern("-@");
-}
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+#endif
 
-/*
-* Local variables:
-* mode: c
-* c-file-style: ruby
-* indent-tabs-mode: nil
-* End:
-*/
+#undef rb_intern
+    rb_require("json/common");
+    mJSON = rb_define_module("JSON");
+    VALUE mExt = rb_define_module_under(mJSON, "Ext");
+    VALUE cParserConfig = rb_define_class_under(mExt, "ParserConfig", rb_cObject);
+    eNestingError = rb_path2class("JSON::NestingError");
+    rb_gc_register_mark_object(eNestingError);
+    rb_define_alloc_func(cParserConfig, cJSON_parser_s_allocate);
+    rb_define_method(cParserConfig, "initialize", cParserConfig_initialize, 1);
+    rb_define_method(cParserConfig, "parse", cParserConfig_parse, 1);
+
+    VALUE cParser = rb_define_class_under(mExt, "Parser", rb_cObject);
+    rb_define_singleton_method(cParser, "parse", cParser_m_parse, 2);
+
+    CNaN = rb_const_get(mJSON, rb_intern("NaN"));
+    rb_gc_register_mark_object(CNaN);
+
+    CInfinity = rb_const_get(mJSON, rb_intern("Infinity"));
+    rb_gc_register_mark_object(CInfinity);
+
+    CMinusInfinity = rb_const_get(mJSON, rb_intern("MinusInfinity"));
+    rb_gc_register_mark_object(CMinusInfinity);
+
+    rb_global_variable(&Encoding_UTF_8);
+    Encoding_UTF_8 = rb_const_get(rb_path2class("Encoding"), rb_intern("UTF_8"));
+
+    sym_max_nesting = ID2SYM(rb_intern("max_nesting"));
+    sym_allow_nan = ID2SYM(rb_intern("allow_nan"));
+    sym_allow_trailing_comma = ID2SYM(rb_intern("allow_trailing_comma"));
+    sym_symbolize_names = ID2SYM(rb_intern("symbolize_names"));
+    sym_freeze = ID2SYM(rb_intern("freeze"));
+    sym_on_load = ID2SYM(rb_intern("on_load"));
+    sym_decimal_class = ID2SYM(rb_intern("decimal_class"));
+    sym_allow_duplicate_key = ID2SYM(rb_intern("allow_duplicate_key"));
+
+    i_chr = rb_intern("chr");
+    i_aset = rb_intern("[]=");
+    i_aref = rb_intern("[]");
+    i_leftshift = rb_intern("<<");
+    i_new = rb_intern("new");
+    i_try_convert = rb_intern("try_convert");
+    i_uminus = rb_intern("-@");
+    i_encode = rb_intern("encode");
+
+    binary_encindex = rb_ascii8bit_encindex();
+    utf8_encindex = rb_utf8_encindex();
+    enc_utf8 = rb_utf8_encoding();
+
+#ifdef HAVE_SIMD
+    simd_impl = find_simd_implementation();
+#endif
+}