summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--ChangeLog5
-rw-r--r--ext/json/ext/generator/extconf.h3
-rw-r--r--ext/json/ext/generator/extconf.rb9
-rwxr-xr-xext/json/ext/generator/generator.c728
-rw-r--r--ext/json/ext/generator/unicode.c184
-rwxr-xr-xext/json/ext/generator/unicode.h53
-rw-r--r--ext/json/ext/parser/extconf.h3
-rw-r--r--ext/json/ext/parser/extconf.rb9
-rw-r--r--ext/json/ext/parser/parser.c1601
-rw-r--r--ext/json/ext/parser/parser.rl569
-rw-r--r--ext/json/ext/parser/unicode.c156
-rwxr-xr-xext/json/ext/parser/unicode.h58
-rw-r--r--ext/nkf/nkf-utf8/nkf.c198
-rw-r--r--ext/nkf/nkf-utf8/utf8tbl.c247
-rw-r--r--ext/nkf/nkf-utf8/utf8tbl.h3
-rw-r--r--lib/json.rb210
-rw-r--r--lib/json/Array.xpm21
-rw-r--r--lib/json/FalseClass.xpm21
-rw-r--r--lib/json/Hash.xpm21
-rw-r--r--lib/json/Key.xpm73
-rw-r--r--lib/json/NilClass.xpm21
-rw-r--r--lib/json/Numeric.xpm28
-rw-r--r--lib/json/String.xpm96
-rw-r--r--lib/json/TrueClass.xpm21
-rw-r--r--lib/json/common.rb194
-rw-r--r--lib/json/editor.rb1295
-rw-r--r--lib/json/ext.rb13
-rw-r--r--lib/json/json.xpm1499
-rw-r--r--lib/json/pure.rb75
-rw-r--r--lib/json/pure/generator.rb321
-rw-r--r--lib/json/pure/parser.rb241
-rwxr-xr-xlib/json/version.rb9
-rw-r--r--test/json/fixtures/fail1.json1
-rw-r--r--test/json/fixtures/fail10.json1
-rw-r--r--test/json/fixtures/fail11.json1
-rw-r--r--test/json/fixtures/fail12.json1
-rw-r--r--test/json/fixtures/fail13.json1
-rw-r--r--test/json/fixtures/fail14.json1
-rw-r--r--test/json/fixtures/fail18.json1
-rw-r--r--test/json/fixtures/fail19.json1
-rw-r--r--test/json/fixtures/fail2.json1
-rw-r--r--test/json/fixtures/fail20.json1
-rw-r--r--test/json/fixtures/fail21.json1
-rw-r--r--test/json/fixtures/fail22.json1
-rw-r--r--test/json/fixtures/fail23.json1
-rw-r--r--test/json/fixtures/fail24.json1
-rw-r--r--test/json/fixtures/fail25.json1
-rw-r--r--test/json/fixtures/fail27.json2
-rw-r--r--test/json/fixtures/fail28.json2
-rw-r--r--test/json/fixtures/fail3.json1
-rw-r--r--test/json/fixtures/fail4.json1
-rw-r--r--test/json/fixtures/fail5.json1
-rw-r--r--test/json/fixtures/fail6.json1
-rw-r--r--test/json/fixtures/fail7.json1
-rw-r--r--test/json/fixtures/fail8.json1
-rw-r--r--test/json/fixtures/fail9.json1
-rw-r--r--test/json/fixtures/pass1.json56
-rw-r--r--test/json/fixtures/pass15.json1
-rw-r--r--test/json/fixtures/pass16.json1
-rw-r--r--test/json/fixtures/pass17.json1
-rw-r--r--test/json/fixtures/pass2.json1
-rw-r--r--test/json/fixtures/pass26.json1
-rw-r--r--test/json/fixtures/pass3.json6
-rw-r--r--test/json/runner.rb24
-rwxr-xr-xtest/json/test_json.rb255
-rwxr-xr-xtest/json/test_json_addition.rb94
-rwxr-xr-xtest/json/test_json_fixtures.rb30
-rwxr-xr-xtest/json/test_json_generate.rb81
-rwxr-xr-xtest/json/test_json_unicode.rb59
69 files changed, 8551 insertions, 70 deletions
diff --git a/ChangeLog b/ChangeLog
index be31385..cd0ac15 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+Mon Jun 04 21:15:45 2007 NARUSE, Yui <naruse@ruby-lang.org>
+
+ * lib/json.rb, lib/json, ext/json, test/json:
+ import JSON library.
+
Sat Jun 2 16:48:55 2007 Koichi Sasada <ko1@atdot.net>
* cont.c (Fiber#pass): rename to Fiber#yield. Block parameter
diff --git a/ext/json/ext/generator/extconf.h b/ext/json/ext/generator/extconf.h
new file mode 100644
index 0000000..cda0cc8
--- /dev/null
+++ b/ext/json/ext/generator/extconf.h
@@ -0,0 +1,3 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#endif
diff --git a/ext/json/ext/generator/extconf.rb b/ext/json/ext/generator/extconf.rb
new file mode 100644
index 0000000..db721a9
--- /dev/null
+++ b/ext/json/ext/generator/extconf.rb
@@ -0,0 +1,9 @@
+require 'mkmf'
+require 'rbconfig'
+
+if CONFIG['CC'] =~ /gcc/
+ CONFIG['CC'] += ' -Wall -ggdb'
+ #CONFIG['CC'] += ' -Wall'
+end
+
+create_makefile 'json/ext/generator'
diff --git a/ext/json/ext/generator/generator.c b/ext/json/ext/generator/generator.c
new file mode 100755
index 0000000..60e0935
--- /dev/null
+++ b/ext/json/ext/generator/generator.c
@@ -0,0 +1,728 @@
+/* vim: set cin et sw=4 ts=4: */
+
+#include <string.h>
+#include "ruby.h"
+#include "st.h"
+#include "unicode.h"
+
+static VALUE mJSON, mExt, mGenerator, cState, mGeneratorMethods, mObject,
+ mHash, mArray, mInteger, mFloat, mString, mString_Extend,
+ mTrueClass, mFalseClass, mNilClass, eGeneratorError,
+ eCircularDatastructure;
+
+static ID i_to_s, i_to_json, i_new, i_indent, i_space, i_space_before,
+ i_object_nl, i_array_nl, i_check_circular, i_pack, i_unpack,
+ i_create_id, i_extend;
+
+typedef struct JSON_Generator_StateStruct {
+ VALUE indent;
+ VALUE space;
+ VALUE space_before;
+ VALUE object_nl;
+ VALUE array_nl;
+ int check_circular;
+ VALUE seen;
+ VALUE memo;
+ VALUE depth;
+ int flag;
+} JSON_Generator_State;
+
+#define GET_STATE(self) \
+ JSON_Generator_State *state; \
+ Data_Get_Struct(self, JSON_Generator_State, state);
+
+/*
+ * Document-module: JSON::Ext::Generator
+ *
+ * This is the JSON generator implemented as a C extension. It can be
+ * configured to be used by setting
+ *
+ * JSON.generator = JSON::Ext::Generator
+ *
+ * with the method generator= in JSON.
+ *
+ */
+
+static int hash_to_json_state_i(VALUE key, VALUE value, VALUE Vstate)
+{
+ VALUE json, buf, Vdepth;
+ GET_STATE(Vstate);
+ buf = state->memo;
+ Vdepth = state->depth;
+
+ if (key == Qundef) return ST_CONTINUE;
+ if (state->flag) {
+ state->flag = 0;
+ rb_str_buf_cat2(buf, ",");
+ if (RSTRING_LEN(state->object_nl)) rb_str_buf_append(buf, state->object_nl);
+ }
+ if (RSTRING_LEN(state->object_nl)) {
+ rb_str_buf_append(buf, rb_str_times(state->indent, Vdepth));
+ }
+ json = rb_funcall(rb_funcall(key, i_to_s, 0), i_to_json, 2, Vstate, Vdepth);
+ rb_str_buf_append(buf, json);
+ OBJ_INFECT(buf, json);
+ if (RSTRING_LEN(state->space_before)) {
+ rb_str_buf_append(buf, state->space_before);
+ }
+ rb_str_buf_cat2(buf, ":");
+ if (RSTRING_LEN(state->space)) rb_str_buf_append(buf, state->space);
+ json = rb_funcall(value, i_to_json, 2, Vstate, Vdepth);
+ state->flag = 1;
+ rb_str_buf_append(buf, json);
+ OBJ_INFECT(buf, json);
+ state->depth = Vdepth;
+ state->memo = buf;
+ return ST_CONTINUE;
+}
+
+inline static VALUE mHash_json_transfrom(VALUE self, VALUE Vstate, VALUE Vdepth) {
+ long depth, len = RHASH(self)->tbl->num_entries;
+ VALUE result;
+ GET_STATE(Vstate);
+
+ depth = 1 + FIX2LONG(Vdepth);
+ result = rb_str_buf_new(len);
+ state->memo = result;
+ state->depth = LONG2FIX(depth);
+ state->flag = 0;
+ rb_str_buf_cat2(result, "{");
+ if (RSTRING_LEN(state->object_nl)) rb_str_buf_append(result, state->object_nl);
+ rb_hash_foreach(self, hash_to_json_state_i, Vstate);
+ if (RSTRING_LEN(state->object_nl)) rb_str_buf_append(result, state->object_nl);
+ if (RSTRING_LEN(state->object_nl)) {
+ rb_str_buf_append(result, rb_str_times(state->indent, Vdepth));
+ }
+ rb_str_buf_cat2(result, "}");
+ return result;
+}
+
+static int hash_to_json_i(VALUE key, VALUE value, VALUE buf)
+{
+ VALUE tmp;
+
+ if (key == Qundef) return ST_CONTINUE;
+ if (RSTRING_LEN(buf) > 1) rb_str_buf_cat2(buf, ",");
+ tmp = rb_funcall(rb_funcall(key, i_to_s, 0), i_to_json, 0);
+ rb_str_buf_append(buf, tmp);
+ OBJ_INFECT(buf, tmp);
+ rb_str_buf_cat2(buf, ":");
+ tmp = rb_funcall(value, i_to_json, 0);
+ rb_str_buf_append(buf, tmp);
+ OBJ_INFECT(buf, tmp);
+
+ return ST_CONTINUE;
+}
+
+/*
+ * call-seq: to_json(state = nil, depth = 0)
+ *
+ * Returns a JSON string containing a JSON object, that is unparsed from
+ * this Hash instance.
+ * _state_ is a JSON::State object, that can also be used to configure the
+ * produced JSON string output further.
+ * _depth_ is used to find out nesting depth, to indent accordingly.
+ */
+static VALUE mHash_to_json(int argc, VALUE *argv, VALUE self)
+{
+ VALUE Vstate, Vdepth, result;
+ long depth;
+
+ rb_scan_args(argc, argv, "02", &Vstate, &Vdepth);
+ depth = NIL_P(Vdepth) ? 0 : FIX2LONG(Vdepth);
+ if (NIL_P(Vstate)) {
+ long len = RHASH(self)->tbl->num_entries;
+ result = rb_str_buf_new(len);
+ rb_str_buf_cat2(result, "{");
+ rb_hash_foreach(self, hash_to_json_i, result);
+ rb_str_buf_cat2(result, "}");
+ } else {
+ GET_STATE(Vstate);
+ if (state->check_circular) {
+ VALUE self_id = rb_obj_id(self);
+ if (RTEST(rb_hash_aref(state->seen, self_id))) {
+ rb_raise(eCircularDatastructure,
+ "circular data structures not supported!");
+ }
+ rb_hash_aset(state->seen, self_id, Qtrue);
+ result = mHash_json_transfrom(self, Vstate, LONG2FIX(depth));
+ rb_hash_delete(state->seen, self_id);
+ } else {
+ result = mHash_json_transfrom(self, Vstate, LONG2FIX(depth));
+ }
+ }
+ OBJ_INFECT(result, self);
+ return result;
+}
+
+inline static VALUE mArray_json_transfrom(VALUE self, VALUE Vstate, VALUE Vdepth) {
+ long i, len = RARRAY_LEN(self);
+ VALUE shift, result;
+ long depth = NIL_P(Vdepth) ? 0 : FIX2LONG(Vdepth);
+ VALUE delim = rb_str_new2(",");
+ GET_STATE(Vstate);
+
+ if (state->check_circular) {
+ VALUE self_id = rb_obj_id(self);
+ rb_hash_aset(state->seen, self_id, Qtrue);
+ result = rb_str_buf_new(len);
+ if (RSTRING_LEN(state->array_nl)) rb_str_append(delim, state->array_nl);
+ shift = rb_str_times(state->indent, LONG2FIX(depth + 1));
+
+ rb_str_buf_cat2(result, "[");
+ rb_str_buf_append(result, state->array_nl);
+ for (i = 0; i < len; i++) {
+ VALUE element = RARRAY_PTR(self)[i];
+ if (RTEST(rb_hash_aref(state->seen, rb_obj_id(element)))) {
+ rb_raise(eCircularDatastructure,
+ "circular data structures not supported!");
+ }
+ OBJ_INFECT(result, element);
+ if (i > 0) rb_str_buf_append(result, delim);
+ rb_str_buf_append(result, shift);
+ rb_str_buf_append(result, rb_funcall(element, i_to_json, 2, Vstate, LONG2FIX(depth + 1)));
+ }
+ if (RSTRING_LEN(state->array_nl)) {
+ rb_str_buf_append(result, state->array_nl);
+ rb_str_buf_append(result, rb_str_times(state->indent, LONG2FIX(depth)));
+ }
+ rb_str_buf_cat2(result, "]");
+ rb_hash_delete(state->seen, self_id);
+ } else {
+ result = rb_str_buf_new(len);
+ if (RSTRING_LEN(state->array_nl)) rb_str_append(delim, state->array_nl);
+ shift = rb_str_times(state->indent, LONG2FIX(depth + 1));
+
+ rb_str_buf_cat2(result, "[");
+ rb_str_buf_append(result, state->array_nl);
+ for (i = 0; i < len; i++) {
+ VALUE element = RARRAY_PTR(self)[i];
+ OBJ_INFECT(result, element);
+ if (i > 0) rb_str_buf_append(result, delim);
+ rb_str_buf_append(result, shift);
+ rb_str_buf_append(result, rb_funcall(element, i_to_json, 2, Vstate, LONG2FIX(depth + 1)));
+ }
+ rb_str_buf_append(result, state->array_nl);
+ if (RSTRING_LEN(state->array_nl)) {
+ rb_str_buf_append(result, rb_str_times(state->indent, LONG2FIX(depth)));
+ }
+ rb_str_buf_cat2(result, "]");
+ }
+ return result;
+}
+
+/*
+ * call-seq: to_json(state = nil, depth = 0)
+ *
+ * Returns a JSON string containing a JSON array, that is unparsed from
+ * this Array instance.
+ * _state_ is a JSON::State object, that can also be used to configure the
+ * produced JSON string output further.
+ * _depth_ is used to find out nesting depth, to indent accordingly.
+ */
+static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self) {
+ VALUE Vstate, Vdepth, result;
+
+ rb_scan_args(argc, argv, "02", &Vstate, &Vdepth);
+ if (NIL_P(Vstate)) {
+ long i, len = RARRAY_LEN(self);
+ result = rb_str_buf_new(2 + 2 * len);
+ rb_str_buf_cat2(result, "[");
+ for (i = 0; i < len; i++) {
+ VALUE element = RARRAY_PTR(self)[i];
+ OBJ_INFECT(result, element);
+ if (i > 0) rb_str_buf_cat2(result, ",");
+ rb_str_buf_append(result, rb_funcall(element, i_to_json, 0));
+ }
+ rb_str_buf_cat2(result, "]");
+ } else {
+ result = mArray_json_transfrom(self, Vstate, Vdepth);
+ }
+ OBJ_INFECT(result, self);
+ return result;
+}
+
+/*
+ * call-seq: to_json(*)
+ *
+ * Returns a JSON string representation for this Integer number.
+ */
+static VALUE mInteger_to_json(int argc, VALUE *argv, VALUE self)
+{
+ return rb_funcall(self, i_to_s, 0);
+}
+
+/*
+ * call-seq: to_json(*)
+ *
+ * Returns a JSON string representation for this Float number.
+ */
+static VALUE mFloat_to_json(int argc, VALUE *argv, VALUE self)
+{
+ return rb_funcall(self, i_to_s, 0);
+}
+
+/*
+ * call-seq: String.included(modul)
+ *
+ * Extends _modul_ with the String::Extend module.
+ */
+static VALUE mString_included_s(VALUE self, VALUE modul) {
+ return rb_funcall(modul, i_extend, 1, mString_Extend);
+}
+
+/*
+ * call-seq: to_json(*)
+ *
+ * This string should be encoded with UTF-8 A call to this method
+ * returns a JSON string encoded with UTF16 big endian characters as
+ * \u????.
+ */
+static VALUE mString_to_json(int argc, VALUE *argv, VALUE self)
+{
+ VALUE result = rb_str_buf_new(RSTRING_LEN(self));
+ rb_str_buf_cat2(result, "\"");
+ JSON_convert_UTF8_to_JSON(result, self, strictConversion);
+ rb_str_buf_cat2(result, "\"");
+ return result;
+}
+
+/*
+ * call-seq: to_json_raw_object()
+ *
+ * This method creates a raw object hash, that can be nested into
+ * other data structures and will be unparsed as a raw string. This
+ * method should be used, if you want to convert raw strings to JSON
+ * instead of UTF-8 strings, e. g. binary data.
+ */
+static VALUE mString_to_json_raw_object(VALUE self) {
+ VALUE ary;
+ VALUE result = rb_hash_new();
+ rb_hash_aset(result, rb_funcall(mJSON, i_create_id, 0), rb_class_name(rb_obj_class(self)));
+ ary = rb_funcall(self, i_unpack, 1, rb_str_new2("C*"));
+ rb_hash_aset(result, rb_str_new2("raw"), ary);
+ return result;
+}
+
+/*
+ * call-seq: to_json_raw(*args)
+ *
+ * This method creates a JSON text from the result of a call to
+ * to_json_raw_object of this String.
+ */
+static VALUE mString_to_json_raw(int argc, VALUE *argv, VALUE self) {
+ VALUE obj = mString_to_json_raw_object(self);
+ Check_Type(obj, T_HASH);
+ return mHash_to_json(argc, argv, obj);
+}
+
+/*
+ * call-seq: json_create(o)
+ *
+ * Raw Strings are JSON Objects (the raw bytes are stored in an array for the
+ * key "raw"). The Ruby String can be created by this module method.
+ */
+static VALUE mString_Extend_json_create(VALUE self, VALUE o) {
+ VALUE ary;
+ Check_Type(o, T_HASH);
+ ary = rb_hash_aref(o, rb_str_new2("raw"));
+ return rb_funcall(ary, i_pack, 1, rb_str_new2("C*"));
+}
+
+/*
+ * call-seq: to_json(state = nil, depth = 0)
+ *
+ * Returns a JSON string for true: 'true'.
+ */
+static VALUE mTrueClass_to_json(int argc, VALUE *argv, VALUE self)
+{
+ return rb_str_new2("true");
+}
+
+/*
+ * call-seq: to_json(state = nil, depth = 0)
+ *
+ * Returns a JSON string for false: 'false'.
+ */
+static VALUE mFalseClass_to_json(int argc, VALUE *argv, VALUE self)
+{
+ return rb_str_new2("false");
+}
+
+/*
+ * call-seq: to_json(state = nil, depth = 0)
+ *
+ */
+static VALUE mNilClass_to_json(int argc, VALUE *argv, VALUE self)
+{
+ return rb_str_new2("null");
+}
+
+/*
+ * call-seq: to_json(*)
+ *
+ * Converts this object to a string (calling #to_s), converts
+ * it to a JSON string, and returns the result. This is a fallback, if no
+ * special method #to_json was defined for some object.
+ */
+static VALUE mObject_to_json(int argc, VALUE *argv, VALUE self)
+{
+ VALUE string = rb_funcall(self, i_to_s, 0);
+ Check_Type(string, T_STRING);
+ return mString_to_json(argc, argv, string);
+}
+
+/*
+ * Document-class: JSON::Ext::Generator::State
+ *
+ * This class is used to create State instances, that are use to hold data
+ * while generating a JSON text from a a Ruby data structure.
+ */
+
+static void State_mark(JSON_Generator_State *state)
+{
+ rb_gc_mark_maybe(state->indent);
+ rb_gc_mark_maybe(state->space);
+ rb_gc_mark_maybe(state->space_before);
+ rb_gc_mark_maybe(state->object_nl);
+ rb_gc_mark_maybe(state->array_nl);
+ rb_gc_mark_maybe(state->seen);
+ rb_gc_mark_maybe(state->memo);
+ rb_gc_mark_maybe(state->depth);
+}
+
+static JSON_Generator_State *State_allocate()
+{
+ JSON_Generator_State *state = ALLOC(JSON_Generator_State);
+ return state;
+}
+
+static VALUE cState_s_allocate(VALUE klass)
+{
+ JSON_Generator_State *state = State_allocate();
+ return Data_Wrap_Struct(klass, State_mark, -1, state);
+}
+
+/*
+ * call-seq: new(opts = {})
+ *
+ * Instantiates a new State object, configured by _opts_.
+ *
+ * _opts_ can have the following keys:
+ *
+ * * *indent*: a string used to indent levels (default: ''),
+ * * *space*: a string that is put after, a : or , delimiter (default: ''),
+ * * *space_before*: a string that is put before a : pair delimiter (default: ''),
+ * * *object_nl*: a string that is put at the end of a JSON object (default: ''),
+ * * *array_nl*: a string that is put at the end of a JSON array (default: ''),
+ * * *check_circular*: true if checking for circular data structures
+ * should be done, false (the default) otherwise.
+ */
+static VALUE cState_initialize(int argc, VALUE *argv, VALUE self)
+{
+ VALUE opts;
+ GET_STATE(self);
+
+ rb_scan_args(argc, argv, "01", &opts);
+ if (NIL_P(opts)) {
+ state->indent = rb_str_new2("");
+ state->space = rb_str_new2("");
+ state->space_before = rb_str_new2("");
+ state->array_nl = rb_str_new2("");
+ state->object_nl = rb_str_new2("");
+ state->check_circular = 0;
+ } else {
+ VALUE tmp;
+ opts = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
+ tmp = rb_hash_aref(opts, ID2SYM(i_indent));
+ if (RTEST(tmp)) {
+ Check_Type(tmp, T_STRING);
+ state->indent = tmp;
+ } else {
+ state->indent = rb_str_new2("");
+ }
+ tmp = rb_hash_aref(opts, ID2SYM(i_space));
+ if (RTEST(tmp)) {
+ Check_Type(tmp, T_STRING);
+ state->space = tmp;
+ } else {
+ state->space = rb_str_new2("");
+ }
+ tmp = rb_hash_aref(opts, ID2SYM(i_space_before));
+ if (RTEST(tmp)) {
+ Check_Type(tmp, T_STRING);
+ state->space_before = tmp;
+ } else {
+ state->space_before = rb_str_new2("");
+ }
+ tmp = rb_hash_aref(opts, ID2SYM(i_array_nl));
+ if (RTEST(tmp)) {
+ Check_Type(tmp, T_STRING);
+ state->array_nl = tmp;
+ } else {
+ state->array_nl = rb_str_new2("");
+ }
+ tmp = rb_hash_aref(opts, ID2SYM(i_object_nl));
+ if (RTEST(tmp)) {
+ Check_Type(tmp, T_STRING);
+ state->object_nl = tmp;
+ } else {
+ state->object_nl = rb_str_new2("");
+ }
+ tmp = rb_hash_aref(opts, ID2SYM(i_check_circular));
+ state->check_circular = RTEST(tmp);
+ }
+ state->seen = rb_hash_new();
+ state->memo = Qnil;
+ state->depth = INT2FIX(0);
+ return self;
+}
+
+/*
+ * call-seq: from_state(opts)
+ *
+ * Creates a State object from _opts_, which ought to be Hash to create a
+ * new State instance configured by _opts_, something else to create an
+ * unconfigured instance. If _opts_ is a State object, it is just returned.
+ */
+static VALUE cState_from_state_s(VALUE self, VALUE opts)
+{
+ if (rb_obj_is_kind_of(opts, self)) {
+ return opts;
+ } else if (rb_obj_is_kind_of(opts, rb_cHash)) {
+ return rb_funcall(self, i_new, 1, opts);
+ } else {
+ return rb_funcall(self, i_new, 0);
+ }
+}
+
+/*
+ * call-seq: indent()
+ *
+ * This string is used to indent levels in the JSON text.
+ */
+static VALUE cState_indent(VALUE self)
+{
+ GET_STATE(self);
+ return state->indent;
+}
+
+/*
+ * call-seq: indent=(indent)
+ *
+ * This string is used to indent levels in the JSON text.
+ */
+static VALUE cState_indent_set(VALUE self, VALUE indent)
+{
+ GET_STATE(self);
+ Check_Type(indent, T_STRING);
+ return state->indent = indent;
+}
+
+/*
+ * call-seq: space()
+ *
+ * This string is used to insert a space between the tokens in a JSON
+ * string.
+ */
+static VALUE cState_space(VALUE self)
+{
+ GET_STATE(self);
+ return state->space;
+}
+
+/*
+ * call-seq: space=(space)
+ *
+ * This string is used to insert a space between the tokens in a JSON
+ * string.
+ */
+static VALUE cState_space_set(VALUE self, VALUE space)
+{
+ GET_STATE(self);
+ Check_Type(space, T_STRING);
+ return state->space = space;
+}
+
+/*
+ * call-seq: space_before()
+ *
+ * This string is used to insert a space before the ':' in JSON objects.
+ */
+static VALUE cState_space_before(VALUE self)
+{
+ GET_STATE(self);
+ return state->space_before;
+}
+
+/*
+ * call-seq: space_before=(space_before)
+ *
+ * This string is used to insert a space before the ':' in JSON objects.
+ */
+static VALUE cState_space_before_set(VALUE self, VALUE space_before)
+{
+ GET_STATE(self);
+ Check_Type(space_before, T_STRING);
+ return state->space_before = space_before;
+}
+
+/*
+ * call-seq: object_nl()
+ *
+ * This string is put at the end of a line that holds a JSON object (or
+ * Hash).
+ */
+static VALUE cState_object_nl(VALUE self)
+{
+ GET_STATE(self);
+ return state->object_nl;
+}
+
+/*
+ * call-seq: object_nl=(object_nl)
+ *
+ * This string is put at the end of a line that holds a JSON object (or
+ * Hash).
+ */
+static VALUE cState_object_nl_set(VALUE self, VALUE object_nl)
+{
+ GET_STATE(self);
+ Check_Type(object_nl, T_STRING);
+ return state->object_nl = object_nl;
+}
+
+/*
+ * call-seq: array_nl()
+ *
+ * This string is put at the end of a line that holds a JSON array.
+ */
+static VALUE cState_array_nl(VALUE self)
+{
+ GET_STATE(self);
+ return state->array_nl;
+}
+
+/*
+ * call-seq: array_nl=(array_nl)
+ *
+ * This string is put at the end of a line that holds a JSON array.
+ */
+static VALUE cState_array_nl_set(VALUE self, VALUE array_nl)
+{
+ GET_STATE(self);
+ Check_Type(array_nl, T_STRING);
+ return state->array_nl = array_nl;
+}
+
+/*
+ * call-seq: check_circular?(object)
+ *
+ * Returns true, if circular data structures should be checked,
+ * otherwise returns false.
+ */
+static VALUE cState_check_circular_p(VALUE self)
+{
+ GET_STATE(self);
+ return state->check_circular ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq: seen?(object)
+ *
+ * Returns _true_, if _object_ was already seen during this generating run.
+ */
+static VALUE cState_seen_p(VALUE self, VALUE object)
+{
+ GET_STATE(self);
+ return rb_hash_aref(state->seen, rb_obj_id(object));
+}
+
+/*
+ * call-seq: remember(object)
+ *
+ * Remember _object_, to find out if it was already encountered (if a cyclic
+ * data structure is rendered).
+ */
+static VALUE cState_remember(VALUE self, VALUE object)
+{
+ GET_STATE(self);
+ return rb_hash_aset(state->seen, rb_obj_id(object), Qtrue);
+}
+
+/*
+ * call-seq: forget(object)
+ *
+ * Forget _object_ for this generating run.
+ */
+static VALUE cState_forget(VALUE self, VALUE object)
+{
+ GET_STATE(self);
+ return rb_hash_delete(state->seen, rb_obj_id(object));
+}
+
+void Init_generator()
+{
+ mJSON = rb_define_module("JSON");
+ mExt = rb_define_module_under(mJSON, "Ext");
+ mGenerator = rb_define_module_under(mExt, "Generator");
+ eGeneratorError = rb_path2class("JSON::GeneratorError");
+ eCircularDatastructure = rb_path2class("JSON::CircularDatastructure");
+ cState = rb_define_class_under(mGenerator, "State", rb_cObject);
+ rb_define_alloc_func(cState, cState_s_allocate);
+ rb_define_singleton_method(cState, "from_state", cState_from_state_s, 1);
+ rb_define_method(cState, "initialize", cState_initialize, -1);
+
+ rb_define_method(cState, "indent", cState_indent, 0);
+ rb_define_method(cState, "indent=", cState_indent_set, 1);
+ rb_define_method(cState, "space", cState_space, 0);
+ rb_define_method(cState, "space=", cState_space_set, 1);
+ rb_define_method(cState, "space_before", cState_space_before, 0);
+ rb_define_method(cState, "space_before=", cState_space_before_set, 1);
+ rb_define_method(cState, "object_nl", cState_object_nl, 0);
+ rb_define_method(cState, "object_nl=", cState_object_nl_set, 1);
+ rb_define_method(cState, "array_nl", cState_array_nl, 0);
+ rb_define_method(cState, "array_nl=", cState_array_nl_set, 1);
+ rb_define_method(cState, "check_circular?", cState_check_circular_p, 0);
+ rb_define_method(cState, "seen?", cState_seen_p, 1);
+ rb_define_method(cState, "remember", cState_remember, 1);
+ rb_define_method(cState, "forget", cState_forget, 1);
+ mGeneratorMethods = rb_define_module_under(mGenerator, "GeneratorMethods");
+ mObject = rb_define_module_under(mGeneratorMethods, "Object");
+ rb_define_method(mObject, "to_json", mObject_to_json, -1);
+ mHash = rb_define_module_under(mGeneratorMethods, "Hash");
+ rb_define_method(mHash, "to_json", mHash_to_json, -1);
+ mArray = rb_define_module_under(mGeneratorMethods, "Array");
+ rb_define_method(mArray, "to_json", mArray_to_json, -1);
+ mInteger = rb_define_module_under(mGeneratorMethods, "Integer");
+ rb_define_method(mInteger, "to_json", mInteger_to_json, -1);
+ mFloat = rb_define_module_under(mGeneratorMethods, "Float");
+ rb_define_method(mFloat, "to_json", mFloat_to_json, -1);
+ mString = rb_define_module_under(mGeneratorMethods, "String");
+ rb_define_singleton_method(mString, "included", mString_included_s, 1);
+ rb_define_method(mString, "to_json", mString_to_json, -1);
+ rb_define_method(mString, "to_json_raw", mString_to_json_raw, -1);
+ rb_define_method(mString, "to_json_raw_object", mString_to_json_raw_object, 0);
+ mString_Extend = rb_define_module_under(mString, "Extend");
+ rb_define_method(mString_Extend, "json_create", mString_Extend_json_create, 1);
+ mTrueClass = rb_define_module_under(mGeneratorMethods, "TrueClass");
+ rb_define_method(mTrueClass, "to_json", mTrueClass_to_json, -1);
+ mFalseClass = rb_define_module_under(mGeneratorMethods, "FalseClass");
+ rb_define_method(mFalseClass, "to_json", mFalseClass_to_json, -1);
+ mNilClass = rb_define_module_under(mGeneratorMethods, "NilClass");
+ rb_define_method(mNilClass, "to_json", mNilClass_to_json, -1);
+
+ i_to_s = rb_intern("to_s");
+ i_to_json = rb_intern("to_json");
+ i_new = rb_intern("new");
+ i_indent = rb_intern("indent");
+ i_space = rb_intern("space");
+ i_space_before = rb_intern("space_before");
+ i_object_nl = rb_intern("object_nl");
+ i_array_nl = rb_intern("array_nl");
+ i_check_circular = rb_intern("check_circular");
+ i_pack = rb_intern("pack");
+ i_unpack = rb_intern("unpack");
+ i_create_id = rb_intern("create_id");
+ i_extend = rb_intern("extend");
+}
diff --git a/ext/json/ext/generator/unicode.c b/ext/json/ext/generator/unicode.c
new file mode 100644
index 0000000..44e1f41
--- /dev/null
+++ b/ext/json/ext/generator/unicode.c
@@ -0,0 +1,184 @@
+/* vim: set cin et sw=4 ts=4: */
+
+#include "unicode.h"
+
+#define unicode_escape(buffer, character) \
+ snprintf(buf, 7, "\\u%04x", (unsigned int) (character)); \
+ rb_str_buf_cat(buffer, buf, 6);
+
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ *
+ * Disclaimer
+ *
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ *
+ * Limitations on Rights to Redistribute This Code
+ *
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/*
+ * Index into the table below with the first byte of a UTF-8 sequence to
+ * get the number of trailing bytes that are supposed to follow it.
+ * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
+ * left as-is for anyone who may want to do such conversion, which was
+ * allowed in earlier algorithms.
+ */
+static const char trailingBytesForUTF8[256] = {
+ 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,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,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,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+ 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+/*
+ * Magic values subtracted from a buffer value during UTF8 conversion.
+ * This table contains as many values as there might be trailing bytes
+ * in a UTF-8 sequence.
+ */
+static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
+ 0x03C82080UL, 0xFA082080UL, 0x82082080UL };
+
+/*
+ * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
+ * into the first byte, depending on how many bytes follow. There are
+ * as many entries in this table as there are UTF-8 sequence types.
+ * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
+ * for *legal* UTF-8 will be 4 or fewer bytes total.
+ */
+static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+/*
+ * Utility routine to tell whether a sequence of bytes is legal UTF-8.
+ * This must be called with the length pre-determined by the first byte.
+ * If not calling this from ConvertUTF8to*, then the length can be set by:
+ * length = trailingBytesForUTF8[*source]+1;
+ * and the sequence is illegal right away if there aren't that many bytes
+ * available.
+ * If presented with a length > 4, this returns 0. The Unicode
+ * definition of UTF-8 goes up to 4-byte sequences.
+ */
+
+inline static unsigned char isLegalUTF8(const UTF8 *source, int length)
+{
+ UTF8 a;
+ const UTF8 *srcptr = source+length;
+ switch (length) {
+ default: return 0;
+ /* Everything else falls through when "1"... */
+ case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+ case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+ case 2: if ((a = (*--srcptr)) > 0xBF) return 0;
+
+ switch (*source) {
+ /* no fall-through in this inner switch */
+ case 0xE0: if (a < 0xA0) return 0; break;
+ case 0xED: if (a > 0x9F) return 0; break;
+ case 0xF0: if (a < 0x90) return 0; break;
+ case 0xF4: if (a > 0x8F) return 0; break;
+ default: if (a < 0x80) return 0;
+ }
+
+ case 1: if (*source >= 0x80 && *source < 0xC2) return 0;
+ }
+ if (*source > 0xF4) return 0;
+ return 1;
+}
+
+void JSON_convert_UTF8_to_JSON(VALUE buffer, VALUE string, ConversionFlags flags)
+{
+ char buf[7];
+ const UTF8* source = (UTF8 *) RSTRING_PTR(string);
+ const UTF8* sourceEnd = source + RSTRING_LEN(string);
+
+ while (source < sourceEnd) {
+ UTF32 ch = 0;
+ unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
+ if (source + extraBytesToRead >= sourceEnd) {
+ rb_raise(rb_path2class("JSON::GeneratorError"),
+ "partial character in source, but hit end");
+ }
+ if (!isLegalUTF8(source, extraBytesToRead+1)) {
+ rb_raise(rb_path2class("JSON::GeneratorError"),
+ "source sequence is illegal/malformed");
+ }
+ /*
+ * The cases all fall through. See "Note A" below.
+ */
+ switch (extraBytesToRead) {
+ case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
+ case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
+ case 3: ch += *source++; ch <<= 6;
+ case 2: ch += *source++; ch <<= 6;
+ case 1: ch += *source++; ch <<= 6;
+ case 0: ch += *source++;
+ }
+ ch -= offsetsFromUTF8[extraBytesToRead];
+
+ if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
+ /* UTF-16 surrogate values are illegal in UTF-32 */
+ if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+ if (flags == strictConversion) {
+ source -= (extraBytesToRead+1); /* return to the illegal value itself */
+ rb_raise(rb_path2class("JSON::GeneratorError"),
+ "source sequence is illegal/malformed");
+ } else {
+ unicode_escape(buffer, UNI_REPLACEMENT_CHAR);
+ }
+ } else {
+ /* normal case */
+ if (ch == '"') {
+ rb_str_buf_cat2(buffer, "\\\"");
+ } else if (ch == '\\') {
+ rb_str_buf_cat2(buffer, "\\\\");
+ } else if (ch == '/') {
+ rb_str_buf_cat2(buffer, "\\/");
+ } else if (ch >= 0x20 && ch <= 0x7f) {
+ rb_str_buf_cat(buffer, (char *) source - 1, 1);
+ } else if (ch == '\n') {
+ rb_str_buf_cat2(buffer, "\\n");
+ } else if (ch == '\r') {
+ rb_str_buf_cat2(buffer, "\\r");
+ } else if (ch == '\t') {
+ rb_str_buf_cat2(buffer, "\\t");
+ } else if (ch == '\f') {
+ rb_str_buf_cat2(buffer, "\\f");
+ } else if (ch == '\b') {
+ rb_str_buf_cat2(buffer, "\\b");
+ } else if (ch < 0x20) {
+ unicode_escape(buffer, (UTF16) ch);
+ } else {
+ unicode_escape(buffer, (UTF16) ch);
+ }
+ }
+ } else if (ch > UNI_MAX_UTF16) {
+ if (flags == strictConversion) {
+ source -= (extraBytesToRead+1); /* return to the start */
+ rb_raise(rb_path2class("JSON::GeneratorError"),
+ "source sequence is illegal/malformed");
+ } else {
+ unicode_escape(buffer, UNI_REPLACEMENT_CHAR);
+ }
+ } else {
+ /* target is a character in range 0xFFFF - 0x10FFFF. */
+ ch -= halfBase;
+ unicode_escape(buffer, (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START));
+ unicode_escape(buffer, (UTF16)((ch & halfMask) + UNI_SUR_LOW_START));
+ }
+ }
+}
diff --git a/ext/json/ext/generator/unicode.h b/ext/json/ext/generator/unicode.h
new file mode 100755
index 0000000..841474b
--- /dev/null
+++ b/ext/json/ext/generator/unicode.h
@@ -0,0 +1,53 @@
+#include "ruby.h"
+
+#ifndef _GENERATOR_UNICODE_H_
+#define _GENERATOR_UNICODE_H_
+
+typedef enum {
+ conversionOK = 0, /* conversion successful */
+ sourceExhausted, /* partial character in source, but hit end */
+ targetExhausted, /* insuff. room in target for conversion */
+ sourceIllegal /* source sequence is illegal/malformed */
+} ConversionResult;
+
+typedef enum {
+ strictConversion = 0,
+ lenientConversion
+} ConversionFlags;
+
+typedef unsigned long UTF32; /* at least 32 bits */
+typedef unsigned short UTF16; /* at least 16 bits */
+typedef unsigned char UTF8; /* typically 8 bits */
+
+#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
+#define UNI_MAX_BMP (UTF32)0x0000FFFF
+#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
+#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
+#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
+
+#define UNI_SUR_HIGH_START (UTF32)0xD800
+#define UNI_SUR_HIGH_END (UTF32)0xDBFF
+#define UNI_SUR_LOW_START (UTF32)0xDC00
+#define UNI_SUR_LOW_END (UTF32)0xDFFF
+
+static const int halfShift = 10; /* used for shifting by 10 bits */
+
+static const UTF32 halfBase = 0x0010000UL;
+static const UTF32 halfMask = 0x3FFUL;
+
+void JSON_convert_UTF8_to_JSON(VALUE buffer, VALUE string, ConversionFlags flags);
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(ARRAY) RARRAY(ARRAY)->ptr
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(ARRAY) RARRAY(ARRAY)->len
+#endif
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(string) RSTRING(string)->ptr
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(string) RSTRING(string)->len
+#endif
+
+#endif
diff --git a/ext/json/ext/parser/extconf.h b/ext/json/ext/parser/extconf.h
new file mode 100644
index 0000000..cda0cc8
--- /dev/null
+++ b/ext/json/ext/parser/extconf.h
@@ -0,0 +1,3 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#endif
diff --git a/ext/json/ext/parser/extconf.rb b/ext/json/ext/parser/extconf.rb
new file mode 100644
index 0000000..085c8d0
--- /dev/null
+++ b/ext/json/ext/parser/extconf.rb
@@ -0,0 +1,9 @@
+require 'mkmf'
+require 'rbconfig'
+
+if CONFIG['CC'] =~ /gcc/
+ #CONFIG['CC'] += ' -Wall -ggdb'
+ CONFIG['CC'] += ' -Wall'
+end
+
+create_makefile 'json/ext/parser'
diff --git a/ext/json/ext/parser/parser.c b/ext/json/ext/parser/parser.c
new file mode 100644
index 0000000..7448e5f
--- /dev/null
+++ b/ext/json/ext/parser/parser.c
@@ -0,0 +1,1601 @@
+#line 1 "parser.rl"
+/* vim: set cin et sw=4 ts=4: */
+
+#include "ruby.h"
+#include "re.h"
+#include "st.h"
+#include "unicode.h"
+
+#define EVIL 0x666
+
+static VALUE mJSON, mExt, cParser, eParserError, eNestingError;
+
+static ID i_json_creatable_p, i_json_create, i_create_id, i_chr, i_max_nesting;
+
+typedef struct JSON_ParserStruct {
+ VALUE Vsource;
+ char *source;
+ long len;
+ char *memo;
+ VALUE create_id;
+ int max_nesting;
+ int current_nesting;
+} JSON_Parser;
+
+static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result);
+
+#define GET_STRUCT \
+ JSON_Parser *json; \
+ Data_Get_Struct(self, JSON_Parser, json);
+
+#line 58 "parser.rl"
+
+
+
+#line 41 "parser.c"
+static const int JSON_object_start = 1;
+static const int JSON_object_first_final = 27;
+static const int JSON_object_error = 0;
+
+static const int JSON_object_en_main = 1;
+
+#line 91 "parser.rl"
+
+
+static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+ VALUE last_name = Qnil;
+
+ if (json->max_nesting && json->current_nesting > json->max_nesting) {
+ rb_raise(eNestingError, "nesting of %d is to deep", json->current_nesting);
+ }
+
+ *result = rb_hash_new();
+
+
+#line 63 "parser.c"
+ {
+ cs = JSON_object_start;
+ }
+#line 105 "parser.rl"
+
+#line 69 "parser.c"
+ {
+ if ( p == pe )
+ goto _out;
+ switch ( cs )
+ {
+case 1:
+ if ( (*p) == 123 )
+ goto st2;
+ goto st0;
+st0:
+ goto _out0;
+st2:
+ if ( ++p == pe )
+ goto _out2;
+case 2:
+ switch( (*p) ) {
+ case 13: goto st2;
+ case 32: goto st2;
+ case 34: goto tr2;
+ case 47: goto st23;
+ case 125: goto tr4;
+ }
+ if ( 9 <= (*p) && (*p) <= 10 )
+ goto st2;
+ goto st0;
+tr2:
+#line 77 "parser.rl"
+ {
+ char *np = JSON_parse_string(json, p, pe, &last_name);
+ if (np == NULL) goto _out3; else {p = (( np))-1;}
+ }
+ goto st3;
+st3:
+ if ( ++p == pe )
+ goto _out3;
+case 3:
+#line 106 "parser.c"
+ 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:
+ if ( ++p == pe )
+ goto _out4;
+case 4:
+ switch( (*p) ) {
+ case 42: goto st5;
+ case 47: goto st7;
+ }
+ goto st0;
+st5:
+ if ( ++p == pe )
+ goto _out5;
+case 5:
+ if ( (*p) == 42 )
+ goto st6;
+ goto st5;
+st6:
+ if ( ++p == pe )
+ goto _out6;
+case 6:
+ switch( (*p) ) {
+ case 42: goto st6;
+ case 47: goto st3;
+ }
+ goto st5;
+st7:
+ if ( ++p == pe )
+ goto _out7;
+case 7:
+ if ( (*p) == 10 )
+ goto st3;
+ goto st7;
+st8:
+ if ( ++p == pe )
+ goto _out8;
+case 8:
+ switch( (*p) ) {
+ case 13: goto st8;
+ case 32: goto st8;
+ case 34: goto tr11;
+ case 45: goto tr11;
+ case 47: goto st19;
+ case 91: goto tr11;
+ case 102: goto tr11;
+ case 110: goto tr11;
+ case 116: goto tr11;
+ case 123: goto tr11;
+ }
+ if ( (*p) > 10 ) {
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto tr11;
+ } else if ( (*p) >= 9 )
+ goto st8;
+ goto st0;
+tr11:
+#line 66 "parser.rl"
+ {
+ VALUE v = Qnil;
+ char *np = JSON_parse_value(json, p, pe, &v);
+ if (np == NULL) {
+ goto _out9;
+ } else {
+ rb_hash_aset(*result, last_name, v);
+ {p = (( np))-1;}
+ }
+ }
+ goto st9;
+st9:
+ if ( ++p == pe )
+ goto _out9;
+case 9:
+#line 187 "parser.c"
+ switch( (*p) ) {
+ case 13: goto st9;
+ case 32: goto st9;
+ case 44: goto st10;
+ case 47: goto st15;
+ case 125: goto tr4;
+ }
+ if ( 9 <= (*p) && (*p) <= 10 )
+ goto st9;
+ goto st0;
+st10:
+ if ( ++p == pe )
+ goto _out10;
+case 10:
+ switch( (*p) ) {
+ case 13: goto st10;
+ case 32: goto st10;
+ case 34: goto tr2;
+ case 47: goto st11;
+ }
+ if ( 9 <= (*p) && (*p) <= 10 )
+ goto st10;
+ goto st0;
+st11:
+ if ( ++p == pe )
+ goto _out11;
+case 11:
+ switch( (*p) ) {
+ case 42: goto st12;
+ case 47: goto st14;
+ }
+ goto st0;
+st12:
+ if ( ++p == pe )
+ goto _out12;
+case 12:
+ if ( (*p) == 42 )
+ goto st13;
+ goto st12;
+st13:
+ if ( ++p == pe )
+ goto _out13;
+case 13:
+ switch( (*p) ) {
+ case 42: goto st13;
+ case 47: goto st10;
+ }
+ goto st12;
+st14:
+ if ( ++p == pe )
+ goto _out14;
+case 14:
+ if ( (*p) == 10 )
+ goto st10;
+ goto st14;
+st15:
+ if ( ++p == pe )
+ goto _out15;
+case 15:
+ switch( (*p) ) {
+ case 42: goto st16;
+ case 47: goto st18;
+ }
+ goto st0;
+st16:
+ if ( ++p == pe )
+ goto _out16;
+case 16:
+ if ( (*p) == 42 )
+ goto st17;
+ goto st16;
+st17:
+ if ( ++p == pe )
+ goto _out17;
+case 17:
+ switch( (*p) ) {
+ case 42: goto st17;
+ case 47: goto st9;
+ }
+ goto st16;
+st18:
+ if ( ++p == pe )
+ goto _out18;
+case 18:
+ if ( (*p) == 10 )
+ goto st9;
+ goto st18;
+tr4:
+#line 82 "parser.rl"
+ { goto _out27; }
+ goto st27;
+st27:
+ if ( ++p == pe )
+ goto _out27;
+case 27:
+#line 283 "parser.c"
+ goto st0;
+st19:
+ if ( ++p == pe )
+ goto _out19;
+case 19:
+ switch( (*p) ) {
+ case 42: goto st20;
+ case 47: goto st22;
+ }
+ goto st0;
+st20:
+ if ( ++p == pe )
+ goto _out20;
+case 20:
+ if ( (*p) == 42 )
+ goto st21;
+ goto st20;
+st21:
+ if ( ++p == pe )
+ goto _out21;
+case 21:
+ switch( (*p) ) {
+ case 42: goto st21;
+ case 47: goto st8;
+ }
+ goto st20;
+st22:
+ if ( ++p == pe )
+ goto _out22;
+case 22:
+ if ( (*p) == 10 )
+ goto st8;
+ goto st22;
+st23:
+ if ( ++p == pe )
+ goto _out23;
+case 23:
+ switch( (*p) ) {
+ case 42: goto st24;
+ case 47: goto st26;
+ }
+ goto st0;
+st24:
+ if ( ++p == pe )
+ goto _out24;
+case 24:
+ if ( (*p) == 42 )
+ goto st25;
+ goto st24;
+st25:
+ if ( ++p == pe )
+ goto _out25;
+case 25:
+ switch( (*p) ) {
+ case 42: goto st25;
+ case 47: goto st2;
+ }
+ goto st24;
+st26:
+ if ( ++p == pe )
+ goto _out26;
+case 26:
+ if ( (*p) == 10 )
+ goto st2;
+ goto st26;
+ }
+ _out0: cs = 0; goto _out;
+ _out2: cs = 2; goto _out;
+ _out3: cs = 3; goto _out;
+ _out4: cs = 4; goto _out;
+ _out5: cs = 5; goto _out;
+ _out6: cs = 6; goto _out;
+ _out7: cs = 7; goto _out;
+ _out8: cs = 8; goto _out;
+ _out9: cs = 9; goto _out;
+ _out10: cs = 10; goto _out;
+ _out11: cs = 11; goto _out;
+ _out12: cs = 12; goto _out;
+ _out13: cs = 13; goto _out;
+ _out14: cs = 14; goto _out;
+ _out15: cs = 15; goto _out;
+ _out16: cs = 16; goto _out;
+ _out17: cs = 17; goto _out;
+ _out18: cs = 18; goto _out;
+ _out27: cs = 27; goto _out;
+ _out19: cs = 19; goto _out;
+ _out20: cs = 20; goto _out;
+ _out21: cs = 21; goto _out;
+ _out22: cs = 22; goto _out;
+ _out23: cs = 23; goto _out;
+ _out24: cs = 24; goto _out;
+ _out25: cs = 25; goto _out;
+ _out26: cs = 26; goto _out;
+
+ _out: {}
+ }
+#line 106 "parser.rl"
+
+ if (cs >= JSON_object_first_final) {
+ VALUE klassname = rb_hash_aref(*result, json->create_id);
+ if (!NIL_P(klassname)) {
+ VALUE klass = rb_path2class(StringValueCStr(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;
+ }
+}
+
+
+#line 397 "parser.c"
+static const int JSON_value_start = 1;
+static const int JSON_value_first_final = 12;
+static const int JSON_value_error = 0;
+
+static const int JSON_value_en_main = 1;
+
+#line 177 "parser.rl"
+
+
+static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+
+#line 412 "parser.c"
+ {
+ cs = JSON_value_start;
+ }
+#line 184 "parser.rl"
+
+#line 418 "parser.c"
+ {
+ if ( p == pe )
+ goto _out;
+ switch ( cs )
+ {
+case 1:
+ switch( (*p) ) {
+ case 34: goto tr0;
+ case 45: goto tr2;
+ case 91: goto tr3;
+ case 102: goto st2;
+ case 110: goto st6;
+ case 116: goto st9;
+ case 123: goto tr7;
+ }
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto tr2;
+ goto st0;
+st0:
+ goto _out0;
+tr0:
+#line 136 "parser.rl"
+ {
+ char *np = JSON_parse_string(json, p, pe, result);
+ if (np == NULL) goto _out12; else {p = (( np))-1;}
+ }
+ goto st12;
+tr2:
+#line 141 "parser.rl"
+ {
+ char *np;
+ 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;}
+ goto _out12;
+ }
+ goto st12;
+tr3:
+#line 150 "parser.rl"
+ {
+ char *np;
+ json->current_nesting += 1;
+ np = JSON_parse_array(json, p, pe, result);
+ json->current_nesting -= 1;
+ if (np == NULL) goto _out12; else {p = (( np))-1;}
+ }
+ goto st12;
+tr7:
+#line 158 "parser.rl"
+ {
+ char *np;
+ json->current_nesting += 1;
+ np = JSON_parse_object(json, p, pe, result);
+ json->current_nesting -= 1;
+ if (np == NULL) goto _out12; else {p = (( np))-1;}
+ }
+ goto st12;
+tr11:
+#line 130 "parser.rl"
+ {
+ *result = Qfalse;
+ }
+ goto st12;
+tr14:
+#line 127 "parser.rl"
+ {
+ *result = Qnil;
+ }
+ goto st12;
+tr17:
+#line 133 "parser.rl"
+ {
+ *result = Qtrue;
+ }
+ goto st12;
+st12:
+ if ( ++p == pe )
+ goto _out12;
+case 12:
+#line 166 "parser.rl"
+ { goto _out12; }
+#line 501 "parser.c"
+ goto st0;
+st2:
+ if ( ++p == pe )
+ goto _out2;
+case 2:
+ if ( (*p) == 97 )
+ goto st3;
+ goto st0;
+st3:
+ if ( ++p == pe )
+ goto _out3;
+case 3:
+ if ( (*p) == 108 )
+ goto st4;
+ goto st0;
+st4:
+ if ( ++p == pe )
+ goto _out4;
+case 4:
+ if ( (*p) == 115 )
+ goto st5;
+ goto st0;
+st5:
+ if ( ++p == pe )
+ goto _out5;
+case 5:
+ if ( (*p) == 101 )
+ goto tr11;
+ goto st0;
+st6:
+ if ( ++p == pe )
+ goto _out6;
+case 6:
+ if ( (*p) == 117 )
+ goto st7;
+ goto st0;
+st7:
+ if ( ++p == pe )
+ goto _out7;
+case 7:
+ if ( (*p) == 108 )
+ goto st8;
+ goto st0;
+st8:
+ if ( ++p == pe )
+ goto _out8;
+case 8:
+ if ( (*p) == 108 )
+ goto tr14;
+ goto st0;
+st9:
+ if ( ++p == pe )
+ goto _out9;
+case 9:
+ if ( (*p) == 114 )
+ goto st10;
+ goto st0;
+st10:
+ if ( ++p == pe )
+ goto _out10;
+case 10:
+ if ( (*p) == 117 )
+ goto st11;
+ goto st0;
+st11:
+ if ( ++p == pe )
+ goto _out11;
+case 11:
+ if ( (*p) == 101 )
+ goto tr17;
+ goto st0;
+ }
+ _out0: cs = 0; goto _out;
+ _out12: cs = 12; goto _out;
+ _out2: cs = 2; goto _out;
+ _out3: cs = 3; goto _out;
+ _out4: cs = 4; goto _out;
+ _out5: cs = 5; goto _out;
+ _out6: cs = 6; goto _out;
+ _out7: cs = 7; goto _out;
+ _out8: cs = 8; goto _out;
+ _out9: cs = 9; goto _out;
+ _out10: cs = 10; goto _out;
+ _out11: cs = 11; goto _out;
+
+ _out: {}
+ }
+#line 185 "parser.rl"
+
+ if (cs >= JSON_value_first_final) {
+ return p;
+ } else {
+ return NULL;
+ }
+}
+
+
+#line 599 "parser.c"
+static const int JSON_integer_start = 1;
+static const int JSON_integer_first_final = 5;
+static const int JSON_integer_error = 0;
+
+static const int JSON_integer_en_main = 1;
+
+#line 201 "parser.rl"
+
+
+static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+
+#line 614 "parser.c"
+ {
+ cs = JSON_integer_start;
+ }
+#line 208 "parser.rl"
+ json->memo = p;
+
+#line 621 "parser.c"
+ {
+ if ( p == pe )
+ goto _out;
+ switch ( cs )
+ {
+case 1:
+ switch( (*p) ) {
+ case 45: goto st2;
+ case 48: goto st3;
+ }
+ if ( 49 <= (*p) && (*p) <= 57 )
+ goto st4;
+ goto st0;
+st0:
+ goto _out0;
+st2:
+ if ( ++p == pe )
+ goto _out2;
+case 2:
+ if ( (*p) == 48 )
+ goto st3;
+ if ( 49 <= (*p) && (*p) <= 57 )
+ goto st4;
+ goto st0;
+st3:
+ if ( ++p == pe )
+ goto _out3;
+case 3:
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto st0;
+ goto tr4;
+tr4:
+#line 198 "parser.rl"
+ { goto _out5; }
+ goto st5;
+st5:
+ if ( ++p == pe )
+ goto _out5;
+case 5:
+#line 661 "parser.c"
+ goto st0;
+st4:
+ if ( ++p == pe )
+ goto _out4;
+case 4:
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto st4;
+ goto tr4;
+ }
+ _out0: cs = 0; goto _out;
+ _out2: cs = 2; goto _out;
+ _out3: cs = 3; goto _out;
+ _out5: cs = 5; goto _out;
+ _out4: cs = 4; goto _out;
+
+ _out: {}
+ }
+#line 210 "parser.rl"
+
+ if (cs >= JSON_integer_first_final) {
+ long len = p - json->memo;
+ *result = rb_Integer(rb_str_new(json->memo, len));
+ return p + 1;
+ } else {
+ return NULL;
+ }
+}
+
+
+#line 691 "parser.c"
+static const int JSON_float_start = 1;
+static const int JSON_float_first_final = 10;
+static const int JSON_float_error = 0;
+
+static const int JSON_float_en_main = 1;
+
+#line 232 "parser.rl"
+
+
+static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+
+#line 706 "parser.c"
+ {
+ cs = JSON_float_start;
+ }
+#line 239 "parser.rl"
+ json->memo = p;
+
+#line 713 "parser.c"
+ {
+ if ( p == pe )
+ goto _out;
+ switch ( cs )
+ {
+case 1:
+ switch( (*p) ) {
+ case 45: goto st2;
+ case 48: goto st3;
+ }
+ if ( 49 <= (*p) && (*p) <= 57 )
+ goto st9;
+ goto st0;
+st0:
+ goto _out0;
+st2:
+ if ( ++p == pe )
+ goto _out2;
+case 2:
+ if ( (*p) == 48 )
+ goto st3;
+ if ( 49 <= (*p) && (*p) <= 57 )
+ goto st9;
+ goto st0;
+st3:
+ if ( ++p == pe )
+ goto _out3;
+case 3:
+ switch( (*p) ) {
+ case 46: goto st4;
+ case 69: goto st6;
+ case 101: goto st6;
+ }
+ goto st0;
+st4:
+ if ( ++p == pe )
+ goto _out4;
+case 4:
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto st5;
+ goto st0;
+st5:
+ if ( ++p == pe )
+ goto _out5;
+case 5:
+ switch( (*p) ) {
+ case 69: goto st6;
+ case 101: goto st6;
+ }
+ if ( (*p) > 46 ) {
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto st5;
+ } else if ( (*p) >= 45 )
+ goto st0;
+ goto tr7;
+tr7:
+#line 226 "parser.rl"
+ { goto _out10; }
+ goto st10;
+st10:
+ if ( ++p == pe )
+ goto _out10;
+case 10:
+#line 777 "parser.c"
+ goto st0;
+st6:
+ if ( ++p == pe )
+ goto _out6;
+case 6:
+ switch( (*p) ) {
+ case 43: goto st7;
+ case 45: goto st7;
+ }
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto st8;
+ goto st0;
+st7:
+ if ( ++p == pe )
+ goto _out7;
+case 7:
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto st8;
+ goto st0;
+st8:
+ if ( ++p == pe )
+ goto _out8;
+case 8:
+ switch( (*p) ) {
+ case 69: goto st0;
+ case 101: goto st0;
+ }
+ if ( (*p) > 46 ) {
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto st8;
+ } else if ( (*p) >= 45 )
+ goto st0;
+ goto tr7;
+st9:
+ if ( ++p == pe )
+ goto _out9;
+case 9:
+ switch( (*p) ) {
+ case 46: goto st4;
+ case 69: goto st6;
+ case 101: goto st6;
+ }
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto st9;
+ goto st0;
+ }
+ _out0: cs = 0; goto _out;
+ _out2: cs = 2; goto _out;
+ _out3: cs = 3; goto _out;
+ _out4: cs = 4; goto _out;
+ _out5: cs = 5; goto _out;
+ _out10: cs = 10; goto _out;
+ _out6: cs = 6; goto _out;
+ _out7: cs = 7; goto _out;
+ _out8: cs = 8; goto _out;
+ _out9: cs = 9; goto _out;
+
+ _out: {}
+ }
+#line 241 "parser.rl"
+
+ if (cs >= JSON_float_first_final) {
+ long len = p - json->memo;
+ *result = rb_Float(rb_str_new(json->memo, len));
+ return p + 1;
+ } else {
+ return NULL;
+ }
+}
+
+
+
+#line 850 "parser.c"
+static const int JSON_array_start = 1;
+static const int JSON_array_first_final = 17;
+static const int JSON_array_error = 0;
+
+static const int JSON_array_en_main = 1;
+
+#line 277 "parser.rl"
+
+
+static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+ if (json->max_nesting && json->current_nesting > json->max_nesting) {
+ rb_raise(eNestingError, "nesting of %d is to deep", json->current_nesting);
+ }
+ *result = rb_ary_new();
+
+
+#line 870 "parser.c"
+ {
+ cs = JSON_array_start;
+ }
+#line 289 "parser.rl"
+
+#line 876 "parser.c"
+ {
+ if ( p == pe )
+ goto _out;
+ switch ( cs )
+ {
+case 1:
+ if ( (*p) == 91 )
+ goto st2;
+ goto st0;
+st0:
+ goto _out0;
+st2:
+ if ( ++p == pe )
+ goto _out2;
+case 2:
+ switch( (*p) ) {
+ case 13: goto st2;
+ case 32: goto st2;
+ case 34: goto tr2;
+ case 45: goto tr2;
+ case 47: goto st13;
+ case 91: goto tr2;
+ case 93: goto tr4;
+ case 102: goto tr2;
+ case 110: goto tr2;
+ case 116: goto tr2;
+ case 123: goto tr2;
+ }
+ if ( (*p) > 10 ) {
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto tr2;
+ } else if ( (*p) >= 9 )
+ goto st2;
+ goto st0;
+tr2:
+#line 258 "parser.rl"
+ {
+ VALUE v = Qnil;
+ char *np = JSON_parse_value(json, p, pe, &v);
+ if (np == NULL) {
+ goto _out3;
+ } else {
+ rb_ary_push(*result, v);
+ {p = (( np))-1;}
+ }
+ }
+ goto st3;
+st3:
+ if ( ++p == pe )
+ goto _out3;
+case 3:
+#line 928 "parser.c"
+ switch( (*p) ) {
+ case 13: goto st3;
+ case 32: goto st3;
+ case 44: goto st4;
+ case 47: goto st9;
+ case 93: goto tr4;
+ }
+ if ( 9 <= (*p) && (*p) <= 10 )
+ goto st3;
+ goto st0;
+st4:
+ if ( ++p == pe )
+ goto _out4;
+case 4:
+ switch( (*p) ) {
+ case 13: goto st4;
+ case 32: goto st4;
+ case 34: goto tr2;
+ case 45: goto tr2;
+ case 47: goto st5;
+ case 91: goto tr2;
+ case 102: goto tr2;
+ case 110: goto tr2;
+ case 116: goto tr2;
+ case 123: goto tr2;
+ }
+ if ( (*p) > 10 ) {
+ if ( 48 <= (*p) && (*p) <= 57 )
+ goto tr2;
+ } else if ( (*p) >= 9 )
+ goto st4;
+ goto st0;
+st5:
+ if ( ++p == pe )
+ goto _out5;
+case 5:
+ switch( (*p) ) {
+ case 42: goto st6;
+ case 47: goto st8;
+ }
+ goto st0;
+st6:
+ if ( ++p == pe )
+ goto _out6;
+case 6:
+ if ( (*p) == 42 )
+ goto st7;
+ goto st6;
+st7:
+ if ( ++p == pe )
+ goto _out7;
+case 7:
+ switch( (*p) ) {
+ case 42: goto st7;
+ case 47: goto st4;
+ }
+ goto st6;
+st8:
+ if ( ++p == pe )
+ goto _out8;
+case 8:
+ if ( (*p) == 10 )
+ goto st4;
+ goto st8;
+st9:
+ if ( ++p == pe )
+ goto _out9;
+case 9:
+ switch( (*p) ) {
+ case 42: goto st10;
+ case 47: goto st12;
+ }
+ goto st0;
+st10:
+ if ( ++p == pe )
+ goto _out10;
+case 10:
+ if ( (*p) == 42 )
+ goto st11;
+ goto st10;
+st11:
+ if ( ++p == pe )
+ goto _out11;
+case 11:
+ switch( (*p) ) {
+ case 42: goto st11;
+ case 47: goto st3;
+ }
+ goto st10;
+st12:
+ if ( ++p == pe )
+ goto _out12;
+case 12:
+ if ( (*p) == 10 )
+ goto st3;
+ goto st12;
+tr4:
+#line 269 "parser.rl"
+ { goto _out17; }
+ goto st17;
+st17:
+ if ( ++p == pe )
+ goto _out17;
+case 17:
+#line 1033 "parser.c"
+ goto st0;
+st13:
+ if ( ++p == pe )
+ goto _out13;
+case 13:
+ switch( (*p) ) {
+ case 42: goto st14;
+ case 47: goto st16;
+ }
+ goto st0;
+st14:
+ if ( ++p == pe )
+ goto _out14;
+case 14:
+ if ( (*p) == 42 )
+ goto st15;
+ goto st14;
+st15:
+ if ( ++p == pe )
+ goto _out15;
+case 15:
+ switch( (*p) ) {
+ case 42: goto st15;
+ case 47: goto st2;
+ }
+ goto st14;
+st16:
+ if ( ++p == pe )
+ goto _out16;
+case 16:
+ if ( (*p) == 10 )
+ goto st2;
+ goto st16;
+ }
+ _out0: cs = 0; goto _out;
+ _out2: cs = 2; goto _out;
+ _out3: cs = 3; goto _out;
+ _out4: cs = 4; goto _out;
+ _out5: cs = 5; goto _out;
+ _out6: cs = 6; goto _out;
+ _out7: cs = 7; goto _out;
+ _out8: cs = 8; goto _out;
+ _out9: cs = 9; goto _out;
+ _out10: cs = 10; goto _out;
+ _out11: cs = 11; goto _out;
+ _out12: cs = 12; goto _out;
+ _out17: cs = 17; goto _out;
+ _out13: cs = 13; goto _out;
+ _out14: cs = 14; goto _out;
+ _out15: cs = 15; goto _out;
+ _out16: cs = 16; goto _out;
+
+ _out: {}
+ }
+#line 290 "parser.rl"
+
+ if(cs >= JSON_array_first_final) {
+ return p + 1;
+ } else {
+ rb_raise(eParserError, "unexpected token at '%s'", p);
+ }
+}
+
+static VALUE json_string_unescape(char *p, char *pe)
+{
+ VALUE result = rb_str_buf_new(pe - p + 1);
+
+ while (p < pe) {
+ if (*p == '\\') {
+ p++;
+ if (p >= pe) return Qnil; /* raise an exception later, \ at end */
+ switch (*p) {
+ case '"':
+ case '\\':
+ rb_str_buf_cat(result, p, 1);
+ p++;
+ break;
+ case 'b':
+ rb_str_buf_cat2(result, "\b");
+ p++;
+ break;
+ case 'f':
+ rb_str_buf_cat2(result, "\f");
+ p++;
+ break;
+ case 'n':
+ rb_str_buf_cat2(result, "\n");
+ p++;
+ break;
+ case 'r':
+ rb_str_buf_cat2(result, "\r");
+ p++;
+ break;
+ case 't':
+ rb_str_buf_cat2(result, "\t");
+ p++;
+ break;
+ case 'u':
+ if (p > pe - 4) {
+ return Qnil;
+ } else {
+ p = JSON_convert_UTF16_to_UTF8(result, p, pe, strictConversion);
+ }
+ break;
+ default:
+ rb_str_buf_cat(result, p, 1);
+ p++;
+ break;
+ }
+ } else {
+ char *q = p;
+ while (*q != '\\' && q < pe) q++;
+ rb_str_buf_cat(result, p, q - p);
+ p = q;
+ }
+ }
+ return result;
+}
+
+
+#line 1154 "parser.c"
+static const int JSON_string_start = 1;
+static const int JSON_string_first_final = 8;
+static const int JSON_string_error = 0;
+
+static const int JSON_string_en_main = 1;
+
+#line 368 "parser.rl"
+
+
+static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+ *result = rb_str_new("", 0);
+
+#line 1170 "parser.c"
+ {
+ cs = JSON_string_start;
+ }
+#line 376 "parser.rl"
+ json->memo = p;
+
+#line 1177 "parser.c"
+ {
+ if ( p == pe )
+ goto _out;
+ switch ( cs )
+ {
+case 1:
+ if ( (*p) == 34 )
+ goto st2;
+ goto st0;
+st0:
+ goto _out0;
+st2:
+ if ( ++p == pe )
+ goto _out2;
+case 2:
+ switch( (*p) ) {
+ case 34: goto tr2;
+ case 92: goto st3;
+ }
+ if ( 0 <= (*p) && (*p) <= 31 )
+ goto st0;
+ goto st2;
+tr2:
+#line 360 "parser.rl"
+ {
+ *result = json_string_unescape(json->memo + 1, p);
+ if (NIL_P(*result)) goto _out8; else {p = (( p + 1))-1;}
+ }
+#line 365 "parser.rl"
+ { goto _out8; }
+ goto st8;
+st8:
+ if ( ++p == pe )
+ goto _out8;
+case 8:
+#line 1213 "parser.c"
+ goto st0;
+st3:
+ if ( ++p == pe )
+ goto _out3;
+case 3:
+ if ( (*p) == 117 )
+ goto st4;
+ if ( 0 <= (*p) && (*p) <= 31 )
+ goto st0;
+ goto st2;
+st4:
+ if ( ++p == pe )
+ goto _out4;
+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:
+ if ( ++p == pe )
+ goto _out5;
+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:
+ if ( ++p == pe )
+ goto _out6;
+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:
+ if ( ++p == pe )
+ goto _out7;
+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;
+ }
+ _out0: cs = 0; goto _out;
+ _out2: cs = 2; goto _out;
+ _out8: cs = 8; goto _out;
+ _out3: cs = 3; goto _out;
+ _out4: cs = 4; goto _out;
+ _out5: cs = 5; goto _out;
+ _out6: cs = 6; goto _out;
+ _out7: cs = 7; goto _out;
+
+ _out: {}
+ }
+#line 378 "parser.rl"
+
+ if (cs >= JSON_string_first_final) {
+ return p + 1;
+ } else {
+ return NULL;
+ }
+}
+
+
+
+#line 1299 "parser.c"
+static const int JSON_start = 1;
+static const int JSON_first_final = 10;
+static const int JSON_error = 0;
+
+static const int JSON_en_main = 1;
+
+#line 412 "parser.rl"
+
+
+/*
+ * 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.
+ *
+ */
+
+/*
+ * 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.
+ */
+static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
+{
+ char *ptr;
+ long len;
+ VALUE source, opts;
+ GET_STRUCT;
+ rb_scan_args(argc, argv, "11", &source, &opts);
+ source = StringValue(source);
+ ptr = RSTRING_PTR(source);
+ len = RSTRING_LEN(source);
+ if (len < 2) {
+ rb_raise(eParserError, "A JSON text must at least contain two octets!");
+ }
+ json->max_nesting = 19;
+ if (!NIL_P(opts)) {
+ 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 {
+ VALUE s_max_nesting = ID2SYM(i_max_nesting);
+ if (st_lookup(RHASH(opts)->tbl, s_max_nesting, 0)) {
+ VALUE max_nesting = rb_hash_aref(opts, s_max_nesting);
+ if (RTEST(max_nesting)) {
+ Check_Type(max_nesting, T_FIXNUM);
+ json->max_nesting = FIX2INT(max_nesting);
+ } else {
+ json->max_nesting = 0;
+ }
+ }
+ }
+ }
+ json->current_nesting = 0;
+ /*
+ Convert these?
+ if (len >= 4 && ptr[0] == 0 && ptr[1] == 0 && ptr[2] == 0) {
+ rb_raise(eParserError, "Only UTF8 octet streams are supported atm!");
+ } else if (len >= 4 && ptr[0] == 0 && ptr[2] == 0) {
+ rb_raise(eParserError, "Only UTF8 octet streams are supported atm!");
+ } else if (len >= 4 && ptr[1] == 0 && ptr[2] == 0 && ptr[3] == 0) {
+ rb_raise(eParserError, "Only UTF8 octet streams are supported atm!");
+ } else if (len >= 4 && ptr[1] == 0 && ptr[3] == 0) {
+ rb_raise(eParserError, "Only UTF8 octet streams are supported atm!");
+ }
+ */
+ json->len = len;
+ json->source = ptr;
+ json->Vsource = source;
+ json->create_id = rb_funcall(mJSON, i_create_id, 0);
+ return self;
+}
+
+/*
+ * call-seq: parse()
+ *
+ * Parses the current JSON text _source_ and returns the complete data
+ * structure as a result.
+ */
+static VALUE cParser_parse(VALUE self)
+{
+ char *p, *pe;
+ int cs = EVIL;
+ VALUE result = Qnil;
+ GET_STRUCT;
+
+
+#line 1400 "parser.c"
+ {
+ cs = JSON_start;
+ }
+#line 505 "parser.rl"
+ p = json->source;
+ pe = p + json->len;
+
+#line 1408 "parser.c"
+ {
+ if ( p == pe )
+ goto _out;
+ switch ( cs )
+ {
+st1:
+ if ( ++p == pe )
+ goto _out1;
+case 1:
+ switch( (*p) ) {
+ case 13: goto st1;
+ case 32: goto st1;
+ case 47: goto st2;
+ case 91: goto tr3;
+ case 123: goto tr4;
+ }
+ if ( 9 <= (*p) && (*p) <= 10 )
+ goto st1;
+ goto st0;
+st0:
+ goto _out0;
+st2:
+ if ( ++p == pe )
+ goto _out2;
+case 2:
+ switch( (*p) ) {
+ case 42: goto st3;
+ case 47: goto st5;
+ }
+ goto st0;
+st3:
+ if ( ++p == pe )
+ goto _out3;
+case 3:
+ if ( (*p) == 42 )
+ goto st4;
+ goto st3;
+st4:
+ if ( ++p == pe )
+ goto _out4;
+case 4:
+ switch( (*p) ) {
+ case 42: goto st4;
+ case 47: goto st1;
+ }
+ goto st3;
+st5:
+ if ( ++p == pe )
+ goto _out5;
+case 5:
+ if ( (*p) == 10 )
+ goto st1;
+ goto st5;
+tr3:
+#line 401 "parser.rl"
+ {
+ char *np;
+ json->current_nesting = 1;
+ np = JSON_parse_array(json, p, pe, &result);
+ if (np == NULL) goto _out10; else {p = (( np))-1;}
+ }
+ goto st10;
+tr4:
+#line 394 "parser.rl"
+ {
+ char *np;
+ json->current_nesting = 1;
+ np = JSON_parse_object(json, p, pe, &result);
+ if (np == NULL) goto _out10; else {p = (( np))-1;}
+ }
+ goto st10;
+st10:
+ if ( ++p == pe )
+ goto _out10;
+case 10:
+#line 1484 "parser.c"
+ switch( (*p) ) {
+ case 13: goto st10;
+ case 32: goto st10;
+ case 47: goto st6;
+ }
+ if ( 9 <= (*p) && (*p) <= 10 )
+ goto st10;
+ goto st0;
+st6:
+ if ( ++p == pe )
+ goto _out6;
+case 6:
+ switch( (*p) ) {
+ case 42: goto st7;
+ case 47: goto st9;
+ }
+ goto st0;
+st7:
+ if ( ++p == pe )
+ goto _out7;
+case 7:
+ if ( (*p) == 42 )
+ goto st8;
+ goto st7;
+st8:
+ if ( ++p == pe )
+ goto _out8;
+case 8:
+ switch( (*p) ) {
+ case 42: goto st8;
+ case 47: goto st10;
+ }
+ goto st7;
+st9:
+ if ( ++p == pe )
+ goto _out9;
+case 9:
+ if ( (*p) == 10 )
+ goto st10;
+ goto st9;
+ }
+ _out1: cs = 1; goto _out;
+ _out0: cs = 0; goto _out;
+ _out2: cs = 2; goto _out;
+ _out3: cs = 3; goto _out;
+ _out4: cs = 4; goto _out;
+ _out5: cs = 5; goto _out;
+ _out10: cs = 10; goto _out;
+ _out6: cs = 6; goto _out;
+ _out7: cs = 7; goto _out;
+ _out8: cs = 8; goto _out;
+ _out9: cs = 9; goto _out;
+
+ _out: {}
+ }
+#line 508 "parser.rl"
+
+ if (cs >= JSON_first_final && p == pe) {
+ return result;
+ } else {
+ rb_raise(eParserError, "unexpected token at '%s'", p);
+ }
+}
+
+static JSON_Parser *JSON_allocate()
+{
+ JSON_Parser *json = ALLOC(JSON_Parser);
+ MEMZERO(json, JSON_Parser, 1);
+ return json;
+}
+
+static void JSON_mark(JSON_Parser *json)
+{
+ rb_gc_mark_maybe(json->Vsource);
+ rb_gc_mark_maybe(json->create_id);
+}
+
+static void JSON_free(JSON_Parser *json)
+{
+ free(json);
+}
+
+static VALUE cJSON_parser_s_allocate(VALUE klass)
+{
+ JSON_Parser *json = JSON_allocate();
+ return Data_Wrap_Struct(klass, JSON_mark, JSON_free, json);
+}
+
+/*
+ * call-seq: source()
+ *
+ * Returns a copy of the current _source_ string, that was used to construct
+ * this Parser.
+ */
+static VALUE cParser_source(VALUE self)
+{
+ GET_STRUCT;
+ return rb_str_dup(json->Vsource);
+}
+
+void Init_parser()
+{
+ 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_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);
+
+ i_json_creatable_p = rb_intern("json_creatable?");
+ i_json_create = rb_intern("json_create");
+ i_create_id = rb_intern("create_id");
+ i_chr = rb_intern("chr");
+ i_max_nesting = rb_intern("max_nesting");
+}
diff --git a/ext/json/ext/parser/parser.rl b/ext/json/ext/parser/parser.rl
new file mode 100644
index 0000000..9ce8c6f
--- /dev/null
+++ b/ext/json/ext/parser/parser.rl
@@ -0,0 +1,569 @@
+/* vim: set cin et sw=4 ts=4: */
+
+#include "ruby.h"
+#include "re.h"
+#include "st.h"
+#include "unicode.h"
+
+#define EVIL 0x666
+
+static VALUE mJSON, mExt, cParser, eParserError, eNestingError;
+
+static ID i_json_creatable_p, i_json_create, i_create_id, i_chr, i_max_nesting;
+
+typedef struct JSON_ParserStruct {
+ VALUE Vsource;
+ char *source;
+ long len;
+ char *memo;
+ VALUE create_id;
+ int max_nesting;
+ int current_nesting;
+} JSON_Parser;
+
+static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result);
+static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result);
+
+#define GET_STRUCT \
+ JSON_Parser *json; \
+ Data_Get_Struct(self, JSON_Parser, json);
+
+%%{
+ machine JSON_common;
+
+ cr = '\n';
+ cr_neg = [^\n];
+ ws = [ \t\r\n];
+ c_comment = '/*' ( any* - (any* '*/' any* ) ) '*/';
+ cpp_comment = '//' cr_neg* cr;
+ comment = c_comment | cpp_comment;
+ ignore = ws | comment;
+ name_separator = ':';
+ value_separator = ',';
+ Vnull = 'null';
+ Vfalse = 'false';
+ Vtrue = 'true';
+ begin_value = [nft"\-[{] | digit;
+ begin_object = '{';
+ end_object = '}';
+ begin_array = '[';
+ end_array = ']';
+ begin_string = '"';
+ begin_name = begin_string;
+ begin_number = digit | '-';
+}%%
+
+%%{
+ machine JSON_object;
+ include JSON_common;
+
+ write data;
+
+ action parse_value {
+ VALUE v = Qnil;
+ char *np = JSON_parse_value(json, fpc, pe, &v);
+ if (np == NULL) {
+ fbreak;
+ } else {
+ rb_hash_aset(*result, last_name, v);
+ fexec np;
+ }
+ }
+
+ action parse_name {
+ char *np = JSON_parse_string(json, fpc, pe, &last_name);
+ if (np == NULL) fbreak; else fexec np;
+ }
+
+ action exit { fbreak; }
+
+ a_pair = ignore* begin_name >parse_name
+ ignore* name_separator ignore*
+ begin_value >parse_value;
+
+ main := begin_object
+ (a_pair (ignore* value_separator a_pair)*)?
+ ignore* end_object @exit;
+}%%
+
+static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+ VALUE last_name = Qnil;
+
+ if (json->max_nesting && json->current_nesting > json->max_nesting) {
+ rb_raise(eNestingError, "nesting of %d is to deep", json->current_nesting);
+ }
+
+ *result = rb_hash_new();
+
+ %% write init;
+ %% write exec;
+
+ if (cs >= JSON_object_first_final) {
+ VALUE klassname = rb_hash_aref(*result, json->create_id);
+ if (!NIL_P(klassname)) {
+ VALUE klass = rb_path2class(StringValueCStr(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;
+ }
+}
+
+%%{
+ machine JSON_value;
+ include JSON_common;
+
+ write data;
+
+ action parse_null {
+ *result = Qnil;
+ }
+ action parse_false {
+ *result = Qfalse;
+ }
+ action parse_true {
+ *result = Qtrue;
+ }
+ action parse_string {
+ char *np = JSON_parse_string(json, fpc, pe, result);
+ if (np == NULL) fbreak; else fexec np;
+ }
+
+ action parse_number {
+ char *np;
+ np = JSON_parse_float(json, fpc, pe, result);
+ if (np != NULL) fexec np;
+ np = JSON_parse_integer(json, fpc, pe, result);
+ if (np != NULL) fexec np;
+ fbreak;
+ }
+
+ action parse_array {
+ char *np;
+ json->current_nesting += 1;
+ np = JSON_parse_array(json, fpc, pe, result);
+ json->current_nesting -= 1;
+ if (np == NULL) fbreak; else fexec np;
+ }
+
+ action parse_object {
+ char *np;
+ json->current_nesting += 1;
+ np = JSON_parse_object(json, fpc, pe, result);
+ json->current_nesting -= 1;
+ if (np == NULL) fbreak; else fexec np;
+ }
+
+ action exit { fbreak; }
+
+main := (
+ Vnull @parse_null |
+ Vfalse @parse_false |
+ Vtrue @parse_true |
+ begin_number >parse_number |
+ begin_string >parse_string |
+ begin_array >parse_array |
+ begin_object >parse_object
+ ) %*exit;
+}%%
+
+static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+ %% write init;
+ %% write exec;
+
+ if (cs >= JSON_value_first_final) {
+ return p;
+ } else {
+ return NULL;
+ }
+}
+
+%%{
+ machine JSON_integer;
+
+ write data;
+
+ action exit { fbreak; }
+
+ main := '-'? ('0' | [1-9][0-9]*) (^[0-9] @exit);
+}%%
+
+static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+ %% write init;
+ json->memo = p;
+ %% write exec;
+
+ if (cs >= JSON_integer_first_final) {
+ long len = p - json->memo;
+ *result = rb_Integer(rb_str_new(json->memo, len));
+ return p + 1;
+ } else {
+ return NULL;
+ }
+}
+
+%%{
+ machine JSON_float;
+ include JSON_common;
+
+ write data;
+
+ action exit { fbreak; }
+
+ main := '-'? (
+ (('0' | [1-9][0-9]*) '.' [0-9]+ ([Ee] [+\-]?[0-9]+)?)
+ | (('0' | [1-9][0-9]*) ([Ee] [+\-]?[0-9]+))
+ ) (^[0-9Ee.\-] @exit );
+}%%
+
+static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+ %% write init;
+ json->memo = p;
+ %% write exec;
+
+ if (cs >= JSON_float_first_final) {
+ long len = p - json->memo;
+ *result = rb_Float(rb_str_new(json->memo, len));
+ return p + 1;
+ } else {
+ return NULL;
+ }
+}
+
+
+%%{
+ machine JSON_array;
+ include JSON_common;
+
+ write data;
+
+ action parse_value {
+ VALUE v = Qnil;
+ char *np = JSON_parse_value(json, fpc, pe, &v);
+ if (np == NULL) {
+ fbreak;
+ } else {
+ rb_ary_push(*result, v);
+ fexec np;
+ }
+ }
+
+ action exit { fbreak; }
+
+ next_element = value_separator ignore* begin_value >parse_value;
+
+ main := begin_array ignore*
+ ((begin_value >parse_value ignore*)
+ (ignore* next_element ignore*)*)?
+ end_array @exit;
+}%%
+
+static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+ if (json->max_nesting && json->current_nesting > json->max_nesting) {
+ rb_raise(eNestingError, "nesting of %d is to deep", json->current_nesting);
+ }
+ *result = rb_ary_new();
+
+ %% write init;
+ %% write exec;
+
+ if(cs >= JSON_array_first_final) {
+ return p + 1;
+ } else {
+ rb_raise(eParserError, "unexpected token at '%s'", p);
+ }
+}
+
+static VALUE json_string_unescape(char *p, char *pe)
+{
+ VALUE result = rb_str_buf_new(pe - p + 1);
+
+ while (p < pe) {
+ if (*p == '\\') {
+ p++;
+ if (p >= pe) return Qnil; /* raise an exception later, \ at end */
+ switch (*p) {
+ case '"':
+ case '\\':
+ rb_str_buf_cat(result, p, 1);
+ p++;
+ break;
+ case 'b':
+ rb_str_buf_cat2(result, "\b");
+ p++;
+ break;
+ case 'f':
+ rb_str_buf_cat2(result, "\f");
+ p++;
+ break;
+ case 'n':
+ rb_str_buf_cat2(result, "\n");
+ p++;
+ break;
+ case 'r':
+ rb_str_buf_cat2(result, "\r");
+ p++;
+ break;
+ case 't':
+ rb_str_buf_cat2(result, "\t");
+ p++;
+ break;
+ case 'u':
+ if (p > pe - 4) {
+ return Qnil;
+ } else {
+ p = JSON_convert_UTF16_to_UTF8(result, p, pe, strictConversion);
+ }
+ break;
+ default:
+ rb_str_buf_cat(result, p, 1);
+ p++;
+ break;
+ }
+ } else {
+ char *q = p;
+ while (*q != '\\' && q < pe) q++;
+ rb_str_buf_cat(result, p, q - p);
+ p = q;
+ }
+ }
+ return result;
+}
+
+%%{
+ machine JSON_string;
+ include JSON_common;
+
+ write data;
+
+ action parse_string {
+ *result = json_string_unescape(json->memo + 1, p);
+ if (NIL_P(*result)) fbreak; else fexec p + 1;
+ }
+
+ action exit { fbreak; }
+
+ main := '"' ((^(["\\] | 0..0x1f) | '\\'["\\/bfnrt] | '\\u'[0-9a-fA-F]{4} | '\\'^(["\\/bfnrtu]|0..0x1f))* %parse_string) '"' @exit;
+}%%
+
+static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result)
+{
+ int cs = EVIL;
+
+ *result = rb_str_new("", 0);
+ %% write init;
+ json->memo = p;
+ %% write exec;
+
+ if (cs >= JSON_string_first_final) {
+ return p + 1;
+ } else {
+ return NULL;
+ }
+}
+
+
+%%{
+ machine JSON;
+
+ write data;
+
+ include JSON_common;
+
+ action parse_object {
+ char *np;
+ json->current_nesting = 1;
+ np = JSON_parse_object(json, fpc, pe, &result);
+ if (np == NULL) fbreak; else fexec np;
+ }
+
+ action parse_array {
+ char *np;
+ json->current_nesting = 1;
+ np = JSON_parse_array(json, fpc, pe, &result);
+ if (np == NULL) fbreak; else fexec np;
+ }
+
+ main := ignore* (
+ begin_object >parse_object |
+ begin_array >parse_array
+ ) ignore*;
+}%%
+
+/*
+ * 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.
+ *
+ */
+
+/*
+ * 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.
+ */
+static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
+{
+ char *ptr;
+ long len;
+ VALUE source, opts;
+ GET_STRUCT;
+ rb_scan_args(argc, argv, "11", &source, &opts);
+ source = StringValue(source);
+ ptr = RSTRING_PTR(source);
+ len = RSTRING_LEN(source);
+ if (len < 2) {
+ rb_raise(eParserError, "A JSON text must at least contain two octets!");
+ }
+ json->max_nesting = 19;
+ if (!NIL_P(opts)) {
+ 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 {
+ VALUE s_max_nesting = ID2SYM(i_max_nesting);
+ if (st_lookup(RHASH(opts)->tbl, s_max_nesting, 0)) {
+ VALUE max_nesting = rb_hash_aref(opts, s_max_nesting);
+ if (RTEST(max_nesting)) {
+ Check_Type(max_nesting, T_FIXNUM);
+ json->max_nesting = FIX2INT(max_nesting);
+ } else {
+ json->max_nesting = 0;
+ }
+ }
+ }
+ }
+ json->current_nesting = 0;
+ /*
+ Convert these?
+ if (len >= 4 && ptr[0] == 0 && ptr[1] == 0 && ptr[2] == 0) {
+ rb_raise(eParserError, "Only UTF8 octet streams are supported atm!");
+ } else if (len >= 4 && ptr[0] == 0 && ptr[2] == 0) {
+ rb_raise(eParserError, "Only UTF8 octet streams are supported atm!");
+ } else if (len >= 4 && ptr[1] == 0 && ptr[2] == 0 && ptr[3] == 0) {
+ rb_raise(eParserError, "Only UTF8 octet streams are supported atm!");
+ } else if (len >= 4 && ptr[1] == 0 && ptr[3] == 0) {
+ rb_raise(eParserError, "Only UTF8 octet streams are supported atm!");
+ }
+ */
+ json->len = len;
+ json->source = ptr;
+ json->Vsource = source;
+ json->create_id = rb_funcall(mJSON, i_create_id, 0);
+ return self;
+}
+
+/*
+ * call-seq: parse()
+ *
+ * Parses the current JSON text _source_ and returns the complete data
+ * structure as a result.
+ */
+static VALUE cParser_parse(VALUE self)
+{
+ char *p, *pe;
+ int cs = EVIL;
+ VALUE result = Qnil;
+ GET_STRUCT;
+
+ %% write init;
+ p = json->source;
+ pe = p + json->len;
+ %% write exec;
+
+ if (cs >= JSON_first_final && p == pe) {
+ return result;
+ } else {
+ rb_raise(eParserError, "unexpected token at '%s'", p);
+ }
+}
+
+static JSON_Parser *JSON_allocate()
+{
+ JSON_Parser *json = ALLOC(JSON_Parser);
+ MEMZERO(json, JSON_Parser, 1);
+ return json;
+}
+
+static void JSON_mark(JSON_Parser *json)
+{
+ rb_gc_mark_maybe(json->Vsource);
+ rb_gc_mark_maybe(json->create_id);
+}
+
+static void JSON_free(JSON_Parser *json)
+{
+ free(json);
+}
+
+static VALUE cJSON_parser_s_allocate(VALUE klass)
+{
+ JSON_Parser *json = JSON_allocate();
+ return Data_Wrap_Struct(klass, JSON_mark, JSON_free, json);
+}
+
+/*
+ * call-seq: source()
+ *
+ * Returns a copy of the current _source_ string, that was used to construct
+ * this Parser.
+ */
+static VALUE cParser_source(VALUE self)
+{
+ GET_STRUCT;
+ return rb_str_dup(json->Vsource);
+}
+
+void Init_parser()
+{
+ 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_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);
+
+ i_json_creatable_p = rb_intern("json_creatable?");
+ i_json_create = rb_intern("json_create");
+ i_create_id = rb_intern("create_id");
+ i_chr = rb_intern("chr");
+ i_max_nesting = rb_intern("max_nesting");
+}
diff --git a/ext/json/ext/parser/unicode.c b/ext/json/ext/parser/unicode.c
new file mode 100644
index 0000000..609a0e8
--- /dev/null
+++ b/ext/json/ext/parser/unicode.c
@@ -0,0 +1,156 @@
+/* vim: set cin et sw=4 ts=4: */
+
+#include "unicode.h"
+
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ *
+ * Disclaimer
+ *
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ *
+ * Limitations on Rights to Redistribute This Code
+ *
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/*
+ * Index into the table below with the first byte of a UTF-8 sequence to
+ * get the number of trailing bytes that are supposed to follow it.
+ * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
+ * left as-is for anyone who may want to do such conversion, which was
+ * allowed in earlier algorithms.
+ */
+static const char trailingBytesForUTF8[256] = {
+ 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,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,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,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+ 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+/*
+ * Magic values subtracted from a buffer value during UTF8 conversion.
+ * This table contains as many values as there might be trailing bytes
+ * in a UTF-8 sequence.
+ */
+static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
+ 0x03C82080UL, 0xFA082080UL, 0x82082080UL };
+
+/*
+ * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
+ * into the first byte, depending on how many bytes follow. There are
+ * as many entries in this table as there are UTF-8 sequence types.
+ * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
+ * for *legal* UTF-8 will be 4 or fewer bytes total.
+ */
+static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+char *JSON_convert_UTF16_to_UTF8 (
+ VALUE buffer,
+ char *source,
+ char *sourceEnd,
+ ConversionFlags flags)
+{
+ UTF16 *tmp, *tmpPtr, *tmpEnd;
+ char buf[5];
+ long n = 0, i;
+ char *p = source - 1;
+
+ while (p < sourceEnd && p[0] == '\\' && p[1] == 'u') {
+ p += 6;
+ n++;
+ }
+ p = source + 1;
+ buf[4] = 0;
+ tmpPtr = tmp = ALLOC_N(UTF16, n);
+ tmpEnd = tmp + n;
+ for (i = 0; i < n; i++) {
+ buf[0] = *p++;
+ buf[1] = *p++;
+ buf[2] = *p++;
+ buf[3] = *p++;
+ tmpPtr[i] = strtol(buf, NULL, 16);
+ p += 2;
+ }
+
+ while (tmpPtr < tmpEnd) {
+ UTF32 ch;
+ unsigned short bytesToWrite = 0;
+ const UTF32 byteMask = 0xBF;
+ const UTF32 byteMark = 0x80;
+ ch = *tmpPtr++;
+ /* If we have a surrogate pair, convert to UTF32 first. */
+ if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
+ /* If the 16 bits following the high surrogate are in the source
+ * buffer... */
+ if (tmpPtr < tmpEnd) {
+ UTF32 ch2 = *tmpPtr;
+ /* If it's a low surrogate, convert to UTF32. */
+ if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
+ ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
+ + (ch2 - UNI_SUR_LOW_START) + halfBase;
+ ++tmpPtr;
+ } else if (flags == strictConversion) { /* it's an unpaired high surrogate */
+ free(tmp);
+ rb_raise(rb_path2class("JSON::ParserError"),
+ "source sequence is illegal/malformed near %s", source);
+ }
+ } else { /* We don't have the 16 bits following the high surrogate. */
+ free(tmp);
+ rb_raise(rb_path2class("JSON::ParserError"),
+ "partial character in source, but hit end near %s", source);
+ break;
+ }
+ } else if (flags == strictConversion) {
+ /* UTF-16 surrogate values are illegal in UTF-32 */
+ if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
+ free(tmp);
+ rb_raise(rb_path2class("JSON::ParserError"),
+ "source sequence is illegal/malformed near %s", source);
+ }
+ }
+ /* Figure out how many bytes the result will require */
+ if (ch < (UTF32) 0x80) {
+ bytesToWrite = 1;
+ } else if (ch < (UTF32) 0x800) {
+ bytesToWrite = 2;
+ } else if (ch < (UTF32) 0x10000) {
+ bytesToWrite = 3;
+ } else if (ch < (UTF32) 0x110000) {
+ bytesToWrite = 4;
+ } else {
+ bytesToWrite = 3;
+ ch = UNI_REPLACEMENT_CHAR;
+ }
+
+ buf[0] = 0;
+ buf[1] = 0;
+ buf[2] = 0;
+ buf[3] = 0;
+ p = buf + bytesToWrite;
+ switch (bytesToWrite) { /* note: everything falls through. */
+ case 4: *--p = (UTF8) ((ch | byteMark) & byteMask); ch >>= 6;
+ case 3: *--p = (UTF8) ((ch | byteMark) & byteMask); ch >>= 6;
+ case 2: *--p = (UTF8) ((ch | byteMark) & byteMask); ch >>= 6;
+ case 1: *--p = (UTF8) (ch | firstByteMark[bytesToWrite]);
+ }
+ rb_str_buf_cat(buffer, p, bytesToWrite);
+ }
+ free(tmp);
+ source += 5 + (n - 1) * 6;
+ return source;
+}
diff --git a/ext/json/ext/parser/unicode.h b/ext/json/ext/parser/unicode.h
new file mode 100755
index 0000000..155da0c
--- /dev/null
+++ b/ext/json/ext/parser/unicode.h
@@ -0,0 +1,58 @@
+
+#ifndef _PARSER_UNICODE_H_
+#define _PARSER_UNICODE_H_
+
+#include "ruby.h"
+
+typedef unsigned long UTF32; /* at least 32 bits */
+typedef unsigned short UTF16; /* at least 16 bits */
+typedef unsigned char UTF8; /* typically 8 bits */
+
+#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
+#define UNI_MAX_BMP (UTF32)0x0000FFFF
+#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
+#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
+#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
+
+#define UNI_SUR_HIGH_START (UTF32)0xD800
+#define UNI_SUR_HIGH_END (UTF32)0xDBFF
+#define UNI_SUR_LOW_START (UTF32)0xDC00
+#define UNI_SUR_LOW_END (UTF32)0xDFFF
+
+static const int halfShift = 10; /* used for shifting by 10 bits */
+
+static const UTF32 halfBase = 0x0010000UL;
+static const UTF32 halfMask = 0x3FFUL;
+
+typedef enum {
+ conversionOK = 0, /* conversion successful */
+ sourceExhausted, /* partial character in source, but hit end */
+ targetExhausted, /* insuff. room in target for conversion */
+ sourceIllegal /* source sequence is illegal/malformed */
+} ConversionResult;
+
+typedef enum {
+ strictConversion = 0,
+ lenientConversion
+} ConversionFlags;
+
+char *JSON_convert_UTF16_to_UTF8 (
+ VALUE buffer,
+ char *source,
+ char *sourceEnd,
+ ConversionFlags flags);
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(ARRAY) RARRAY(ARRAY)->ptr
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(ARRAY) RARRAY(ARRAY)->len
+#endif
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(string) RSTRING(string)->ptr
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(string) RSTRING(string)->len
+#endif
+
+#endif
diff --git a/ext/nkf/nkf-utf8/nkf.c b/ext/nkf/nkf-utf8/nkf.c
index 3cd1b16..30bb6c4 100644
--- a/ext/nkf/nkf-utf8/nkf.c
+++ b/ext/nkf/nkf-utf8/nkf.c
@@ -41,7 +41,7 @@
***********************************************************************/
/* $Id$ */
#define NKF_VERSION "2.0.8"
-#define NKF_RELEASE_DATE "2007-01-28"
+#define NKF_RELEASE_DATE "2007-05-28"
#include "config.h"
#include "utf8tbl.h"
@@ -351,10 +351,12 @@ static nkf_char e_iconv(nkf_char c2,nkf_char c1,nkf_char c0);
* 0: Shift_JIS, eucJP-ascii
* 1: eucJP-ms
* 2: CP932, CP51932
+ * 3: CP10001
*/
-#define UCS_MAP_ASCII 0
-#define UCS_MAP_MS 1
-#define UCS_MAP_CP932 2
+#define UCS_MAP_ASCII 0
+#define UCS_MAP_MS 1
+#define UCS_MAP_CP932 2
+#define UCS_MAP_CP10001 3
static int ms_ucs_map_f = UCS_MAP_ASCII;
#endif
#ifdef UTF8_INPUT_ENABLE
@@ -1233,6 +1235,14 @@ void options(unsigned char *cp)
#ifdef UTF8_OUTPUT_ENABLE
ms_ucs_map_f = UCS_MAP_CP932;
#endif
+ }else if(strcmp(codeset, "CP10001") == 0){
+ input_f = SJIS_INPUT;
+#ifdef SHIFTJIS_CP932
+ cp51932_f = TRUE;
+#endif
+#ifdef UTF8_OUTPUT_ENABLE
+ ms_ucs_map_f = UCS_MAP_CP10001;
+#endif
}else if(strcmp(codeset, "EUCJP") == 0 ||
strcmp(codeset, "EUC-JP") == 0){
input_f = EUC_INPUT;
@@ -1371,6 +1381,11 @@ void options(unsigned char *cp)
#ifdef UTF8_OUTPUT_ENABLE
ms_ucs_map_f = UCS_MAP_CP932;
#endif
+ }else if(strcmp(codeset, "CP10001") == 0){
+ output_conv = s_oconv;
+#ifdef UTF8_OUTPUT_ENABLE
+ ms_ucs_map_f = UCS_MAP_CP10001;
+#endif
}else if(strcmp(codeset, "EUCJP") == 0 ||
strcmp(codeset, "EUC-JP") == 0){
output_conv = e_oconv;
@@ -2676,6 +2691,12 @@ nkf_char kanji_convert(FILE *f)
} else { /* bogus code, skip SSO and one byte */
NEXT;
}
+ } else if (ms_ucs_map_f == UCS_MAP_CP10001 &&
+ (c1 == 0xFD || c1 == 0xFE)) {
+ /* CP10001 */
+ c2 = X0201;
+ c1 &= 0x7f;
+ SEND;
} else {
/* already established */
c2 = c1;
@@ -2885,35 +2906,41 @@ nkf_char kanji_convert(FILE *f)
(*oconv)(0, ESC);
SEND;
}
- } else if ((c1 == NL || c1 == CR) && broken_f&4) {
- input_mode = ASCII; set_iconv(FALSE, 0);
- SEND;
- } else if (c1 == NL && mime_decode_f && !mime_decode_mode ) {
- if ((c1=(*i_getc)(f))!=EOF && c1 == SPACE) {
- i_ungetc(SPACE,f);
- continue;
- } else {
- i_ungetc(c1,f);
- }
- c1 = NL;
- SEND;
- } else if (c1 == CR && mime_decode_f && !mime_decode_mode ) {
- if ((c1=(*i_getc)(f))!=EOF) {
- if (c1==SPACE) {
- i_ungetc(SPACE,f);
- continue;
- } else if (c1 == NL && (c1=(*i_getc)(f))!=EOF && c1 == SPACE) {
- i_ungetc(SPACE,f);
- continue;
- } else {
- i_ungetc(c1,f);
+ } else if (c1 == NL || c1 == CR) {
+ if (broken_f&4) {
+ input_mode = ASCII; set_iconv(FALSE, 0);
+ SEND;
+ } else if (mime_decode_f && !mime_decode_mode){
+ if (c1 == NL) {
+ if ((c1=(*i_getc)(f))!=EOF && c1 == SPACE) {
+ i_ungetc(SPACE,f);
+ continue;
+ } else {
+ i_ungetc(c1,f);
+ }
+ c1 = NL;
+ SEND;
+ } else { /* if (c1 == CR)*/
+ if ((c1=(*i_getc)(f))!=EOF) {
+ if (c1==SPACE) {
+ i_ungetc(SPACE,f);
+ continue;
+ } else if (c1 == NL && (c1=(*i_getc)(f))!=EOF && c1 == SPACE) {
+ i_ungetc(SPACE,f);
+ continue;
+ } else {
+ i_ungetc(c1,f);
+ }
+ i_ungetc(NL,f);
+ } else {
+ i_ungetc(c1,f);
+ }
+ c1 = CR;
+ SEND;
}
- i_ungetc(NL,f);
- } else {
- i_ungetc(c1,f);
}
- c1 = CR;
- SEND;
+ if (crmode_f == CR && c1 == NL) crmode_f = CRLF;
+ else crmode_f = c1;
} else if (c1 == DEL && input_mode == X0208 ) {
/* CP5022x */
c2 = c1;
@@ -3125,9 +3152,6 @@ nkf_char s2e_conv(nkf_char c2, nkf_char c1, nkf_char *p2, nkf_char *p1)
static const nkf_char shift_jisx0213_s1a3_table[5][2] ={ { 1, 8}, { 3, 4}, { 5,12}, {13,14}, {15, 0} };
#ifdef SHIFTJIS_CP932
if (!cp932inv_f && is_ibmext_in_sjis(c2)){
-#if 0
- extern const unsigned short shiftjis_cp932[3][189];
-#endif
val = shiftjis_cp932[c2 - CP932_TABLE_BEGIN][c1 - 0x40];
if (val){
c2 = val >> 8;
@@ -3136,9 +3160,6 @@ nkf_char s2e_conv(nkf_char c2, nkf_char c1, nkf_char *p2, nkf_char *p1)
}
if (cp932inv_f
&& CP932INV_TABLE_BEGIN <= c2 && c2 <= CP932INV_TABLE_END){
-#if 0
- extern const unsigned short cp932inv[2][189];
-#endif
nkf_char c = cp932inv[c2 - CP932INV_TABLE_BEGIN][c1 - 0x40];
if (c){
c2 = c >> 8;
@@ -3148,9 +3169,6 @@ nkf_char s2e_conv(nkf_char c2, nkf_char c1, nkf_char *p2, nkf_char *p1)
#endif /* SHIFTJIS_CP932 */
#ifdef X0212_ENABLE
if (!x0213_f && is_ibmext_in_sjis(c2)){
-#if 0
- extern const unsigned short shiftjis_x0212[3][189];
-#endif
val = shiftjis_x0212[c2 - 0xfa][c1 - 0x40];
if (val){
if (val > 0x7FFF){
@@ -3481,14 +3499,6 @@ nkf_char w_iconv32(nkf_char c2, nkf_char c1, nkf_char c0)
nkf_char unicode_to_jis_common(nkf_char c2, nkf_char c1, nkf_char c0, nkf_char *p2, nkf_char *p1)
{
-#if 0
- extern const unsigned short *const utf8_to_euc_2bytes[];
- extern const unsigned short *const utf8_to_euc_2bytes_ms[];
- extern const unsigned short *const utf8_to_euc_2bytes_932[];
- extern const unsigned short *const *const utf8_to_euc_3bytes[];
- extern const unsigned short *const *const utf8_to_euc_3bytes_ms[];
- extern const unsigned short *const *const utf8_to_euc_3bytes_932[];
-#endif
const unsigned short *const *pp;
const unsigned short *const *const *ppp;
static const int no_best_fit_chars_table_C2[] =
@@ -3538,11 +3548,27 @@ nkf_char unicode_to_jis_common(nkf_char c2, nkf_char c1, nkf_char c0, nkf_char *
}
}else if(ms_ucs_map_f == UCS_MAP_MS){
if(c2 == 0xC2 && no_best_fit_chars_table_C2_ms[c1&0x3F]) return 1;
+ }else if(ms_ucs_map_f == UCS_MAP_CP10001){
+ switch(c2){
+ case 0xC2:
+ switch(c1){
+ case 0xA2:
+ case 0xA3:
+ case 0xA5:
+ case 0xA6:
+ case 0xAC:
+ case 0xAF:
+ case 0xB8:
+ return 1;
+ }
+ break;
+ }
}
}
pp =
ms_ucs_map_f == UCS_MAP_CP932 ? utf8_to_euc_2bytes_932 :
ms_ucs_map_f == UCS_MAP_MS ? utf8_to_euc_2bytes_ms :
+ ms_ucs_map_f == UCS_MAP_CP10001 ? utf8_to_euc_2bytes_mac :
utf8_to_euc_2bytes;
ret = w_iconv_common(c2, c1, pp, sizeof_utf8_to_euc_2bytes, p2, p1);
}else if(c0 < 0xF0){
@@ -3565,6 +3591,19 @@ nkf_char unicode_to_jis_common(nkf_char c2, nkf_char c1, nkf_char c0, nkf_char *
if(c1 == 0x80 || c0 == 0x9C) return 1;
break;
}
+ }else if(ms_ucs_map_f == UCS_MAP_CP10001){
+ switch(c2){
+ case 0xE3:
+ switch(c1){
+ case 0x82:
+ if(c0 == 0x94) return 1;
+ break;
+ case 0x83:
+ if(c0 == 0xBB) return 1;
+ break;
+ }
+ break;
+ }
}else{
switch(c2){
case 0xE2:
@@ -3596,8 +3635,10 @@ nkf_char unicode_to_jis_common(nkf_char c2, nkf_char c1, nkf_char c0, nkf_char *
ppp =
ms_ucs_map_f == UCS_MAP_CP932 ? utf8_to_euc_3bytes_932 :
ms_ucs_map_f == UCS_MAP_MS ? utf8_to_euc_3bytes_ms :
+ ms_ucs_map_f == UCS_MAP_CP10001 ? utf8_to_euc_3bytes_mac :
utf8_to_euc_3bytes;
ret = w_iconv_common(c1, c0, ppp[c2 - 0xE0], sizeof_utf8_to_euc_C2, p2, p1);
+// fprintf(stderr, "wret: %X %X %X -> %X %X\n",c2,c1,c0,*p2,*p1,ret);
}else return -1;
#ifdef SHIFTJIS_CP932
if (!ret && !cp932inv_f && is_eucg3(*p2)) {
@@ -3739,15 +3780,17 @@ void encode_fallback_subchar(nkf_char c)
#ifdef UTF8_OUTPUT_ENABLE
nkf_char e2w_conv(nkf_char c2, nkf_char c1)
{
-#if 0
- extern const unsigned short euc_to_utf8_1byte[];
- extern const unsigned short *const euc_to_utf8_2bytes[];
- extern const unsigned short *const euc_to_utf8_2bytes_ms[];
- extern const unsigned short *const x0212_to_utf8_2bytes[];
-#endif
const unsigned short *p;
if (c2 == X0201) {
+ if (ms_ucs_map_f == UCS_MAP_CP10001) {
+ switch (c1) {
+ case 0x20:
+ return 0xA0;
+ case 0x7D:
+ return 0xA9;
+ }
+ }
p = euc_to_utf8_1byte;
#ifdef X0212_ENABLE
} else if (is_eucg3(c2)){
@@ -3764,7 +3807,10 @@ nkf_char e2w_conv(nkf_char c2, nkf_char c1)
c2 &= 0x7f;
c2 = (c2&0x7f) - 0x21;
if (0<=c2 && c2<sizeof_euc_to_utf8_2bytes)
- p = ms_ucs_map_f != UCS_MAP_ASCII ? euc_to_utf8_2bytes_ms[c2] : euc_to_utf8_2bytes[c2];
+ p =
+ ms_ucs_map_f == UCS_MAP_ASCII ? euc_to_utf8_2bytes[c2] :
+ ms_ucs_map_f == UCS_MAP_CP10001 ? euc_to_utf8_2bytes_mac[c2] :
+ euc_to_utf8_2bytes_ms[c2];
else
return 0;
}
@@ -4069,9 +4115,6 @@ nkf_char e2s_conv(nkf_char c2, nkf_char c1, nkf_char *p2, nkf_char *p1)
else if(nkf_isgraph(ndx)){
nkf_char val = 0;
const unsigned short *ptr;
-#if 0
- extern const unsigned short *const x0212_shiftjis[];
-#endif
ptr = x0212_shiftjis[ndx - 0x21];
if (ptr){
val = ptr[(c1 & 0x7f) - 0x21];
@@ -4147,9 +4190,6 @@ void s_oconv(nkf_char c2, nkf_char c1)
#ifdef SHIFTJIS_CP932
if (cp932inv_f
&& CP932INV_TABLE_BEGIN <= c2 && c2 <= CP932INV_TABLE_END){
-#if 0
- extern const unsigned short cp932inv[2][189];
-#endif
nkf_char c = cp932inv[c2 - CP932INV_TABLE_BEGIN][c1 - 0x40];
if (c){
c2 = c >> 8;
@@ -4539,6 +4579,10 @@ void z_conv(nkf_char c2, nkf_char c1)
/* if (c2) c1 &= 0x7f; assertion */
+ if (c2 == X0201 && (c1 == 0x20 || c1 == 0x7D || c1 == 0x7E)) {
+ (*o_zconv)(c2,c1);
+ return;
+ }
if (x0201_f && z_prev2==X0201) { /* X0201 */
if (c1==(0xde&0x7f)) { /* 濁点 */
z_prev2=0;
@@ -4942,15 +4986,20 @@ void set_input_codename(char *codename)
void print_guessed_code(char *filename)
{
char *codename = "BINARY";
+ char *str_crmode = NULL;
if (!is_inputcode_mixed) {
if (strcmp(input_codename, "") == 0) {
codename = "ASCII";
} else {
codename = input_codename;
}
+ if (crmode_f == CR) str_crmode = "CR";
+ else if (crmode_f == NL) str_crmode = "LF";
+ else if (crmode_f == CRLF) str_crmode = "CRLF";
}
if (filename != NULL) printf("%s:", filename);
- printf("%s\n", codename);
+ if (str_crmode != NULL) printf("%s (%s)\n", codename, str_crmode);
+ else printf("%s\n", codename);
}
#endif /*WIN32DLL*/
@@ -5068,9 +5117,6 @@ nkf_char nfc_getc(FILE *f)
int i=0, j, k=1, lower, upper;
nkf_char buf[9];
const nkf_nfchar *array;
-#if 0
- extern const struct normalization_pair normalization_table[];
-#endif
buf[i] = (*g)(f);
while (k > 0 && ((buf[i] & 0xc0) != 0x80)){
@@ -5437,7 +5483,7 @@ void open_mime(nkf_char mode)
int i;
int j;
p = mime_pattern[0];
- for(i=0;mime_encode[i];i++) {
+ for(i=0;mime_pattern[i];i++) {
if (mode == mime_encode[i]) {
p = mime_pattern[i];
break;
@@ -5643,10 +5689,21 @@ void mime_putc(nkf_char c)
if (mimeout_mode=='Q') {
if (c <= DEL && (output_mode==ASCII ||output_mode == ISO8859_1 ) ) {
- if (c <= SPACE) {
+ if (c == CR || c == NL) {
+ close_mime();
+ (*o_mputc)(c);
+ base64_count = 0;
+ return;
+ } else if (c <= SPACE) {
close_mime();
- (*o_mputc)(SPACE);
- base64_count++;
+ if (base64_count > 70) {
+ (*o_mputc)(NL);
+ base64_count = 0;
+ }
+ if (!nkf_isblank(c)) {
+ (*o_mputc)(SPACE);
+ base64_count++;
+ }
}
(*o_mputc)(c);
base64_count++;
@@ -5678,7 +5735,8 @@ void mime_putc(nkf_char c)
mimeout_buf_count = 1;
}else{
if (base64_count > 1
- && base64_count + mimeout_buf_count > 76){
+ && base64_count + mimeout_buf_count > 76
+ && mimeout_buf[0] != CR && mimeout_buf[0] != NL){
(*o_mputc)(NL);
base64_count = 0;
if (!nkf_isspace(mimeout_buf[0])){
diff --git a/ext/nkf/nkf-utf8/utf8tbl.c b/ext/nkf/nkf-utf8/utf8tbl.c
index e43ad55..fb6c3b7 100644
--- a/ext/nkf/nkf-utf8/utf8tbl.c
+++ b/ext/nkf/nkf-utf8/utf8tbl.c
@@ -201,6 +201,20 @@ const unsigned short euc_to_utf8_AC[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
};
+const unsigned short euc_to_utf8_AC_mac[] = {
+ 0x2664, 0x2667, 0x2661, 0x2662, 0x2660, 0x2663, 0x2665,
+ 0x2666, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0x3020, 0x260E, 0x3004,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0x261E, 0x261C, 0x261D, 0x261F, 0x21C6, 0x21C4, 0x21C5,
+ 0, 0x21E8, 0x21E6, 0x21E7, 0x21E9, 0x2192, 0x2190, 0x2191,
+ 0x2193, 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,
+};
const unsigned short euc_to_utf8_AD[] = {
0x2460, 0x2461, 0x2462, 0x2463, 0x2464, 0x2465, 0x2466,
0x2467, 0x2468, 0x2469, 0x246A, 0x246B, 0x246C, 0x246D, 0x246E,
@@ -215,6 +229,20 @@ const unsigned short euc_to_utf8_AD[] = {
0x2252, 0x2261, 0x222B, 0x222E, 0x2211, 0x221A, 0x22A5, 0x2220,
0x221F, 0x22BF, 0x2235, 0x2229, 0x222A, 0, 0x3299,
};
+const unsigned short euc_to_utf8_AD_mac[] = {
+ 0x65E5, 0x6708, 0x706B, 0x6C34, 0x6728, 0x91D1, 0x571F,
+ 0x796D, 0x795D, 0x81EA, 0x81F3, 0x3239, 0x547C, 0x3231, 0x8CC7,
+ 0x540D, 0x3232, 0x5B66, 0x8CA1, 0x793E, 0x7279, 0x76E3, 0x4F01,
+ 0x5354, 0x52B4, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0,
+ 0x3349, 0x3314, 0x3322, 0x334D, 0x3318, 0x3327, 0x3303, 0x3336,
+ 0x3351, 0x3357, 0x330D, 0x3326, 0x3323, 0x332B, 0x334A, 0x333B,
+ 0x339C, 0x339D, 0x339E, 0x338E, 0x338F, 0x33C4, 0x33A1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0x337B,
+ 0x301D, 0x301F, 0x2116, 0x33CD, 0x2121, 0x32A4, 0x32A5, 0x32A6,
+ 0x32A7, 0x32A8, 0x3231, 0x3232, 0x3239, 0x337E, 0x337D, 0x337C,
+ 0x2252, 0x5927, 0x5C0F, 0x32A4, 0x32A5, 0x32A6, 0x32A7, 0x32A8,
+ 0x533B, 0x8CA1, 0x512A, 0x52B4, 0x5370, 0x63A7, 0x79D8,
+};
const unsigned short euc_to_utf8_AE[] = {
0x3349, 0x3322, 0x334D, 0x3314, 0x3316, 0x3305, 0x3333,
0x334E, 0x3303, 0x3336, 0x3318, 0x3315, 0x3327, 0x3351, 0x334A,
@@ -2346,6 +2374,33 @@ const unsigned short *const euc_to_utf8_2bytes_ms[] = {
0, euc_to_utf8_F9, euc_to_utf8_FA, euc_to_utf8_FB,
euc_to_utf8_FC_ms, 0, 0,
};
+/* CP10001 */
+const unsigned short *const euc_to_utf8_2bytes_mac[] = {
+ euc_to_utf8_A1_ms, euc_to_utf8_A2_ms, euc_to_utf8_A3,
+ euc_to_utf8_A4, euc_to_utf8_A5, euc_to_utf8_A6, euc_to_utf8_A7,
+ euc_to_utf8_A8, euc_to_utf8_A9, euc_to_utf8_AA, euc_to_utf8_AB,
+ euc_to_utf8_AC_mac, euc_to_utf8_AD_mac, euc_to_utf8_AE, euc_to_utf8_AF,
+ euc_to_utf8_B0, euc_to_utf8_B1, euc_to_utf8_B2, euc_to_utf8_B3,
+ euc_to_utf8_B4, euc_to_utf8_B5, euc_to_utf8_B6, euc_to_utf8_B7,
+ euc_to_utf8_B8, euc_to_utf8_B9, euc_to_utf8_BA, euc_to_utf8_BB,
+ euc_to_utf8_BC, euc_to_utf8_BD, euc_to_utf8_BE, euc_to_utf8_BF,
+ euc_to_utf8_C0, euc_to_utf8_C1, euc_to_utf8_C2, euc_to_utf8_C3,
+ euc_to_utf8_C4, euc_to_utf8_C5, euc_to_utf8_C6, euc_to_utf8_C7,
+ euc_to_utf8_C8, euc_to_utf8_C9, euc_to_utf8_CA, euc_to_utf8_CB,
+ euc_to_utf8_CC, euc_to_utf8_CD, euc_to_utf8_CE, euc_to_utf8_CF,
+ euc_to_utf8_D0, euc_to_utf8_D1, euc_to_utf8_D2, euc_to_utf8_D3,
+ euc_to_utf8_D4, euc_to_utf8_D5, euc_to_utf8_D6, euc_to_utf8_D7,
+ euc_to_utf8_D8, euc_to_utf8_D9, euc_to_utf8_DA, euc_to_utf8_DB,
+ euc_to_utf8_DC, euc_to_utf8_DD, euc_to_utf8_DE, euc_to_utf8_DF,
+ euc_to_utf8_E0, euc_to_utf8_E1, euc_to_utf8_E2, euc_to_utf8_E3,
+ euc_to_utf8_E4, euc_to_utf8_E5, euc_to_utf8_E6, euc_to_utf8_E7,
+ euc_to_utf8_E8, euc_to_utf8_E9, euc_to_utf8_EA, euc_to_utf8_EB,
+ euc_to_utf8_EC, euc_to_utf8_ED, euc_to_utf8_EE, euc_to_utf8_EF,
+ euc_to_utf8_F0, euc_to_utf8_F1, euc_to_utf8_F2, euc_to_utf8_F3,
+ euc_to_utf8_F4, euc_to_utf8_F5, 0, 0,
+ 0, euc_to_utf8_F9, euc_to_utf8_FA, euc_to_utf8_FB,
+ euc_to_utf8_FC_ms, 0, 0,
+};
#ifdef X0212_ENABLE
const unsigned short *const x0212_to_utf8_2bytes[] = {
@@ -2397,6 +2452,16 @@ const unsigned short utf8_to_euc_C2_ms[] = {
0x216B, 0x215E, 0, 0, 0x212D, 0, 0x2279, 0,
0xA231, 0, 0xA26B, 0, 0, 0, 0, 0xA244,
};
+const unsigned short utf8_to_euc_C2_mac[] = {
+ 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,
+ 0x0220, 0xA242, 0x2171, 0x2172, 0xA270, 0x5C, 0xA243, 0x2178,
+ 0x212F, 0x027D, 0xA26C, 0, 0x224C, 0, 0xA26E, 0xA234,
+ 0x216B, 0x215E, 0, 0, 0x212D, 0, 0x2279, 0,
+ 0xA231, 0, 0xA26B, 0, 0, 0, 0, 0xA244,
+};
const unsigned short utf8_to_euc_C2_932[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
@@ -2547,6 +2612,16 @@ const unsigned short utf8_to_euc_E284[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
+const unsigned short utf8_to_euc_E284_mac[] = {
+ 0, 0, 0, 0x216E, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0x2B7B, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0x2B7D, 0x027E, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0x2272, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+};
const unsigned short utf8_to_euc_E285[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
@@ -2557,6 +2632,16 @@ const unsigned short utf8_to_euc_E285[] = {
0xF373, 0xF374, 0xF375, 0xF376, 0xF377, 0xF378, 0xF379, 0xF37A,
0xF37B, 0xF37C, 0, 0, 0, 0, 0, 0,
};
+const unsigned short utf8_to_euc_E285_mac[] = {
+ 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,
+ 0x2A21, 0x2A22, 0x2A23, 0x2A24, 0x2A25, 0x2A26, 0x2A27, 0x2A28,
+ 0x2A29, 0x2A2A, 0, 0, 0, 0, 0, 0,
+ 0x2A35, 0x2A36, 0x2A37, 0x2A38, 0x2A39, 0x2A3A, 0x2A3B, 0x2A3C,
+ 0x2A3D, 0x2A3E, 0, 0, 0, 0, 0, 0,
+};
const unsigned short utf8_to_euc_E286[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
@@ -2597,6 +2682,16 @@ const unsigned short utf8_to_euc_E288_932[] = {
0, 0, 0, 0, 0x2168, 0x2268, 0, 0,
0, 0, 0, 0, 0, 0x2266, 0, 0,
};
+const unsigned short utf8_to_euc_E288_mac[] = {
+ 0x224F, 0, 0x225F, 0x2250, 0, 0, 0, 0x2260,
+ 0x223A, 0, 0, 0x223B, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0x2265, 0, 0, 0x2267, 0x2167, 0x2F22,
+ 0x225C, 0, 0, 0, 0, 0x2142, 0, 0x224A,
+ 0x224B, 0x2241, 0x2240, 0x2269, 0x226A, 0, 0x2F21, 0,
+ 0, 0, 0, 0, 0x2168, 0x2268, 0, 0,
+ 0, 0, 0, 0, 0, 0x2266, 0, 0,
+};
const unsigned short utf8_to_euc_E289[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
@@ -2617,6 +2712,16 @@ const unsigned short utf8_to_euc_E28A[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0x2D79,
};
+const unsigned short utf8_to_euc_E28A_mac[] = {
+ 0, 0, 0x223E, 0x223F, 0, 0, 0x223C, 0x223D,
+ 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, 0x225D, 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, 0x2F23,
+};
const unsigned short utf8_to_euc_E28C[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
@@ -2637,6 +2742,16 @@ const unsigned short utf8_to_euc_E291[] = {
0x2D31, 0x2D32, 0x2D33, 0x2D34, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
+const unsigned short utf8_to_euc_E291_mac[] = {
+ 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,
+ 0x2921, 0x2922, 0x2923, 0x2924, 0x2925, 0x2926, 0x2927, 0x2928,
+ 0x2929, 0x292A, 0x292B, 0x292C, 0x292D, 0x292E, 0x292F, 0x2930,
+ 0x2931, 0x2932, 0x2933, 0x2934, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+};
const unsigned short utf8_to_euc_E294[] = {
0x2821, 0x282C, 0x2822, 0x282D, 0, 0, 0, 0,
0, 0, 0, 0, 0x2823, 0, 0, 0x282E,
@@ -2767,6 +2882,16 @@ const unsigned short utf8_to_euc_E388[] = {
0, 0x2D6A, 0x2D6B, 0, 0, 0, 0, 0,
0, 0x2D6C, 0, 0, 0, 0, 0, 0,
};
+const unsigned short utf8_to_euc_E388_mac[] = {
+ 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, 0x2D2E, 0x2D31, 0, 0, 0, 0, 0,
+ 0, 0x2D2C, 0, 0, 0, 0, 0, 0,
+};
const unsigned short utf8_to_euc_E38A[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
@@ -2777,6 +2902,16 @@ const unsigned short utf8_to_euc_E38A[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
+const unsigned short utf8_to_euc_E38A_mac[] = {
+ 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, 0x2D73, 0x2D74, 0x2D75, 0x2D76,
+ 0x2D77, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+};
const unsigned short utf8_to_euc_E38C[] = {
0, 0, 0, 0x2D46, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0x2D4A, 0, 0,
@@ -2787,6 +2922,16 @@ const unsigned short utf8_to_euc_E38C[] = {
0, 0, 0, 0, 0, 0, 0x2D47, 0,
0, 0, 0, 0x2D4F, 0, 0, 0, 0,
};
+const unsigned short utf8_to_euc_E38C_mac[] = {
+ 0, 0, 0, 0x2E29, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0x2E32, 0, 0,
+ 0, 0, 0, 0, 0x2E24, 0, 0, 0,
+ 0x2E2B, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0x2E22, 0x2E34, 0, 0, 0x2E35, 0x2E2D,
+ 0, 0, 0, 0x2E37, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0x2E2A, 0,
+ 0, 0, 0, 0x2E36, 0, 0, 0, 0,
+};
const unsigned short utf8_to_euc_E38D[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0x2D40, 0x2D4E, 0, 0, 0x2D43, 0, 0,
@@ -2797,6 +2942,16 @@ const unsigned short utf8_to_euc_E38D[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0x2D5F, 0x2D6F, 0x2D6E, 0x2D6D, 0,
};
+const unsigned short utf8_to_euc_E38D_mac[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0x2E21, 0x2E2F, 0, 0, 0x2E23, 0, 0,
+ 0, 0x2E2E, 0, 0, 0, 0, 0, 0x2E31,
+ 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, 0x2E6A, 0x2E69, 0x2E68, 0x2E67, 0,
+};
const unsigned short utf8_to_euc_E38E[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0x2D53, 0x2D54,
@@ -2807,6 +2962,16 @@ const unsigned short utf8_to_euc_E38E[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
+const unsigned short utf8_to_euc_E38E_mac[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0x2B2B, 0x2B2D,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0x2B21, 0x2B23, 0x2B29, 0,
+ 0, 0x2B27, 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,
+};
const unsigned short utf8_to_euc_E38F[] = {
0, 0, 0, 0, 0x2D55, 0, 0, 0,
0, 0, 0, 0, 0, 0x2D63, 0, 0,
@@ -2817,6 +2982,16 @@ const unsigned short utf8_to_euc_E38F[] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
+const unsigned short utf8_to_euc_E38F_mac[] = {
+ 0, 0, 0, 0, 0x2B2E, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0x2B7C, 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,
+};
const unsigned short utf8_to_euc_E4B8[] = {
0x306C, 0x437A, 0xB021, 0x3C37, 0xB022, 0xB023, 0, 0x4B7C,
0x3E66, 0x3B30, 0x3E65, 0x323C, 0xB024, 0x4954, 0x4D3F, 0,
@@ -6171,6 +6346,24 @@ const unsigned short *const utf8_to_euc_E2_932[] = {
0, 0, 0, 0,
0, 0, 0, 0,
};
+const unsigned short *const utf8_to_euc_E2_mac[] = {
+ utf8_to_euc_E280_932, 0, 0, 0,
+ utf8_to_euc_E284_mac, utf8_to_euc_E285_mac, utf8_to_euc_E286, utf8_to_euc_E287,
+ utf8_to_euc_E288_mac, utf8_to_euc_E289, utf8_to_euc_E28A_mac, 0,
+ utf8_to_euc_E28C, 0, 0, 0,
+ 0, utf8_to_euc_E291_mac, 0, 0,
+ utf8_to_euc_E294, utf8_to_euc_E295, utf8_to_euc_E296, utf8_to_euc_E297,
+ utf8_to_euc_E298, utf8_to_euc_E299, 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,
+};
const unsigned short *const utf8_to_euc_E3[] = {
utf8_to_euc_E380, utf8_to_euc_E381, utf8_to_euc_E382, utf8_to_euc_E383,
0, 0, 0, 0,
@@ -6207,6 +6400,24 @@ const unsigned short *const utf8_to_euc_E3_932[] = {
0, 0, 0, 0,
0, 0, 0, 0,
};
+const unsigned short *const utf8_to_euc_E3_mac[] = {
+ utf8_to_euc_E380_932, utf8_to_euc_E381, utf8_to_euc_E382_932, utf8_to_euc_E383,
+ 0, 0, 0, 0,
+ utf8_to_euc_E388_mac, 0, utf8_to_euc_E38A_mac, 0,
+ utf8_to_euc_E38C_mac, utf8_to_euc_E38D_mac, utf8_to_euc_E38E_mac, utf8_to_euc_E38F_mac,
+ 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,
+};
const unsigned short *const utf8_to_euc_E4[] = {
0, 0, 0, 0,
0, 0, 0, 0,
@@ -6441,6 +6652,36 @@ const unsigned short *const utf8_to_euc_2bytes_932[] = {
0, 0, 0, 0,
0, 0, 0, 0,
};
+const unsigned short *const utf8_to_euc_2bytes_mac[] = {
+ 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, 0, 0, 0,
+ 0, 0, 0, 0,
+ 0, 0, utf8_to_euc_C2_mac, utf8_to_euc_C3,
+ utf8_to_euc_C4, utf8_to_euc_C5, 0, utf8_to_euc_C7,
+ 0, 0, 0, utf8_to_euc_CB,
+ 0, 0, utf8_to_euc_CE, utf8_to_euc_CF,
+ utf8_to_euc_D0, utf8_to_euc_D1, 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,
+};
const unsigned short *const *const utf8_to_euc_3bytes[] = {
0, 0, utf8_to_euc_E2, utf8_to_euc_E3,
utf8_to_euc_E4, utf8_to_euc_E5, utf8_to_euc_E6, utf8_to_euc_E7,
@@ -6459,6 +6700,12 @@ const unsigned short *const *const utf8_to_euc_3bytes_932[] = {
utf8_to_euc_E8, utf8_to_euc_E9, 0, 0,
0, 0, 0, utf8_to_euc_EF_ms,
};
+const unsigned short *const *const utf8_to_euc_3bytes_mac[] = {
+ 0, 0, utf8_to_euc_E2_mac, utf8_to_euc_E3_mac,
+ utf8_to_euc_E4, utf8_to_euc_E5, utf8_to_euc_E6, utf8_to_euc_E7,
+ utf8_to_euc_E8, utf8_to_euc_E9, 0, 0,
+ 0, 0, 0, utf8_to_euc_EF_ms,
+};
#ifdef UNICODE_NORMALIZATION
diff --git a/ext/nkf/nkf-utf8/utf8tbl.h b/ext/nkf/nkf-utf8/utf8tbl.h
index 1f40f0b..29413d4 100644
--- a/ext/nkf/nkf-utf8/utf8tbl.h
+++ b/ext/nkf/nkf-utf8/utf8tbl.h
@@ -5,6 +5,7 @@
extern const unsigned short euc_to_utf8_1byte[];
extern const unsigned short *const euc_to_utf8_2bytes[];
extern const unsigned short *const euc_to_utf8_2bytes_ms[];
+extern const unsigned short *const euc_to_utf8_2bytes_mac[];
extern const unsigned short *const x0212_to_utf8_2bytes[];
#endif /* UTF8_OUTPUT_ENABLE */
@@ -12,9 +13,11 @@ extern const unsigned short *const x0212_to_utf8_2bytes[];
extern const unsigned short *const utf8_to_euc_2bytes[];
extern const unsigned short *const utf8_to_euc_2bytes_ms[];
extern const unsigned short *const utf8_to_euc_2bytes_932[];
+extern const unsigned short *const utf8_to_euc_2bytes_mac[];
extern const unsigned short *const *const utf8_to_euc_3bytes[];
extern const unsigned short *const *const utf8_to_euc_3bytes_ms[];
extern const unsigned short *const *const utf8_to_euc_3bytes_932[];
+extern const unsigned short *const *const utf8_to_euc_3bytes_mac[];
#endif /* UTF8_INPUT_ENABLE */
#ifdef UNICODE_NORMALIZATION
diff --git a/lib/json.rb b/lib/json.rb
new file mode 100644
index 0000000..1700e06
--- /dev/null
+++ b/lib/json.rb
@@ -0,0 +1,210 @@
+require 'json/common'
+# = json - JSON for Ruby
+#
+# == Description
+#
+# This is a implementation of the JSON specification according to RFC 4627
+# (http://www.ietf.org/rfc/rfc4627.txt). Starting from version 1.0.0 on there
+# will be two variants available:
+#
+# * A pure ruby variant, that relies on the iconv and the stringscan
+# extensions, which are both part of the ruby standard library.
+# * The quite a bit faster C extension variant, which is in parts implemented
+# in C and comes with its own unicode conversion functions and a parser
+# generated by the ragel state machine compiler
+# (http://www.cs.queensu.ca/~thurston/ragel).
+#
+# Both variants of the JSON generator escape all non-ASCII an control
+# characters with \uXXXX escape sequences, and support UTF-16 surrogate pairs
+# in order to be able to generate the whole range of unicode code points. This
+# means that generated JSON text is encoded as UTF-8 (because ASCII is a subset
+# of UTF-8) and at the same time avoids decoding problems for receiving
+# endpoints, that don't expect UTF-8 encoded texts. On the negative side this
+# may lead to a bit longer strings than necessarry.
+#
+# All strings, that are to be encoded as JSON strings, should be UTF-8 byte
+# sequences on the Ruby side. To encode raw binary strings, that aren't UTF-8
+# encoded, please use the to_json_raw_object method of String (which produces
+# an object, that contains a byte array) and decode the result on the receiving
+# endpoint.
+#
+# == Author
+#
+# Florian Frank <mailto:flori@ping.de>
+#
+# == License
+#
+# This software is distributed under the same license as Ruby itself, see
+# http://www.ruby-lang.org/en/LICENSE.txt.
+#
+# == Download
+#
+# The latest version of this library can be downloaded at
+#
+# * http://rubyforge.org/frs?group_id=953
+#
+# Online Documentation should be located at
+#
+# * http://json.rubyforge.org
+#
+# == Speed Comparisons
+#
+# I have created some benchmark results (see the benchmarks subdir of the
+# package) for the JSON-Parser to estimate the speed up in the C extension:
+#
+# JSON::Pure::Parser:: 28.90 calls/second
+# JSON::Ext::Parser:: 505.50 calls/second
+#
+# This is ca. <b>17.5</b> times the speed of the pure Ruby implementation.
+#
+# I have benchmarked the JSON-Generator as well. This generates a few more
+# values, because there are different modes, that also influence the achieved
+# speed:
+#
+# * JSON::Pure::Generator:
+# generate:: 35.06 calls/second
+# pretty_generate:: 34.00 calls/second
+# fast_generate:: 41.06 calls/second
+#
+# * JSON::Ext::Generator:
+# generate:: 492.11 calls/second
+# pretty_generate:: 348.85 calls/second
+# fast_generate:: 541.60 calls/second
+#
+# * Speedup Ext/Pure:
+# generate safe:: 14.0 times
+# generate pretty:: 10.3 times
+# generate fast:: 13.2 times
+#
+# The rails framework includes a generator as well, also it seems to be rather
+# slow: I measured only 23.87 calls/second which is slower than any of my pure
+# generator results. Here a comparison of the different speedups with the Rails
+# measurement as the divisor:
+#
+# * Speedup Pure/Rails:
+# generate safe:: 1.5 times
+# generate pretty:: 1.4 times
+# generate fast:: 1.7 times
+#
+# * Speedup Ext/Rails:
+# generate safe:: 20.6 times
+# generate pretty:: 14.6 times
+# generate fast:: 22.7 times
+#
+# To achieve the fastest JSON text output, you can use the
+# fast_generate/fast_unparse methods. Beware, that this will disable the
+# checking for circular Ruby data structures, which may cause JSON to go into
+# an infinite loop.
+#
+# == Examples
+#
+# To create a JSON text from a ruby data structure, you
+# can call JSON.generate (or JSON.unparse) like that:
+#
+# json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+# # => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
+#
+# It's also possible to call the #to_json method directly.
+#
+# json = [1, 2, {"a"=>3.141}, false, true, nil, 4..10].to_json
+# # => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
+#
+# To create a valid JSON text you have to make sure, that the output is
+# embedded in either a JSON array [] or a JSON object {}. The easiest way to do
+# this, is by putting your values in a Ruby Array or Hash instance.
+#
+# To get back a ruby data structure from a JSON text, you have to call
+# JSON.parse on it:
+#
+# JSON.parse json
+# # => [1, 2, {"a"=>3.141}, false, true, nil, "4..10"]
+#
+# Note, that the range from the original data structure is a simple
+# string now. The reason for this is, that JSON doesn't support ranges
+# or arbitrary classes. In this case the json library falls back to call
+# Object#to_json, which is the same as #to_s.to_json.
+#
+# It's possible to extend JSON to support serialization of arbitrary classes by
+# simply implementing a more specialized version of the #to_json method, that
+# should return a JSON object (a hash converted to JSON with #to_json)
+# like this (don't forget the *a for all the arguments):
+#
+# class Range
+# def to_json(*a)
+# {
+# 'json_class' => self.class.name, # = 'Range'
+# 'data' => [ first, last, exclude_end? ]
+# }.to_json(*a)
+# end
+# end
+#
+# The hash key 'json_class' is the class, that will be asked to deserialize the
+# JSON representation later. In this case it's 'Range', but any namespace of
+# the form 'A::B' or '::A::B' will do. All other keys are arbitrary and can be
+# used to store the necessary data to configure the object to be deserialized.
+#
+# If a the key 'json_class' is found in a JSON object, the JSON parser checks
+# if the given class responds to the json_create class method. If so, it is
+# called with the JSON object converted to a Ruby hash. So a range can
+# be deserialized by implementing Range.json_create like this:
+#
+# class Range
+# def self.json_create(o)
+# new(*o['data'])
+# end
+# end
+#
+# Now it possible to serialize/deserialize ranges as well:
+#
+# json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+# # => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]"
+# JSON.parse json
+# # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+#
+# JSON.generate always creates the shortest possible string representation of a
+# ruby data structure in one line. This good for data storage or network
+# protocols, but not so good for humans to read. Fortunately there's also
+# JSON.pretty_generate (or JSON.pretty_generate) that creates a more
+# readable output:
+#
+# puts JSON.pretty_generate([1, 2, {"a"=>3.141}, false, true, nil, 4..10])
+# [
+# 1,
+# 2,
+# {
+# "a": 3.141
+# },
+# false,
+# true,
+# null,
+# {
+# "json_class": "Range",
+# "data": [
+# 4,
+# 10,
+# false
+# ]
+# }
+# ]
+#
+# There are also the methods Kernel#j for unparse, and Kernel#jj for
+# pretty_unparse output to the console, that work analogous to Core Ruby's p
+# and the pp library's pp methods.
+#
+# The script tools/server.rb contains a small example if you want to test, how
+# receiving a JSON object from a webrick server in your browser with the
+# javasript prototype library (http://www.prototypejs.org) works.
+#
+module JSON
+ require 'json/version'
+
+ if VARIANT_BINARY
+ require 'json/ext'
+ else
+ begin
+ require 'json/ext'
+ rescue LoadError
+ require 'json/pure'
+ end
+ end
+end
diff --git a/lib/json/Array.xpm b/lib/json/Array.xpm
new file mode 100644
index 0000000..27c4801
--- /dev/null
+++ b/lib/json/Array.xpm
@@ -0,0 +1,21 @@
+/* XPM */
+static char * Array_xpm[] = {
+"16 16 2 1",
+" c None",
+". c #000000",
+" ",
+" ",
+" ",
+" .......... ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" .......... ",
+" ",
+" ",
+" "};
diff --git a/lib/json/FalseClass.xpm b/lib/json/FalseClass.xpm
new file mode 100644
index 0000000..25ce608
--- /dev/null
+++ b/lib/json/FalseClass.xpm
@@ -0,0 +1,21 @@
+/* XPM */
+static char * False_xpm[] = {
+"16 16 2 1",
+" c None",
+". c #FF0000",
+" ",
+" ",
+" ",
+" ...... ",
+" . ",
+" . ",
+" . ",
+" ...... ",
+" . ",
+" . ",
+" . ",
+" . ",
+" . ",
+" ",
+" ",
+" "};
diff --git a/lib/json/Hash.xpm b/lib/json/Hash.xpm
new file mode 100644
index 0000000..cd8f6f7
--- /dev/null
+++ b/lib/json/Hash.xpm
@@ -0,0 +1,21 @@
+/* XPM */
+static char * Hash_xpm[] = {
+"16 16 2 1",
+" c None",
+". c #000000",
+" ",
+" ",
+" ",
+" . . ",
+" . . ",
+" . . ",
+" ......... ",
+" . . ",
+" . . ",
+" ......... ",
+" . . ",
+" . . ",
+" . . ",
+" ",
+" ",
+" "};
diff --git a/lib/json/Key.xpm b/lib/json/Key.xpm
new file mode 100644
index 0000000..9fd7281
--- /dev/null
+++ b/lib/json/Key.xpm
@@ -0,0 +1,73 @@
+/* XPM */
+static char * Key_xpm[] = {
+"16 16 54 1",
+" c None",
+". c #110007",
+"+ c #0E0900",
+"@ c #000013",
+"# c #070600",
+"$ c #F6F006",
+"% c #ECE711",
+"& c #E5EE00",
+"* c #16021E",
+"= c #120900",
+"- c #EDF12B",
+"; c #000033",
+"> c #0F0000",
+", c #FFFE03",
+"' c #E6E500",
+") c #16021B",
+"! c #F7F502",
+"~ c #000E00",
+"{ c #130000",
+"] c #FFF000",
+"^ c #FFE711",
+"/ c #140005",
+"( c #190025",
+"_ c #E9DD27",
+": c #E7DC04",
+"< c #FFEC09",
+"[ c #FFE707",
+"} c #FFDE10",
+"| c #150021",
+"1 c #160700",
+"2 c #FAF60E",
+"3 c #EFE301",
+"4 c #FEF300",
+"5 c #E7E000",
+"6 c #FFFF08",
+"7 c #0E0206",
+"8 c #040000",
+"9 c #03052E",
+"0 c #041212",
+"a c #070300",
+"b c #F2E713",
+"c c #F9DE13",
+"d c #36091E",
+"e c #00001C",
+"f c #1F0010",
+"g c #FFF500",
+"h c #DEDE00",
+"i c #050A00",
+"j c #FAF14A",
+"k c #F5F200",
+"l c #040404",
+"m c #1A0D00",
+"n c #EDE43D",
+"o c #ECE007",
+" ",
+" ",
+" .+@ ",
+" #$%&* ",
+" =-;>,') ",
+" >!~{]^/ ",
+" (_:<[}| ",
+" 1234567 ",
+" 890abcd ",
+" efghi ",
+" >jkl ",
+" mnol ",
+" >kl ",
+" ll ",
+" ",
+" "};
diff --git a/lib/json/NilClass.xpm b/lib/json/NilClass.xpm
new file mode 100644
index 0000000..3509f06
--- /dev/null
+++ b/lib/json/NilClass.xpm
@@ -0,0 +1,21 @@
+/* XPM */
+static char * False_xpm[] = {
+"16 16 2 1",
+" c None",
+". c #000000",
+" ",
+" ",
+" ",
+" ... ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" . . ",
+" ... ",
+" ",
+" ",
+" "};
diff --git a/lib/json/Numeric.xpm b/lib/json/Numeric.xpm
new file mode 100644
index 0000000..e071e2e
--- /dev/null
+++ b/lib/json/Numeric.xpm
@@ -0,0 +1,28 @@
+/* XPM */
+static char * Numeric_xpm[] = {
+"16 16 9 1",
+" c None",
+". c #FF0000",
+"+ c #0000FF",
+"@ c #0023DB",
+"# c #00EA14",
+"$ c #00FF00",
+"% c #004FAF",
+"& c #0028D6",
+"* c #00F20C",
+" ",
+" ",
+" ",
+" ... +++@#$$$$ ",
+" .+ %& $$ ",
+" . + $ ",
+" . + $$ ",
+" . ++$$$$ ",
+" . + $$ ",
+" . + $ ",
+" . + $ ",
+" . + $ $$ ",
+" .....++++*$$ ",
+" ",
+" ",
+" "};
diff --git a/lib/json/String.xpm b/lib/json/String.xpm
new file mode 100644
index 0000000..f79a89c
--- /dev/null
+++ b/lib/json/String.xpm
@@ -0,0 +1,96 @@
+/* XPM */
+static char * String_xpm[] = {
+"16 16 77 1",
+" c None",
+". c #000000",
+"+ c #040404",
+"@ c #080806",
+"# c #090606",
+"$ c #EEEAE1",
+"% c #E7E3DA",
+"& c #E0DBD1",
+"* c #D4B46F",
+"= c #0C0906",
+"- c #E3C072",
+"; c #E4C072",
+"> c #060505",
+", c #0B0A08",
+"' c #D5B264",
+") c #D3AF5A",
+"! c #080602",
+"~ c #E1B863",
+"{ c #DDB151",
+"] c #DBAE4A",
+"^ c #DDB152",
+"/ c #DDB252",
+"( c #070705",
+"_ c #0C0A07",
+": c #D3A33B",
+"< c #020201",
+"[ c #DAAA41",
+"} c #040302",
+"| c #E4D9BF",
+"1 c #0B0907",
+"2 c #030201",
+"3 c #020200",
+"4 c #C99115",
+"5 c #080704",
+"6 c #DBC8A2",
+"7 c #E7D7B4",
+"8 c #E0CD9E",
+"9 c #080601",
+"0 c #040400",
+"a c #010100",
+"b c #0B0B08",
+"c c #DCBF83",
+"d c #DCBC75",
+"e c #DEB559",
+"f c #040301",
+"g c #BC8815",
+"h c #120E07",
+"i c #060402",
+"j c #0A0804",
+"k c #D4A747",
+"l c #D6A12F",
+"m c #0E0C05",
+"n c #C8C1B0",
+"o c #1D1B15",
+"p c #D7AD51",
+"q c #070502",
+"r c #080804",
+"s c #BC953B",
+"t c #C4BDAD",
+"u c #0B0807",
+"v c #DBAC47",
+"w c #1B150A",
+"x c #B78A2C",
+"y c #D8A83C",
+"z c #D4A338",
+"A c #0F0B03",
+"B c #181105",
+"C c #C59325",
+"D c #C18E1F",
+"E c #060600",
+"F c #CC992D",
+"G c #B98B25",
+"H c #B3831F",
+"I c #C08C1C",
+"J c #060500",
+"K c #0E0C03",
+"L c #0D0A00",
+" ",
+" .+@# ",
+" .$%&*= ",
+" .-;>,')! ",
+" .~. .{]. ",
+" .^/. (_:< ",
+" .[.}|$12 ",
+" 345678}90 ",
+" a2bcdefgh ",
+" ijkl.mno ",
+" <pq. rstu ",
+" .]v. wx= ",
+" .yzABCDE ",
+" .FGHIJ ",
+" 0KL0 ",
+" "};
diff --git a/lib/json/TrueClass.xpm b/lib/json/TrueClass.xpm
new file mode 100644
index 0000000..143eef4
--- /dev/null
+++ b/lib/json/TrueClass.xpm
@@ -0,0 +1,21 @@
+/* XPM */
+static char * TrueClass_xpm[] = {
+"16 16 2 1",
+" c None",
+". c #0BF311",
+" ",
+" ",
+" ",
+" ......... ",
+" . ",
+" . ",
+" . ",
+" . ",
+" . ",
+" . ",
+" . ",
+" . ",
+" . ",
+" ",
+" ",
+" "};
diff --git a/lib/json/common.rb b/lib/json/common.rb
new file mode 100644
index 0000000..c820cfb
--- /dev/null
+++ b/lib/json/common.rb
@@ -0,0 +1,194 @@
+require 'json/version'
+
+module JSON
+ class << self
+ # If object is string like parse the string and return the parsed result as a
+ # Ruby data structure. Otherwise generate a JSON text from the Ruby data
+ # structure object and return it.
+ def [](object)
+ if object.respond_to? :to_str
+ JSON.parse(object.to_str)
+ else
+ JSON.generate(object)
+ end
+ end
+
+ # Returns the JSON parser class, that is used by JSON. This might be either
+ # JSON::Ext::Parser or JSON::Pure::Parser.
+ attr_reader :parser
+
+ # Set the JSON parser class _parser_ to be used by JSON.
+ def parser=(parser) # :nodoc:
+ @parser = parser
+ remove_const :Parser if const_defined? :Parser
+ const_set :Parser, parser
+ end
+
+ # Return the constant located at _path_. The format of _path_ has to be
+ # either ::A::B::C or A::B::C. In any case A has to be located at the top
+ # level (absolute namespace path?). If there doesn't exist a constant at
+ # the given path, an ArgumentError is raised.
+ def deep_const_get(path) # :nodoc:
+ path = path.to_s
+ path.split(/::/).inject(Object) do |p, c|
+ case
+ when c.empty? then p
+ when p.const_defined?(c) then p.const_get(c)
+ else raise ArgumentError, "can't find const #{path}"
+ end
+ end
+ end
+
+ # Set the module _generator_ to be used by JSON.
+ def generator=(generator) # :nodoc:
+ @generator = generator
+ generator_methods = generator::GeneratorMethods
+ for const in generator_methods.constants
+ klass = deep_const_get(const)
+ modul = generator_methods.const_get(const)
+ klass.class_eval do
+ instance_methods(false).each do |m|
+ m.to_s == 'to_json' and remove_method m
+ end
+ include modul
+ end
+ end
+ self.state = generator::State
+ const_set :State, self.state
+ end
+
+ # Returns the JSON generator modul, that is used by JSON. This might be
+ # either JSON::Ext::Generator or JSON::Pure::Generator.
+ attr_reader :generator
+
+ # Returns the JSON generator state class, that is used by JSON. This might
+ # be either JSON::Ext::Generator::State or JSON::Pure::Generator::State.
+ attr_accessor :state
+
+ # This is create identifier, that is used to decide, if the _json_create_
+ # hook of a class should be called. It defaults to 'json_class'.
+ attr_accessor :create_id
+ end
+ self.create_id = 'json_class'
+
+ # The base exception for JSON errors.
+ class JSONError < StandardError; end
+
+ # This exception is raised, if a parser error occurs.
+ class ParserError < JSONError; end
+
+ # This exception is raised, if the nesting of parsed datastructures is too
+ # deep.
+ class NestingError < ParserError; end
+
+ # This exception is raised, if a generator or unparser error occurs.
+ class GeneratorError < JSONError; end
+ # For backwards compatibility
+ UnparserError = GeneratorError
+
+ # If a circular data structure is encountered while unparsing
+ # this exception is raised.
+ class CircularDatastructure < GeneratorError; end
+
+ # This exception is raised, if the required unicode support is missing on the
+ # system. Usually this means, that the iconv library is not installed.
+ class MissingUnicodeSupport < JSONError; end
+
+ module_function
+
+ # Parse the JSON string _source_ into a Ruby data structure and return it.
+ #
+ # _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.
+ def parse(source, opts = {})
+ JSON.parser.new(source, opts).parse
+ end
+
+ # Unparse the Ruby data structure _obj_ into a single line JSON string and
+ # return it. _state_ is a JSON::State object, that can be used to configure
+ # the output further.
+ #
+ # It defaults to a state object, that creates the shortest possible JSON text
+ # in one line and only checks for circular data structures. If you are sure,
+ # that the objects don't contain any circles, you can set _state_ to nil, to
+ # disable these checks in order to create the JSON text faster. See also
+ # fast_generate.
+ def generate(obj, state = JSON.state.new)
+ obj.to_json(state)
+ end
+
+ alias unparse generate
+ module_function :unparse
+
+ # Unparse the Ruby data structure _obj_ into a single line JSON string and
+ # return it. This method disables the checks for circles in Ruby objects.
+ #
+ # *WARNING*: Be careful not to pass any Ruby data structures with circles as
+ # _obj_ argument, because this will cause JSON to go into an infinite loop.
+ def fast_generate(obj)
+ obj.to_json(nil)
+ end
+
+ alias fast_unparse fast_generate
+ module_function :fast_unparse
+
+ # Unparse the Ruby data structure _obj_ into a JSON string and return it. The
+ # returned string is a prettier form of the string returned by #unparse.
+ def pretty_generate(obj)
+ state = JSON.state.new(
+ :indent => ' ',
+ :space => ' ',
+ :object_nl => "\n",
+ :array_nl => "\n",
+ :check_circular => true
+ )
+ obj.to_json(state)
+ end
+
+ alias pretty_unparse pretty_generate
+ module_function :pretty_unparse
+end
+
+module ::Kernel
+ # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in
+ # one line.
+ def j(*objs)
+ objs.each do |obj|
+ puts JSON::generate(obj)
+ end
+ nil
+ end
+
+ # Ouputs _objs_ to STDOUT as JSON strings in a pretty format, with
+ # indentation and over many lines.
+ def jj(*objs)
+ objs.each do |obj|
+ puts JSON::pretty_generate(obj)
+ end
+ nil
+ end
+
+ # If object is string like parse the string and return the parsed result as a
+ # Ruby data structure. Otherwise generate a JSON text from the Ruby data
+ # structure object and return it.
+ def JSON(object)
+ if object.respond_to? :to_str
+ JSON.parse(object.to_str)
+ else
+ JSON.generate(object)
+ end
+ end
+end
+
+class ::Class
+ # Returns true, if this class can be used to create an instance
+ # from a serialised JSON string. The class has to implement a class
+ # method _json_create_ that expects a hash as first parameter, which includes
+ # the required data.
+ def json_creatable?
+ respond_to?(:json_create)
+ end
+end
+ # vim: set et sw=2 ts=2:
diff --git a/lib/json/editor.rb b/lib/json/editor.rb
new file mode 100644
index 0000000..063df69
--- /dev/null
+++ b/lib/json/editor.rb
@@ -0,0 +1,1295 @@
+# To use the GUI JSON editor, start the edit_json.rb executable script. It
+# requires ruby-gtk to be installed.
+
+require 'gtk2'
+require 'iconv'
+require 'json'
+require 'rbconfig'
+require 'open-uri'
+
+module JSON
+ module Editor
+ include Gtk
+
+ # Beginning of the editor window title
+ TITLE = 'JSON Editor'.freeze
+
+ # Columns constants
+ ICON_COL, TYPE_COL, CONTENT_COL = 0, 1, 2
+
+ # JSON primitive types (Containers)
+ CONTAINER_TYPES = %w[Array Hash].sort
+ # All JSON primitive types
+ ALL_TYPES = (%w[TrueClass FalseClass Numeric String NilClass] +
+ CONTAINER_TYPES).sort
+
+ # The Nodes necessary for the tree representation of a JSON document
+ ALL_NODES = (ALL_TYPES + %w[Key]).sort
+
+ DEFAULT_DIALOG_KEY_PRESS_HANDLER = lambda do |dialog, event|
+ case event.keyval
+ when Gdk::Keyval::GDK_Return
+ dialog.response Dialog::RESPONSE_ACCEPT
+ when Gdk::Keyval::GDK_Escape
+ dialog.response Dialog::RESPONSE_REJECT
+ end
+ end
+
+ # Returns the Gdk::Pixbuf of the icon named _name_ from the icon cache.
+ def Editor.fetch_icon(name)
+ @icon_cache ||= {}
+ unless @icon_cache.key?(name)
+ path = File.dirname(__FILE__)
+ @icon_cache[name] = Gdk::Pixbuf.new(File.join(path, name + '.xpm'))
+ end
+ @icon_cache[name]
+ end
+
+ # Opens an error dialog on top of _window_ showing the error message
+ # _text_.
+ def Editor.error_dialog(window, text)
+ dialog = MessageDialog.new(window, Dialog::MODAL,
+ MessageDialog::ERROR,
+ MessageDialog::BUTTONS_CLOSE, text)
+ dialog.show_all
+ window.focus = dialog
+ dialog.run
+ rescue TypeError
+ dialog = MessageDialog.new(Editor.window, Dialog::MODAL,
+ MessageDialog::ERROR,
+ MessageDialog::BUTTONS_CLOSE, text)
+ dialog.show_all
+ window.focus = dialog
+ dialog.run
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Opens a yes/no question dialog on top of _window_ showing the error
+ # message _text_. If yes was answered _true_ is returned, otherwise
+ # _false_.
+ def Editor.question_dialog(window, text)
+ dialog = MessageDialog.new(window, Dialog::MODAL,
+ MessageDialog::QUESTION,
+ MessageDialog::BUTTONS_YES_NO, text)
+ dialog.show_all
+ window.focus = dialog
+ dialog.run do |response|
+ return Gtk::Dialog::RESPONSE_YES === response
+ end
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Convert the tree model starting from Gtk::TreeIter _iter_ into a Ruby
+ # data structure and return it.
+ def Editor.model2data(iter)
+ return nil if iter.nil?
+ case iter.type
+ when 'Hash'
+ hash = {}
+ iter.each { |c| hash[c.content] = Editor.model2data(c.first_child) }
+ hash
+ when 'Array'
+ array = Array.new(iter.n_children)
+ iter.each_with_index { |c, i| array[i] = Editor.model2data(c) }
+ array
+ when 'Key'
+ iter.content
+ when 'String'
+ iter.content
+ when 'Numeric'
+ content = iter.content
+ if /\./.match(content)
+ content.to_f
+ else
+ content.to_i
+ end
+ when 'TrueClass'
+ true
+ when 'FalseClass'
+ false
+ when 'NilClass'
+ nil
+ else
+ fail "Unknown type found in model: #{iter.type}"
+ end
+ end
+
+ # Convert the Ruby data structure _data_ into tree model data for Gtk and
+ # returns the whole model. If the parameter _model_ wasn't given a new
+ # Gtk::TreeStore is created as the model. The _parent_ parameter specifies
+ # the parent node (iter, Gtk:TreeIter instance) to which the data is
+ # appended, alternativeley the result of the yielded block is used as iter.
+ def Editor.data2model(data, model = nil, parent = nil)
+ model ||= TreeStore.new(Gdk::Pixbuf, String, String)
+ iter = if block_given?
+ yield model
+ else
+ model.append(parent)
+ end
+ case data
+ when Hash
+ iter.type = 'Hash'
+ data.sort.each do |key, value|
+ pair_iter = model.append(iter)
+ pair_iter.type = 'Key'
+ pair_iter.content = key.to_s
+ Editor.data2model(value, model, pair_iter)
+ end
+ when Array
+ iter.type = 'Array'
+ data.each do |value|
+ Editor.data2model(value, model, iter)
+ end
+ when Numeric
+ iter.type = 'Numeric'
+ iter.content = data.to_s
+ when String, true, false, nil
+ iter.type = data.class.name
+ iter.content = data.nil? ? 'null' : data.to_s
+ else
+ iter.type = 'String'
+ iter.content = data.to_s
+ end
+ model
+ end
+
+ # The Gtk::TreeIter class is reopened and some auxiliary methods are added.
+ class Gtk::TreeIter
+ include Enumerable
+
+ # Traverse each of this Gtk::TreeIter instance's children
+ # and yield to them.
+ def each
+ n_children.times { |i| yield nth_child(i) }
+ end
+
+ # Recursively traverse all nodes of this Gtk::TreeIter's subtree
+ # (including self) and yield to them.
+ def recursive_each(&block)
+ yield self
+ each do |i|
+ i.recursive_each(&block)
+ end
+ end
+
+ # Remove the subtree of this Gtk::TreeIter instance from the
+ # model _model_.
+ def remove_subtree(model)
+ while current = first_child
+ model.remove(current)
+ end
+ end
+
+ # Returns the type of this node.
+ def type
+ self[TYPE_COL]
+ end
+
+ # Sets the type of this node to _value_. This implies setting
+ # the respective icon accordingly.
+ def type=(value)
+ self[TYPE_COL] = value
+ self[ICON_COL] = Editor.fetch_icon(value)
+ end
+
+ # Returns the content of this node.
+ def content
+ self[CONTENT_COL]
+ end
+
+ # Sets the content of this node to _value_.
+ def content=(value)
+ self[CONTENT_COL] = value
+ end
+ end
+
+ # This module bundles some method, that can be used to create a menu. It
+ # should be included into the class in question.
+ module MenuExtension
+ include Gtk
+
+ # Creates a Menu, that includes MenuExtension. _treeview_ is the
+ # Gtk::TreeView, on which it operates.
+ def initialize(treeview)
+ @treeview = treeview
+ @menu = Menu.new
+ end
+
+ # Returns the Gtk::TreeView of this menu.
+ attr_reader :treeview
+
+ # Returns the menu.
+ attr_reader :menu
+
+ # Adds a Gtk::SeparatorMenuItem to this instance's #menu.
+ def add_separator
+ menu.append SeparatorMenuItem.new
+ end
+
+ # Adds a Gtk::MenuItem to this instance's #menu. _label_ is the label
+ # string, _klass_ is the item type, and _callback_ is the procedure, that
+ # is called if the _item_ is activated.
+ def add_item(label, keyval = nil, klass = MenuItem, &callback)
+ label = "#{label} (C-#{keyval.chr})" if keyval
+ item = klass.new(label)
+ item.signal_connect(:activate, &callback)
+ if keyval
+ self.signal_connect(:'key-press-event') do |item, event|
+ if event.state & Gdk::Window::ModifierType::CONTROL_MASK != 0 and
+ event.keyval == keyval
+ callback.call item
+ end
+ end
+ end
+ menu.append item
+ item
+ end
+
+ # This method should be implemented in subclasses to create the #menu of
+ # this instance. It has to be called after an instance of this class is
+ # created, to build the menu.
+ def create
+ raise NotImplementedError
+ end
+
+ def method_missing(*a, &b)
+ treeview.__send__(*a, &b)
+ end
+ end
+
+ # This class creates the popup menu, that opens when clicking onto the
+ # treeview.
+ class PopUpMenu
+ include MenuExtension
+
+ # Change the type or content of the selected node.
+ def change_node(item)
+ if current = selection.selected
+ parent = current.parent
+ old_type, old_content = current.type, current.content
+ if ALL_TYPES.include?(old_type)
+ @clipboard_data = Editor.model2data(current)
+ type, content = ask_for_element(parent, current.type,
+ current.content)
+ if type
+ current.type, current.content = type, content
+ current.remove_subtree(model)
+ toplevel.display_status("Changed a node in tree.")
+ window.change
+ end
+ else
+ toplevel.display_status(
+ "Cannot change node of type #{old_type} in tree!")
+ end
+ end
+ end
+
+ # Cut the selected node and its subtree, and save it into the
+ # clipboard.
+ def cut_node(item)
+ if current = selection.selected
+ if current and current.type == 'Key'
+ @clipboard_data = {
+ current.content => Editor.model2data(current.first_child)
+ }
+ else
+ @clipboard_data = Editor.model2data(current)
+ end
+ model.remove(current)
+ window.change
+ toplevel.display_status("Cut a node from tree.")
+ end
+ end
+
+ # Copy the selected node and its subtree, and save it into the
+ # clipboard.
+ def copy_node(item)
+ if current = selection.selected
+ if current and current.type == 'Key'
+ @clipboard_data = {
+ current.content => Editor.model2data(current.first_child)
+ }
+ else
+ @clipboard_data = Editor.model2data(current)
+ end
+ window.change
+ toplevel.display_status("Copied a node from tree.")
+ end
+ end
+
+ # Paste the data in the clipboard into the selected Array or Hash by
+ # appending it.
+ def paste_node_appending(item)
+ if current = selection.selected
+ if @clipboard_data
+ case current.type
+ when 'Array'
+ Editor.data2model(@clipboard_data, model, current)
+ expand_collapse(current)
+ when 'Hash'
+ if @clipboard_data.is_a? Hash
+ parent = current.parent
+ hash = Editor.model2data(current)
+ model.remove(current)
+ hash.update(@clipboard_data)
+ Editor.data2model(hash, model, parent)
+ if parent
+ expand_collapse(parent)
+ elsif @expanded
+ expand_all
+ end
+ window.change
+ else
+ toplevel.display_status(
+ "Cannot paste non-#{current.type} data into '#{current.type}'!")
+ end
+ else
+ toplevel.display_status(
+ "Cannot paste node below '#{current.type}'!")
+ end
+ else
+ toplevel.display_status("Nothing to paste in clipboard!")
+ end
+ else
+ toplevel.display_status("Append a node into the root first!")
+ end
+ end
+
+ # Paste the data in the clipboard into the selected Array inserting it
+ # before the selected element.
+ def paste_node_inserting_before(item)
+ if current = selection.selected
+ if @clipboard_data
+ parent = current.parent or return
+ parent_type = parent.type
+ if parent_type == 'Array'
+ selected_index = parent.each_with_index do |c, i|
+ break i if c == current
+ end
+ Editor.data2model(@clipboard_data, model, parent) do |m|
+ m.insert_before(parent, current)
+ end
+ expand_collapse(current)
+ toplevel.display_status("Inserted an element to " +
+ "'#{parent_type}' before index #{selected_index}.")
+ window.change
+ else
+ toplevel.display_status(
+ "Cannot insert node below '#{parent_type}'!")
+ end
+ else
+ toplevel.display_status("Nothing to paste in clipboard!")
+ end
+ else
+ toplevel.display_status("Append a node into the root first!")
+ end
+ end
+
+ # Append a new node to the selected Hash or Array.
+ def append_new_node(item)
+ if parent = selection.selected
+ parent_type = parent.type
+ case parent_type
+ when 'Hash'
+ key, type, content = ask_for_hash_pair(parent)
+ key or return
+ iter = create_node(parent, 'Key', key)
+ iter = create_node(iter, type, content)
+ toplevel.display_status(
+ "Added a (key, value)-pair to '#{parent_type}'.")
+ window.change
+ when 'Array'
+ type, content = ask_for_element(parent)
+ type or return
+ iter = create_node(parent, type, content)
+ window.change
+ toplevel.display_status("Appendend an element to '#{parent_type}'.")
+ else
+ toplevel.display_status("Cannot append to '#{parent_type}'!")
+ end
+ else
+ type, content = ask_for_element
+ type or return
+ iter = create_node(nil, type, content)
+ window.change
+ end
+ end
+
+ # Insert a new node into an Array before the selected element.
+ def insert_new_node(item)
+ if current = selection.selected
+ parent = current.parent or return
+ parent_parent = parent.parent
+ parent_type = parent.type
+ if parent_type == 'Array'
+ selected_index = parent.each_with_index do |c, i|
+ break i if c == current
+ end
+ type, content = ask_for_element(parent)
+ type or return
+ iter = model.insert_before(parent, current)
+ iter.type, iter.content = type, content
+ toplevel.display_status("Inserted an element to " +
+ "'#{parent_type}' before index #{selected_index}.")
+ window.change
+ else
+ toplevel.display_status(
+ "Cannot insert node below '#{parent_type}'!")
+ end
+ else
+ toplevel.display_status("Append a node into the root first!")
+ end
+ end
+
+ # Recursively collapse/expand a subtree starting from the selected node.
+ def collapse_expand(item)
+ if current = selection.selected
+ if row_expanded?(current.path)
+ collapse_row(current.path)
+ else
+ expand_row(current.path, true)
+ end
+ else
+ toplevel.display_status("Append a node into the root first!")
+ end
+ end
+
+ # Create the menu.
+ def create
+ add_item("Change node", ?n, &method(:change_node))
+ add_separator
+ add_item("Cut node", ?x, &method(:cut_node))
+ add_item("Copy node", ?c, &method(:copy_node))
+ add_item("Paste node (appending)", ?v, &method(:paste_node_appending))
+ add_item("Paste node (inserting before)", ?V,
+ &method(:paste_node_inserting_before))
+ add_separator
+ add_item("Append new node", ?a, &method(:append_new_node))
+ add_item("Insert new node before", ?i, &method(:insert_new_node))
+ add_separator
+ add_item("Collapse/Expand node (recursively)", ?C,
+ &method(:collapse_expand))
+
+ menu.show_all
+ signal_connect(:button_press_event) do |widget, event|
+ if event.kind_of? Gdk::EventButton and event.button == 3
+ menu.popup(nil, nil, event.button, event.time)
+ end
+ end
+ signal_connect(:popup_menu) do
+ menu.popup(nil, nil, 0, Gdk::Event::CURRENT_TIME)
+ end
+ end
+ end
+
+ # This class creates the File pulldown menu.
+ class FileMenu
+ include MenuExtension
+
+ # Clear the model and filename, but ask to save the JSON document, if
+ # unsaved changes have occured.
+ def new(item)
+ window.clear
+ end
+
+ # Open a file and load it into the editor. Ask to save the JSON document
+ # first, if unsaved changes have occured.
+ def open(item)
+ window.file_open
+ end
+
+ def open_location(item)
+ window.location_open
+ end
+
+ # Revert the current JSON document in the editor to the saved version.
+ def revert(item)
+ window.instance_eval do
+ @filename and file_open(@filename)
+ end
+ end
+
+ # Save the current JSON document.
+ def save(item)
+ window.file_save
+ end
+
+ # Save the current JSON document under the given filename.
+ def save_as(item)
+ window.file_save_as
+ end
+
+ # Quit the editor, after asking to save any unsaved changes first.
+ def quit(item)
+ window.quit
+ end
+
+ # Create the menu.
+ def create
+ title = MenuItem.new('File')
+ title.submenu = menu
+ add_item('New', &method(:new))
+ add_item('Open', ?o, &method(:open))
+ add_item('Open location', ?l, &method(:open_location))
+ add_item('Revert', &method(:revert))
+ add_separator
+ add_item('Save', ?s, &method(:save))
+ add_item('Save As', ?S, &method(:save_as))
+ add_separator
+ add_item('Quit', ?q, &method(:quit))
+ title
+ end
+ end
+
+ # This class creates the Edit pulldown menu.
+ class EditMenu
+ include MenuExtension
+
+ # Find a string in all nodes' contents and select the found node in the
+ # treeview.
+ def find(item)
+ search = ask_for_find_term or return
+ begin
+ @search = Regexp.new(search)
+ rescue => e
+ Editor.error_dialog(self, "Evaluation of regex /#{search}/ failed: #{e}!")
+ return
+ end
+ iter = model.get_iter('0')
+ iter.recursive_each do |i|
+ if @iter
+ if @iter != i
+ next
+ else
+ @iter = nil
+ next
+ end
+ elsif @search.match(i[CONTENT_COL])
+ set_cursor(i.path, nil, false)
+ @iter = i
+ break
+ end
+ end
+ end
+
+ # Repeat the last search given by #find.
+ def find_again(item)
+ @search or return
+ iter = model.get_iter('0')
+ iter.recursive_each do |i|
+ if @iter
+ if @iter != i
+ next
+ else
+ @iter = nil
+ next
+ end
+ elsif @search.match(i[CONTENT_COL])
+ set_cursor(i.path, nil, false)
+ @iter = i
+ break
+ end
+ end
+ end
+
+ # Sort (Reverse sort) all elements of the selected array by the given
+ # expression. _x_ is the element in question.
+ def sort(item)
+ if current = selection.selected
+ if current.type == 'Array'
+ parent = current.parent
+ ary = Editor.model2data(current)
+ order, reverse = ask_for_order
+ order or return
+ begin
+ block = eval "lambda { |x| #{order} }"
+ if reverse
+ ary.sort! { |a,b| block[b] <=> block[a] }
+ else
+ ary.sort! { |a,b| block[a] <=> block[b] }
+ end
+ rescue => e
+ Editor.error_dialog(self, "Failed to sort Array with #{order}: #{e}!")
+ else
+ Editor.data2model(ary, model, parent) do |m|
+ m.insert_before(parent, current)
+ end
+ model.remove(current)
+ expand_collapse(parent)
+ window.change
+ toplevel.display_status("Array has been sorted.")
+ end
+ else
+ toplevel.display_status("Only Array nodes can be sorted!")
+ end
+ else
+ toplevel.display_status("Select an Array to sort first!")
+ end
+ end
+
+ # Create the menu.
+ def create
+ title = MenuItem.new('Edit')
+ title.submenu = menu
+ add_item('Find', ?f, &method(:find))
+ add_item('Find Again', ?g, &method(:find_again))
+ add_separator
+ add_item('Sort', ?S, &method(:sort))
+ title
+ end
+ end
+
+ class OptionsMenu
+ include MenuExtension
+
+ # Collapse/Expand all nodes by default.
+ def collapsed_nodes(item)
+ if expanded
+ self.expanded = false
+ collapse_all
+ else
+ self.expanded = true
+ expand_all
+ end
+ end
+
+ # Toggle pretty saving mode on/off.
+ def pretty_saving(item)
+ @pretty_item.toggled
+ window.change
+ end
+
+ attr_reader :pretty_item
+
+ # Create the menu.
+ def create
+ title = MenuItem.new('Options')
+ title.submenu = menu
+ add_item('Collapsed nodes', nil, CheckMenuItem, &method(:collapsed_nodes))
+ @pretty_item = add_item('Pretty saving', nil, CheckMenuItem,
+ &method(:pretty_saving))
+ @pretty_item.active = true
+ window.unchange
+ title
+ end
+ end
+
+ # This class inherits from Gtk::TreeView, to configure it and to add a lot
+ # of behaviour to it.
+ class JSONTreeView < Gtk::TreeView
+ include Gtk
+
+ # Creates a JSONTreeView instance, the parameter _window_ is
+ # a MainWindow instance and used for self delegation.
+ def initialize(window)
+ @window = window
+ super(TreeStore.new(Gdk::Pixbuf, String, String))
+ self.selection.mode = SELECTION_BROWSE
+
+ @expanded = false
+ self.headers_visible = false
+ add_columns
+ add_popup_menu
+ end
+
+ # Returns the MainWindow instance of this JSONTreeView.
+ attr_reader :window
+
+ # Returns true, if nodes are autoexpanding, false otherwise.
+ attr_accessor :expanded
+
+ private
+
+ def add_columns
+ cell = CellRendererPixbuf.new
+ column = TreeViewColumn.new('Icon', cell,
+ 'pixbuf' => ICON_COL
+ )
+ append_column(column)
+
+ cell = CellRendererText.new
+ column = TreeViewColumn.new('Type', cell,
+ 'text' => TYPE_COL
+ )
+ append_column(column)
+
+ cell = CellRendererText.new
+ cell.editable = true
+ column = TreeViewColumn.new('Content', cell,
+ 'text' => CONTENT_COL
+ )
+ cell.signal_connect(:edited, &method(:cell_edited))
+ append_column(column)
+ end
+
+ def unify_key(iter, key)
+ return unless iter.type == 'Key'
+ parent = iter.parent
+ if parent.any? { |c| c != iter and c.content == key }
+ old_key = key
+ i = 0
+ begin
+ key = sprintf("%s.%d", old_key, i += 1)
+ end while parent.any? { |c| c != iter and c.content == key }
+ end
+ iter.content = key
+ end
+
+ def cell_edited(cell, path, value)
+ iter = model.get_iter(path)
+ case iter.type
+ when 'Key'
+ unify_key(iter, value)
+ toplevel.display_status('Key has been changed.')
+ when 'FalseClass'
+ value.downcase!
+ if value == 'true'
+ iter.type, iter.content = 'TrueClass', 'true'
+ end
+ when 'TrueClass'
+ value.downcase!
+ if value == 'false'
+ iter.type, iter.content = 'FalseClass', 'false'
+ end
+ when 'Numeric'
+ iter.content = (Integer(value) rescue Float(value) rescue 0).to_s
+ when 'String'
+ iter.content = value
+ when 'Hash', 'Array'
+ return
+ else
+ fail "Unknown type found in model: #{iter.type}"
+ end
+ window.change
+ end
+
+ def configure_value(value, type)
+ value.editable = false
+ case type
+ when 'Array', 'Hash'
+ value.text = ''
+ when 'TrueClass'
+ value.text = 'true'
+ when 'FalseClass'
+ value.text = 'false'
+ when 'NilClass'
+ value.text = 'null'
+ when 'Numeric', 'String'
+ value.text ||= ''
+ value.editable = true
+ else
+ raise ArgumentError, "unknown type '#{type}' encountered"
+ end
+ end
+
+ def add_popup_menu
+ menu = PopUpMenu.new(self)
+ menu.create
+ end
+
+ public
+
+ # Create a _type_ node with content _content_, and add it to _parent_
+ # in the model. If _parent_ is nil, create a new model and put it into
+ # the editor treeview.
+ def create_node(parent, type, content)
+ iter = if parent
+ model.append(parent)
+ else
+ new_model = Editor.data2model(nil)
+ toplevel.view_new_model(new_model)
+ new_model.iter_first
+ end
+ iter.type, iter.content = type, content
+ expand_collapse(parent) if parent
+ iter
+ end
+
+ # Ask for a hash key, value pair to be added to the Hash node _parent_.
+ def ask_for_hash_pair(parent)
+ key_input = type_input = value_input = nil
+
+ dialog = Dialog.new("New (key, value) pair for Hash", nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+
+ hbox = HBox.new(false, 5)
+ hbox.pack_start(Label.new("Key:"))
+ hbox.pack_start(key_input = Entry.new)
+ key_input.text = @key || ''
+ dialog.vbox.add(hbox)
+ key_input.signal_connect(:activate) do
+ if parent.any? { |c| c.content == key_input.text }
+ toplevel.display_status('Key already exists in Hash!')
+ key_input.text = ''
+ else
+ toplevel.display_status('Key has been changed.')
+ end
+ end
+
+ hbox = HBox.new(false, 5)
+ hbox.add(Label.new("Type:"))
+ hbox.pack_start(type_input = ComboBox.new(true))
+ ALL_TYPES.each { |t| type_input.append_text(t) }
+ type_input.active = @type || 0
+ dialog.vbox.add(hbox)
+
+ type_input.signal_connect(:changed) do
+ value_input.editable = false
+ case ALL_TYPES[type_input.active]
+ when 'Array', 'Hash'
+ value_input.text = ''
+ when 'TrueClass'
+ value_input.text = 'true'
+ when 'FalseClass'
+ value_input.text = 'false'
+ when 'NilClass'
+ value_input.text = 'null'
+ else
+ value_input.text = ''
+ value_input.editable = true
+ end
+ end
+
+ hbox = HBox.new(false, 5)
+ hbox.add(Label.new("Value:"))
+ hbox.pack_start(value_input = Entry.new)
+ value_input.text = @value || ''
+ dialog.vbox.add(hbox)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ self.focus = dialog
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ @key = key_input.text
+ type = ALL_TYPES[@type = type_input.active]
+ content = value_input.text
+ return @key, type, content
+ end
+ end
+ return
+ ensure
+ dialog.destroy
+ end
+
+ # Ask for an element to be appended _parent_.
+ def ask_for_element(parent = nil, default_type = nil, value_text = @content)
+ type_input = value_input = nil
+
+ dialog = Dialog.new(
+ "New element into #{parent ? parent.type : 'root'}",
+ nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+ hbox = HBox.new(false, 5)
+ hbox.add(Label.new("Type:"))
+ hbox.pack_start(type_input = ComboBox.new(true))
+ default_active = 0
+ types = parent ? ALL_TYPES : CONTAINER_TYPES
+ types.each_with_index do |t, i|
+ type_input.append_text(t)
+ if t == default_type
+ default_active = i
+ end
+ end
+ type_input.active = default_active
+ dialog.vbox.add(hbox)
+ type_input.signal_connect(:changed) do
+ configure_value(value_input, types[type_input.active])
+ end
+
+ hbox = HBox.new(false, 5)
+ hbox.add(Label.new("Value:"))
+ hbox.pack_start(value_input = Entry.new)
+ value_input.text = value_text if value_text
+ configure_value(value_input, types[type_input.active])
+
+ dialog.vbox.add(hbox)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ self.focus = dialog
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ type = types[type_input.active]
+ @content = case type
+ when 'Numeric'
+ Integer(value_input.text) rescue Float(value_input.text) rescue 0
+ else
+ value_input.text
+ end.to_s
+ return type, @content
+ end
+ end
+ return
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Ask for an order criteria for sorting, using _x_ for the element in
+ # question. Returns the order criterium, and true/false for reverse
+ # sorting.
+ def ask_for_order
+ dialog = Dialog.new(
+ "Give an order criterium for 'x'.",
+ nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+ hbox = HBox.new(false, 5)
+
+ hbox.add(Label.new("Order:"))
+ hbox.pack_start(order_input = Entry.new)
+ order_input.text = @order || 'x'
+
+ hbox.pack_start(reverse_checkbox = CheckButton.new('Reverse'))
+
+ dialog.vbox.add(hbox)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ self.focus = dialog
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ return @order = order_input.text, reverse_checkbox.active?
+ end
+ end
+ return
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Ask for a find term to search for in the tree. Returns the term as a
+ # string.
+ def ask_for_find_term
+ dialog = Dialog.new(
+ "Find a node matching regex in tree.",
+ nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+ hbox = HBox.new(false, 5)
+
+ hbox.add(Label.new("Regex:"))
+ hbox.pack_start(regex_input = Entry.new)
+ regex_input.text = @regex || ''
+
+ dialog.vbox.add(hbox)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ self.focus = dialog
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ return @regex = regex_input.text
+ end
+ end
+ return
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Expand or collapse row pointed to by _iter_ according
+ # to the #expanded attribute.
+ def expand_collapse(iter)
+ if expanded
+ expand_row(iter.path, true)
+ else
+ collapse_row(iter.path)
+ end
+ end
+ end
+
+ # The editor main window
+ class MainWindow < Gtk::Window
+ include Gtk
+
+ def initialize(encoding)
+ @changed = false
+ @encoding = encoding
+ super(TOPLEVEL)
+ display_title
+ set_default_size(800, 600)
+ signal_connect(:delete_event) { quit }
+
+ vbox = VBox.new(false, 0)
+ add(vbox)
+ #vbox.border_width = 0
+
+ @treeview = JSONTreeView.new(self)
+ @treeview.signal_connect(:'cursor-changed') do
+ display_status('')
+ end
+
+ menu_bar = create_menu_bar
+ vbox.pack_start(menu_bar, false, false, 0)
+
+ sw = ScrolledWindow.new(nil, nil)
+ sw.shadow_type = SHADOW_ETCHED_IN
+ sw.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+ vbox.pack_start(sw, true, true, 0)
+ sw.add(@treeview)
+
+ @status_bar = Statusbar.new
+ vbox.pack_start(@status_bar, false, false, 0)
+
+ @filename ||= nil
+ if @filename
+ data = read_data(@filename)
+ view_new_model Editor.data2model(data)
+ end
+ end
+
+ # Creates the menu bar with the pulldown menus and returns it.
+ def create_menu_bar
+ menu_bar = MenuBar.new
+ @file_menu = FileMenu.new(@treeview)
+ menu_bar.append @file_menu.create
+ @edit_menu = EditMenu.new(@treeview)
+ menu_bar.append @edit_menu.create
+ @options_menu = OptionsMenu.new(@treeview)
+ menu_bar.append @options_menu.create
+ menu_bar
+ end
+
+ # Sets editor status to changed, to indicate that the edited data
+ # containts unsaved changes.
+ def change
+ @changed = true
+ display_title
+ end
+
+ # Sets editor status to unchanged, to indicate that the edited data
+ # doesn't containt unsaved changes.
+ def unchange
+ @changed = false
+ display_title
+ end
+
+ # Puts a new model _model_ into the Gtk::TreeView to be edited.
+ def view_new_model(model)
+ @treeview.model = model
+ @treeview.expanded = true
+ @treeview.expand_all
+ unchange
+ end
+
+ # Displays _text_ in the status bar.
+ def display_status(text)
+ @cid ||= nil
+ @status_bar.pop(@cid) if @cid
+ @cid = @status_bar.get_context_id('dummy')
+ @status_bar.push(@cid, text)
+ end
+
+ # Opens a dialog, asking, if changes should be saved to a file.
+ def ask_save
+ if Editor.question_dialog(self,
+ "Unsaved changes to JSON model. Save?")
+ if @filename
+ file_save
+ else
+ file_save_as
+ end
+ end
+ end
+
+ # Quit this editor, that is, leave this editor's main loop.
+ def quit
+ ask_save if @changed
+ destroy
+ Gtk.main_quit
+ true
+ end
+
+ # Display the new title according to the editor's current state.
+ def display_title
+ title = TITLE.dup
+ title << ": #@filename" if @filename
+ title << " *" if @changed
+ self.title = title
+ end
+
+ # Clear the current model, after asking to save all unsaved changes.
+ def clear
+ ask_save if @changed
+ @filename = nil
+ self.view_new_model nil
+ end
+
+ def check_pretty_printed(json)
+ pretty = !!((nl_index = json.index("\n")) && nl_index != json.size - 1)
+ @options_menu.pretty_item.active = pretty
+ end
+ private :check_pretty_printed
+
+ # Open the data at the location _uri_, if given. Otherwise open a dialog
+ # to ask for the _uri_.
+ def location_open(uri = nil)
+ uri = ask_for_location unless uri
+ uri or return
+ data = load_location(uri) or return
+ view_new_model Editor.data2model(data)
+ end
+
+ # Open the file _filename_ or call the #select_file method to ask for a
+ # filename.
+ def file_open(filename = nil)
+ filename = select_file('Open as a JSON file') unless filename
+ data = load_file(filename) or return
+ view_new_model Editor.data2model(data)
+ end
+
+ # Save the current file.
+ def file_save
+ if @filename
+ store_file(@filename)
+ else
+ file_save_as
+ end
+ end
+
+ # Save the current file as the filename
+ def file_save_as
+ filename = select_file('Save as a JSON file')
+ store_file(filename)
+ end
+
+ # Store the current JSON document to _path_.
+ def store_file(path)
+ if path
+ data = Editor.model2data(@treeview.model.iter_first)
+ File.open(path + '.tmp', 'wb') do |output|
+ if @options_menu.pretty_item.active?
+ output.puts JSON.pretty_generate(data)
+ else
+ output.write JSON.unparse(data)
+ end
+ end
+ File.rename path + '.tmp', path
+ @filename = path
+ toplevel.display_status("Saved data to '#@filename'.")
+ unchange
+ end
+ rescue SystemCallError => e
+ Editor.error_dialog(self, "Failed to store JSON file: #{e}!")
+ end
+
+ # Load the file named _filename_ into the editor as a JSON document.
+ def load_file(filename)
+ if filename
+ if File.directory?(filename)
+ Editor.error_dialog(self, "Try to select a JSON file!")
+ return
+ else
+ data = read_data(filename)
+ @filename = filename
+ toplevel.display_status("Loaded data from '#@filename'.")
+ display_title
+ return data
+ end
+ end
+ end
+
+ # Load the data at location _uri_ into the editor as a JSON document.
+ def load_location(uri)
+ data = read_data(uri)
+ @filename = nil
+ toplevel.display_status("Loaded data from '#{uri}'.")
+ display_title
+ data
+ end
+
+ # Read a JSON document from the file named _filename_, parse it into a
+ # ruby data structure, and return the data.
+ def read_data(filename)
+ open(filename) do |f|
+ json = f.read
+ check_pretty_printed(json)
+ if @encoding && !/^utf8$/i.match(@encoding)
+ iconverter = Iconv.new('utf8', @encoding)
+ json = iconverter.iconv(json)
+ end
+ return JSON::parse(json, :max_nesting => false)
+ end
+ rescue JSON::JSONError => e
+ Editor.error_dialog(self, "Failed to parse JSON file: #{e}!")
+ return
+ rescue SystemCallError => e
+ quit
+ end
+
+ # Open a file selecton dialog, displaying _message_, and return the
+ # selected filename or nil, if no file was selected.
+ def select_file(message)
+ filename = nil
+ fs = FileSelection.new(message).set_modal(true).
+ set_filename(Dir.pwd + "/").set_transient_for(self)
+ fs.signal_connect(:destroy) { Gtk.main_quit }
+ fs.ok_button.signal_connect(:clicked) do
+ filename = fs.filename
+ fs.destroy
+ Gtk.main_quit
+ end
+ fs.cancel_button.signal_connect(:clicked) do
+ fs.destroy
+ Gtk.main_quit
+ end
+ fs.show_all
+ Gtk.main
+ filename
+ end
+
+ # Ask for location URI a to load data from. Returns the URI as a string.
+ def ask_for_location
+ dialog = Dialog.new(
+ "Load data from location...",
+ nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+ hbox = HBox.new(false, 5)
+
+ hbox.add(Label.new("Location:"))
+ hbox.pack_start(location_input = Entry.new)
+ location_input.width_chars = 60
+ location_input.text = @location || ''
+
+ dialog.vbox.add(hbox)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ return @location = location_input.text
+ end
+ end
+ return
+ ensure
+ dialog.destroy if dialog
+ end
+ end
+
+ class << self
+ # Starts a JSON Editor. If a block was given, it yields
+ # to the JSON::Editor::MainWindow instance.
+ def start(encoding = nil) # :yield: window
+ encoding ||= 'utf8'
+ Gtk.init
+ @window = Editor::MainWindow.new(encoding)
+ @window.icon_list = [ Editor.fetch_icon('json') ]
+ yield @window if block_given?
+ @window.show_all
+ Gtk.main
+ end
+
+ attr_reader :window
+ end
+ end
+end
+ # vim: set et sw=2 ts=2:
diff --git a/lib/json/ext.rb b/lib/json/ext.rb
new file mode 100644
index 0000000..ff4fa42
--- /dev/null
+++ b/lib/json/ext.rb
@@ -0,0 +1,13 @@
+require 'json/common'
+
+module JSON
+ # This module holds all the modules/classes that implement JSON's
+ # functionality as C extensions.
+ module Ext
+ require 'json/ext/parser'
+ require 'json/ext/generator'
+ $DEBUG and warn "Using c extension for JSON."
+ JSON.parser = Parser
+ JSON.generator = Generator
+ end
+end
diff --git a/lib/json/json.xpm b/lib/json/json.xpm
new file mode 100644
index 0000000..2cb626b
--- /dev/null
+++ b/lib/json/json.xpm
@@ -0,0 +1,1499 @@
+/* XPM */
+static char * json_xpm[] = {
+"64 64 1432 2",
+" c None",
+". c #641839",
+"+ c #CF163C",
+"@ c #D31C3B",
+"# c #E11A38",
+"$ c #5F242D",
+"% c #320C22",
+"& c #9B532D",
+"* c #F32E34",
+"= c #820F33",
+"- c #4B0F34",
+"; c #8E1237",
+"> c #944029",
+", c #961325",
+"' c #A00C24",
+") c #872C23",
+"! c #694021",
+"~ c #590D1F",
+"{ c #420528",
+"] c #D85A2D",
+"^ c #7E092B",
+"/ c #0E0925",
+"( c #0D081F",
+"_ c #0F081E",
+": c #12071F",
+"< c #360620",
+"[ c #682A21",
+"} c #673F21",
+"| c #780E21",
+"1 c #A82320",
+"2 c #8D1D1F",
+"3 c #970127",
+"4 c #0D0123",
+"5 c #0D0324",
+"6 c #3B1E28",
+"7 c #C28429",
+"8 c #0C0523",
+"9 c #0C041E",
+"0 c #0E031A",
+"a c #11031A",
+"b c #13031B",
+"c c #13031C",
+"d c #11031D",
+"e c #19051E",
+"f c #390E20",
+"g c #9C0C20",
+"h c #C00721",
+"i c #980320",
+"j c #14031E",
+"k c #CD9F32",
+"l c #C29F2E",
+"m c #0F0325",
+"n c #0D0321",
+"o c #0E0324",
+"p c #D08329",
+"q c #9D1B27",
+"r c #1C0320",
+"s c #0D011A",
+"t c #120117",
+"u c #130017",
+"v c #150018",
+"w c #160119",
+"x c #17021A",
+"y c #15021B",
+"z c #11021E",
+"A c #0F021F",
+"B c #8C1821",
+"C c #CF4522",
+"D c #831821",
+"E c #BA7033",
+"F c #EDB339",
+"G c #C89733",
+"H c #280727",
+"I c #0F051F",
+"J c #0E0420",
+"K c #591F27",
+"L c #E47129",
+"M c #612224",
+"N c #0C021D",
+"O c #120018",
+"P c #140017",
+"Q c #170017",
+"R c #190018",
+"S c #1B0019",
+"T c #1B011A",
+"U c #18011B",
+"V c #15011C",
+"W c #12031E",
+"X c #460A21",
+"Y c #A13823",
+"Z c #784323",
+"` c #5A0C21",
+" . c #BC4530",
+".. c #EB5B38",
+"+. c #CE4E3B",
+"@. c #DD9334",
+"#. c #751A27",
+"$. c #11071E",
+"%. c #0F041C",
+"&. c #1E0824",
+"*. c #955A28",
+"=. c #9A5027",
+"-. c #1E0321",
+";. c #11011A",
+">. c #140018",
+",. c #180018",
+"'. c #1F001A",
+"). c #20001B",
+"!. c #1E001A",
+"~. c #1B001A",
+"{. c #16021B",
+"]. c #16041E",
+"^. c #220622",
+"/. c #5F3525",
+"(. c #DE5724",
+"_. c #611021",
+":. c #0F0925",
+"<. c #D1892E",
+"[. c #F27036",
+"}. c #EC633B",
+"|. c #DA293C",
+"1. c #E64833",
+"2. c #912226",
+"3. c #11081C",
+"4. c #110419",
+"5. c #0F041E",
+"6. c #451425",
+"7. c #BF6F28",
+"8. c #332225",
+"9. c #0E021E",
+"0. c #13001B",
+"a. c #17001A",
+"b. c #1C001B",
+"c. c #21001C",
+"d. c #23001C",
+"e. c #21001B",
+"f. c #19021A",
+"g. c #17041E",
+"h. c #150721",
+"i. c #602424",
+"j. c #D51223",
+"k. c #540820",
+"l. c #D04D2D",
+"m. c #EA8933",
+"n. c #875637",
+"o. c #88543A",
+"p. c #E5923A",
+"q. c #891931",
+"r. c #130B25",
+"s. c #10051B",
+"t. c #110217",
+"u. c #12021A",
+"v. c #761826",
+"w. c #E2A728",
+"x. c #300224",
+"y. c #10011E",
+"z. c #16001B",
+"A. c #1B001B",
+"B. c #21001A",
+"C. c #1E0019",
+"D. c #1D0019",
+"E. c #1A011A",
+"F. c #17031C",
+"G. c #120720",
+"H. c #4E0822",
+"I. c #670721",
+"J. c #C07630",
+"K. c #F59734",
+"L. c #BE1B35",
+"M. c #0E1435",
+"N. c #522037",
+"O. c #DB8039",
+"P. c #D45933",
+"Q. c #420927",
+"R. c #0F041D",
+"S. c #140118",
+"T. c #13021D",
+"U. c #100423",
+"V. c #7B6227",
+"W. c #C04326",
+"X. c #0E0020",
+"Y. c #13001D",
+"Z. c #18001B",
+"`. c #1E001B",
+" + c #22001C",
+".+ c #22001B",
+"++ c #1B011B",
+"@+ c #16041D",
+"#+ c #130520",
+"$+ c #860521",
+"%+ c #710520",
+"&+ c #670A2A",
+"*+ c #A66431",
+"=+ c #E97536",
+"-+ c #F8833A",
+";+ c #F77A3A",
+">+ c #C45337",
+",+ c #0A1C35",
+"'+ c #993638",
+")+ c #F7863B",
+"!+ c #F49736",
+"~+ c #94462B",
+"{+ c #0E031F",
+"]+ c #130119",
+"^+ c #160018",
+"/+ c #16011B",
+"(+ c #15021F",
+"_+ c #120123",
+":+ c #A65C28",
+"<+ c #5C4D23",
+"[+ c #0F001F",
+"}+ c #14001D",
+"|+ c #1A001B",
+"1+ c #1F001B",
+"2+ c #24001D",
+"3+ c #25001D",
+"4+ c #24001C",
+"5+ c #1F001C",
+"6+ c #1A011C",
+"7+ c #16021E",
+"8+ c #3F0421",
+"9+ c #BC0522",
+"0+ c #1C041E",
+"a+ c #7F5531",
+"b+ c #E68A38",
+"c+ c #F8933E",
+"d+ c #FA7942",
+"e+ c #FB7543",
+"f+ c #FA6F41",
+"g+ c #F1793D",
+"h+ c #7D3B3A",
+"i+ c #28263B",
+"j+ c #D45441",
+"k+ c #F8A238",
+"l+ c #996B2D",
+"m+ c #0E0421",
+"n+ c #12011A",
+"o+ c #180019",
+"p+ c #17001C",
+"q+ c #12001F",
+"r+ c #4C2B2A",
+"s+ c #DB8130",
+"t+ c #540023",
+"u+ c #0F0120",
+"v+ c #16011C",
+"w+ c #22001D",
+"x+ c #25001F",
+"y+ c #26001F",
+"z+ c #25001E",
+"A+ c #24001E",
+"B+ c #1D001C",
+"C+ c #18011D",
+"D+ c #16031F",
+"E+ c #3C0522",
+"F+ c #9B0821",
+"G+ c #13041E",
+"H+ c #F6462E",
+"I+ c #E6AB37",
+"J+ c #E7A03E",
+"K+ c #FA9F44",
+"L+ c #FB8A48",
+"M+ c #FD7A4A",
+"N+ c #FD794A",
+"O+ c #FD7748",
+"P+ c #FD7E45",
+"Q+ c #FD8343",
+"R+ c #FB5D42",
+"S+ c #6E3A40",
+"T+ c #EE8A37",
+"U+ c #7E252B",
+"V+ c #100520",
+"W+ c #13011A",
+"X+ c #170019",
+"Y+ c #15001C",
+"Z+ c #0F0020",
+"`+ c #564427",
+" @ c #E0BA29",
+".@ c #5E2B25",
+"+@ c #10011F",
+"@@ c #17011C",
+"#@ c #1E001D",
+"$@ c #23001F",
+"%@ c #250020",
+"&@ c #24001F",
+"*@ c #23001E",
+"=@ c #21001E",
+"-@ c #1B001C",
+";@ c #17021D",
+">@ c #14041E",
+",@ c #AC0B25",
+"'@ c #5E1420",
+")@ c #F28635",
+"!@ c #C2733E",
+"~@ c #984C44",
+"{@ c #EA9148",
+"]@ c #FB844B",
+"^@ c #FD7E4C",
+"/@ c #FE7E4C",
+"(@ c #FE7E4B",
+"_@ c #FE7749",
+":@ c #FD7148",
+"<@ c #FB7D46",
+"[@ c #F89641",
+"}@ c #B95634",
+"|@ c #0D0927",
+"1@ c #11041D",
+"2@ c #150119",
+"3@ c #180017",
+"4@ c #16001A",
+"5@ c #13001E",
+"6@ c #110023",
+"7@ c #944C29",
+"8@ c #EE6229",
+"9@ c #3D0324",
+"0@ c #12021F",
+"a@ c #19011D",
+"b@ c #21001F",
+"c@ c #22001F",
+"d@ c #20001E",
+"e@ c #1F001D",
+"f@ c #1C001C",
+"g@ c #19011C",
+"h@ c #3D1621",
+"i@ c #B53622",
+"j@ c #31061F",
+"k@ c #841D34",
+"l@ c #F2703F",
+"m@ c #C14445",
+"n@ c #E67349",
+"o@ c #FB8E4B",
+"p@ c #FD834C",
+"q@ c #FE834D",
+"r@ c #FE834C",
+"s@ c #FE804C",
+"t@ c #FD814B",
+"u@ c #FB7D49",
+"v@ c #F79B43",
+"w@ c #AF1234",
+"x@ c #0D0625",
+"y@ c #13021C",
+"z@ c #1A0019",
+"A@ c #190019",
+"B@ c #410225",
+"C@ c #D39729",
+"D@ c #AA5927",
+"E@ c #0E0422",
+"F@ c #15021E",
+"G@ c #1A011D",
+"H@ c #1D001D",
+"I@ c #15031D",
+"J@ c #240820",
+"K@ c #A01023",
+"L@ c #670B21",
+"M@ c #3D0D33",
+"N@ c #E63C3E",
+"O@ c #EF7C45",
+"P@ c #F59048",
+"Q@ c #FB944A",
+"R@ c #FD904A",
+"S@ c #FE8E4B",
+"T@ c #FE854A",
+"U@ c #FE854B",
+"V@ c #FE884C",
+"W@ c #FC954B",
+"X@ c #F8AB45",
+"Y@ c #C37A35",
+"Z@ c #0D0425",
+"`@ c #13011B",
+" # c #170018",
+".# c #1A0018",
+"+# c #1C0019",
+"@# c #15001B",
+"## c #100120",
+"$# c #311F25",
+"%# c #E68E28",
+"&# c #7A1425",
+"*# c #130321",
+"=# c #17011E",
+"-# c #1A001D",
+";# c #19001B",
+"># c #16021C",
+",# c #130521",
+"'# c #6F3123",
+")# c #6D3022",
+"!# c #C89433",
+"~# c #EA7E3E",
+"{# c #DB2943",
+"]# c #EF7745",
+"^# c #FB8544",
+"/# c #FD9A43",
+"(# c #FE9941",
+"_# c #FE9D43",
+":# c #FEA548",
+"<# c #FEAE49",
+"[# c #FCB944",
+"}# c #CA9F35",
+"|# c #0E0225",
+"1# c #11001B",
+"2# c #160019",
+"3# c #12011B",
+"4# c #0F0220",
+"5# c #351D26",
+"6# c #D85B28",
+"7# c #6C0F26",
+"8# c #190121",
+"9# c #1B001E",
+"0# c #1A001C",
+"a# c #1D001B",
+"b# c #130220",
+"c# c #703A23",
+"d# c #713A23",
+"e# c #140327",
+"f# c #411B36",
+"g# c #C8713E",
+"h# c #7A3A3F",
+"i# c #CE2C3C",
+"j# c #E77338",
+"k# c #9C6535",
+"l# c #9C6233",
+"m# c #9C6332",
+"n# c #9C6A35",
+"o# c #C37D3C",
+"p# c #FEAC41",
+"q# c #FEC23E",
+"r# c #826330",
+"s# c #100122",
+"t# c #120019",
+"u# c #150017",
+"v# c #190017",
+"w# c #1B0018",
+"x# c #12001A",
+"y# c #10021F",
+"z# c #1A0326",
+"A# c #5F292A",
+"B# c #7B4E29",
+"C# c #3C0E25",
+"D# c #1A0020",
+"E# c #14021F",
+"F# c #723B23",
+"G# c #14001A",
+"H# c #58042A",
+"I# c #A28337",
+"J# c #C8813B",
+"K# c #B14B38",
+"L# c #761231",
+"M# c #5A132A",
+"N# c #0D0726",
+"O# c #0C0623",
+"P# c #0B0723",
+"Q# c #0B0A26",
+"R# c #321C2D",
+"S# c #C45B33",
+"T# c #FEBB33",
+"U# c #13052A",
+"V# c #13011F",
+"W# c #160017",
+"X# c #15001A",
+"Y# c #12001D",
+"Z# c #94062A",
+"`# c #630D2C",
+" $ c #85292B",
+".$ c #AA5E29",
+"+$ c #1F0123",
+"@$ c #19011F",
+"#$ c #1E001C",
+"$$ c #15031F",
+"%$ c #712122",
+"&$ c #712223",
+"*$ c #14011B",
+"=$ c #110321",
+"-$ c #AF0C2B",
+";$ c #E7D534",
+">$ c #EAC934",
+",$ c #84582D",
+"'$ c #1B0824",
+")$ c #11041E",
+"!$ c #10021B",
+"~$ c #100119",
+"{$ c #100218",
+"]$ c #0F041A",
+"^$ c #0E0720",
+"/$ c #2C1026",
+"($ c #D8A328",
+"_$ c #140322",
+":$ c #160016",
+"<$ c #14001F",
+"[$ c #120024",
+"}$ c #100128",
+"|$ c #3C032F",
+"1$ c #2C062E",
+"2$ c #29022B",
+"3$ c #A31D29",
+"4$ c #976A25",
+"5$ c #1A0321",
+"6$ c #17031E",
+"7$ c #1B021D",
+"8$ c #20001C",
+"9$ c #14041F",
+"0$ c #703422",
+"a$ c #6F3522",
+"b$ c #8D0328",
+"c$ c #920329",
+"d$ c #0F0326",
+"e$ c #100321",
+"f$ c #11021B",
+"g$ c #130117",
+"h$ c #140016",
+"i$ c #150015",
+"j$ c #140015",
+"k$ c #130116",
+"l$ c #120219",
+"m$ c #11031C",
+"n$ c #12031D",
+"o$ c #170016",
+"p$ c #160020",
+"q$ c #250029",
+"r$ c #670033",
+"s$ c #DCA238",
+"t$ c #F5C736",
+"u$ c #9A732E",
+"v$ c #110227",
+"w$ c #110324",
+"x$ c #811924",
+"y$ c #A04323",
+"z$ c #250721",
+"A$ c #1A041F",
+"B$ c #1E011D",
+"C$ c #1C011C",
+"D$ c #18031D",
+"E$ c #130721",
+"F$ c #6F3623",
+"G$ c #6B3622",
+"H$ c #1A001A",
+"I$ c #14011F",
+"J$ c #12011E",
+"K$ c #11011C",
+"L$ c #140117",
+"M$ c #170015",
+"N$ c #150016",
+"O$ c #120119",
+"P$ c #11011B",
+"Q$ c #11001A",
+"R$ c #130018",
+"S$ c #170118",
+"T$ c #170119",
+"U$ c #18021E",
+"V$ c #1A0126",
+"W$ c #6F2332",
+"X$ c #E5563B",
+"Y$ c #F1B83F",
+"Z$ c #F6CC38",
+"`$ c #9D7A2D",
+" % c #130123",
+".% c #130320",
+"+% c #2A0721",
+"@% c #B00E24",
+"#% c #7D0B23",
+"$% c #1F0522",
+"%% c #1E0220",
+"&% c #1D011E",
+"*% c #1A031E",
+"=% c #15051F",
+"-% c #241322",
+";% c #A32F23",
+">% c #670E21",
+",% c #1C001A",
+"'% c #19001A",
+")% c #180016",
+"!% c #160118",
+"~% c #140219",
+"{% c #11021C",
+"]% c #10021E",
+"^% c #0F011D",
+"/% c #170117",
+"(% c #160219",
+"_% c #17041D",
+":% c #190523",
+"<% c #8C042E",
+"[% c #B65838",
+"}% c #E9D73F",
+"|% c #EED43E",
+"1% c #D85538",
+"2% c #493129",
+"3% c #130120",
+"4% c #15021D",
+"5% c #330822",
+"6% c #8A0825",
+"7% c #3C0424",
+"8% c #1E0322",
+"9% c #1C0321",
+"0% c #180421",
+"a% c #130822",
+"b% c #AF2D24",
+"c% c #BC5623",
+"d% c #2F071F",
+"e% c #1A041C",
+"f% c #1C031C",
+"g% c #1D011C",
+"h% c #160117",
+"i% c #150419",
+"j% c #12081D",
+"k% c #0F0923",
+"l% c #A77027",
+"m% c #A60525",
+"n% c #11021A",
+"o% c #130218",
+"p% c #150319",
+"q% c #16061D",
+"r% c #180923",
+"s% c #9C1D2B",
+"t% c #A32636",
+"u% c #A66E3B",
+"v% c #4B2E3C",
+"w% c #412C36",
+"x% c #36012D",
+"y% c #140123",
+"z% c #17001E",
+"A% c #19011B",
+"B% c #1A0421",
+"C% c #340425",
+"D% c #9E0326",
+"E% c #1F0424",
+"F% c #1C0524",
+"G% c #180724",
+"H% c #A91024",
+"I% c #D55D24",
+"J% c #90071E",
+"K% c #3C051D",
+"L% c #1C021C",
+"M% c #1C011A",
+"N% c #1D001A",
+"O% c #160116",
+"P% c #150216",
+"Q% c #140217",
+"R% c #140618",
+"S% c #120D1D",
+"T% c #231925",
+"U% c #B16A2E",
+"V% c #FDAC34",
+"W% c #D58631",
+"X% c #280E2A",
+"Y% c #0D0A23",
+"Z% c #0F0920",
+"`% c #120C21",
+" & c #1F1026",
+".& c #A3352E",
+"+& c #EE9F36",
+"@& c #5D2A3C",
+"#& c #960D3C",
+"$& c #970638",
+"%& c #A00330",
+"&& c #4D0126",
+"*& c #1C001F",
+"=& c #280120",
+"-& c #290223",
+";& c #1F0425",
+">& c #260726",
+",& c #340A26",
+"'& c #850925",
+")& c #3A0823",
+"!& c #82071D",
+"~& c #5E071D",
+"{& c #18051C",
+"]& c #18021A",
+"^& c #190118",
+"/& c #160217",
+"(& c #150418",
+"_& c #130618",
+":& c #110718",
+"<& c #10081A",
+"[& c #110D1D",
+"}& c #291C24",
+"|& c #A73B2D",
+"1& c #FD6B36",
+"2& c #FD853C",
+"3& c #FD863B",
+"4& c #C24A35",
+"5& c #6B442F",
+"6& c #6D302D",
+"7& c #6E252E",
+"8& c #8E3B32",
+"9& c #DE7739",
+"0& c #F48E3F",
+"a& c #DD8D41",
+"b& c #854F3D",
+"c& c #7E2D35",
+"d& c #33082B",
+"e& c #1C0222",
+"f& c #20001F",
+"g& c #1F0222",
+"h& c #1A0524",
+"i& c #440C27",
+"j& c #BC1427",
+"k& c #20041B",
+"l& c #53061C",
+"m& c #25071B",
+"n& c #11061A",
+"o& c #130418",
+"p& c #140317",
+"q& c #150217",
+"r& c #160318",
+"s& c #12051B",
+"t& c #100C1D",
+"u& c #0E101E",
+"v& c #0C121F",
+"w& c #0C1321",
+"x& c #781725",
+"y& c #B25D2C",
+"z& c #FA6335",
+"A& c #FD633C",
+"B& c #FE6D42",
+"C& c #FE7C42",
+"D& c #FE813F",
+"E& c #FE873C",
+"F& c #FD743B",
+"G& c #FB683B",
+"H& c #FA7A3E",
+"I& c #F98242",
+"J& c #F97844",
+"K& c #F98943",
+"L& c #F79C3D",
+"M& c #A25133",
+"N& c #280B28",
+"O& c #1D021F",
+"P& c #1F011C",
+"Q& c #280321",
+"R& c #1C0724",
+"S& c #3F1C27",
+"T& c #D33C27",
+"U& c #0E061B",
+"V& c #0C091C",
+"W& c #0C0A1B",
+"X& c #0E091A",
+"Y& c #11081B",
+"Z& c #100A20",
+"`& c #0E0D23",
+" * c #551227",
+".* c #B21829",
+"+* c #C42329",
+"@* c #C62C29",
+"#* c #C55429",
+"$* c #E76F2B",
+"%* c #F14232",
+"&* c #F95E3A",
+"** c #FC6740",
+"=* c #FE6E45",
+"-* c #FE7246",
+";* c #FE7545",
+">* c #FE7744",
+",* c #FD7745",
+"'* c #FD7845",
+")* c #FD7847",
+"!* c #FD7948",
+"~* c #FD7B44",
+"{* c #FC7C3B",
+"]* c #6F3130",
+"^* c #140B24",
+"/* c #19031D",
+"(* c #1C011B",
+"_* c #5A011F",
+":* c #B70421",
+"<* c #380824",
+"[* c #3E2626",
+"}* c #9F5626",
+"|* c #13051E",
+"1* c #360A21",
+"2* c #361223",
+"3* c #371724",
+"4* c #381824",
+"5* c #3B1524",
+"6* c #3E1E26",
+"7* c #471A29",
+"8* c #DB252E",
+"9* c #ED2733",
+"0* c #EE5436",
+"a* c #F04237",
+"b* c #F33934",
+"c* c #F53D2F",
+"d* c #D7312B",
+"e* c #AF212B",
+"f* c #3A2C31",
+"g* c #F65F39",
+"h* c #FB6F41",
+"i* c #FD6D45",
+"j* c #FE7047",
+"k* c #FE7647",
+"l* c #FE7847",
+"m* c #FE7848",
+"n* c #FE7748",
+"o* c #FE7948",
+"p* c #FE7C48",
+"q* c #FE7C47",
+"r* c #FE7642",
+"s* c #FE7439",
+"t* c #6D332C",
+"u* c #100B21",
+"v* c #16031B",
+"w* c #2B001B",
+"x* c #22011F",
+"y* c #220521",
+"z* c #1B0A23",
+"A* c #421425",
+"B* c #951924",
+"C* c #381023",
+"D* c #E94028",
+"E* c #E7302B",
+"F* c #EF432D",
+"G* c #F4302E",
+"H* c #F32C30",
+"I* c #CB4432",
+"J* c #DD3235",
+"K* c #EF4B3A",
+"L* c #F0333E",
+"M* c #CC3D3F",
+"N* c #E4313C",
+"O* c #F34834",
+"P* c #D13E2C",
+"Q* c #431825",
+"R* c #0E1424",
+"S* c #3C202C",
+"T* c #F15537",
+"U* c #F97140",
+"V* c #FC6E45",
+"W* c #FE7547",
+"X* c #FE7947",
+"Y* c #FE7B48",
+"Z* c #FE7D48",
+"`* c #FE8047",
+" = c #FE7A42",
+".= c #FE7A38",
+"+= c #6D442B",
+"@= c #0F0B21",
+"#= c #15031A",
+"$= c #49001B",
+"%= c #2F001C",
+"&= c #21021E",
+"*= c #220620",
+"== c #1B0D23",
+"-= c #641625",
+";= c #951823",
+">= c #390F25",
+",= c #AC3A2A",
+"'= c #B6492E",
+")= c #ED7531",
+"!= c #F45A34",
+"~= c #F54C36",
+"{= c #C72D39",
+"]= c #DE283C",
+"^= c #F33B40",
+"/= c #F34142",
+"(= c #D0393F",
+"_= c #E72E39",
+":= c #DB3C2E",
+"<= c #461724",
+"[= c #0F0D1E",
+"}= c #140B1E",
+"|= c #341427",
+"1= c #CB4834",
+"2= c #F7743F",
+"3= c #FB7145",
+"4= c #FE7747",
+"5= c #FE7A47",
+"6= c #FF7B48",
+"7= c #FF7C48",
+"8= c #FE7F47",
+"9= c #FE8247",
+"0= c #FE8642",
+"a= c #FE8439",
+"b= c #6D442D",
+"c= c #0F0A21",
+"d= c #14031A",
+"e= c #20031D",
+"f= c #210821",
+"g= c #191024",
+"h= c #CC1C25",
+"i= c #961423",
+"j= c #2C162C",
+"k= c #BD242E",
+"l= c #EF2C31",
+"m= c #F54C34",
+"n= c #F34037",
+"o= c #F5353A",
+"p= c #F7413D",
+"q= c #F8423D",
+"r= c #F93A39",
+"s= c #F95731",
+"t= c #341425",
+"u= c #110A1D",
+"v= c #140619",
+"w= c #18051B",
+"x= c #200F26",
+"y= c #864833",
+"z= c #F8773F",
+"A= c #FC7445",
+"B= c #FF7E48",
+"C= c #FF7E49",
+"D= c #FF7D49",
+"E= c #FF7D48",
+"F= c #FE8347",
+"G= c #FE8743",
+"H= c #FE893B",
+"I= c #6E452F",
+"J= c #100E23",
+"K= c #14041A",
+"L= c #55041D",
+"M= c #540921",
+"N= c #161124",
+"O= c #CE6A25",
+"P= c #3F1129",
+"Q= c #170A29",
+"R= c #0F0F29",
+"S= c #15132B",
+"T= c #1E182D",
+"U= c #A82B3D",
+"V= c #CB6633",
+"W= c #CC6932",
+"X= c #CC3D2D",
+"Y= c #331225",
+"Z= c #0F091C",
+"`= c #120417",
+" - c #160216",
+".- c #190419",
+"+- c #210F26",
+"@- c #8C4934",
+"#- c #F97A40",
+"$- c #FC7545",
+"%- c #FF7B49",
+"&- c #FE7D46",
+"*- c #FE7E43",
+"=- c #FD7B3E",
+"-- c #FA6934",
+";- c #532328",
+">- c #130B1D",
+",- c #150519",
+"'- c #14041C",
+")- c #120920",
+"!- c #C43624",
+"~- c #A21E23",
+"{- c #F87C30",
+"]- c #C9302D",
+"^- c #300F2A",
+"/- c #591129",
+"(- c #171328",
+"_- c #171628",
+":- c #141829",
+"<- c #101A2B",
+"[- c #0F172B",
+"}- c #0F1226",
+"|- c #0E0C20",
+"1- c #100619",
+"2- c #140316",
+"3- c #19051B",
+"4- c #3C1428",
+"5- c #E04B36",
+"6- c #FA7B41",
+"7- c #FD7346",
+"8- c #FE7548",
+"9- c #FF7849",
+"0- c #FF7749",
+"a- c #FE7B47",
+"b- c #FE7945",
+"c- c #FC7740",
+"d- c #FA7E39",
+"e- c #C1432F",
+"f- c #131523",
+"g- c #130A1C",
+"h- c #420621",
+"i- c #D08423",
+"j- c #F87739",
+"k- c #C03D37",
+"l- c #962B34",
+"m- c #A14332",
+"n- c #E54B30",
+"o- c #9E3E2F",
+"p- c #7F262E",
+"q- c #922D2E",
+"r- c #9C4B2E",
+"s- c #65212C",
+"t- c #101628",
+"u- c #101022",
+"v- c #11091C",
+"w- c #130619",
+"x- c #160A1E",
+"y- c #43252C",
+"z- c #F66439",
+"A- c #FA6942",
+"B- c #FD6C47",
+"C- c #FE6E48",
+"D- c #FE6F48",
+"E- c #FE7049",
+"F- c #FE714A",
+"G- c #FE744A",
+"H- c #FE7846",
+"I- c #FD7243",
+"J- c #FC703E",
+"K- c #FA6C37",
+"L- c #81312B",
+"M- c #121123",
+"N- c #15071D",
+"O- c #16031A",
+"P- c #17021B",
+"Q- c #8F3D22",
+"R- c #F8393E",
+"S- c #E42A3D",
+"T- c #E7473B",
+"U- c #FB503B",
+"V- c #FB4F3A",
+"W- c #F95439",
+"X- c #ED4C38",
+"Y- c #F45938",
+"Z- c #FB6537",
+"`- c #EA5236",
+" ; c #CE6232",
+".; c #CD392C",
+"+; c #181425",
+"@; c #120F21",
+"#; c #130D20",
+"$; c #151225",
+"%; c #903431",
+"&; c #F8703D",
+"*; c #FB6344",
+"=; c #FD6748",
+"-; c #FE6849",
+";; c #FE6949",
+">; c #FE6A49",
+",; c #FE6C4A",
+"'; c #FE704A",
+"); c #FE734A",
+"!; c #FE7449",
+"~; c #FE7347",
+"{; c #FE7145",
+"]; c #FD6C42",
+"^; c #FD753D",
+"/; c #F36E35",
+"(; c #CB452C",
+"_; c #600D24",
+":; c #1C061F",
+"<; c #1E031F",
+"[; c #5B3821",
+"}; c #CE9822",
+"|; c #FA4341",
+"1; c #FB4341",
+"2; c #FC4541",
+"3; c #FC4542",
+"4; c #FC4143",
+"5; c #FC4D42",
+"6; c #FB5042",
+"7; c #FB5342",
+"8; c #FC5242",
+"9; c #FD4F40",
+"0; c #FD503E",
+"a; c #FB6339",
+"b; c #F45E33",
+"c; c #A12A2E",
+"d; c #401E2C",
+"e; c #452D2F",
+"f; c #F74F38",
+"g; c #FA5940",
+"h; c #FC6245",
+"i; c #FE6447",
+"j; c #FE6449",
+"k; c #FE6549",
+"l; c #FE6749",
+"m; c #FE6B49",
+"n; c #FE6D49",
+"o; c #FE6D48",
+"p; c #FE6D47",
+"q; c #FE6D45",
+"r; c #FE6C44",
+"s; c #FE6A42",
+"t; c #FE663C",
+"u; c #FC6233",
+"v; c #752129",
+"w; c #1F0922",
+"x; c #750520",
+"y; c #81061F",
+"z; c #FA3D42",
+"A; c #FB4142",
+"B; c #FD4543",
+"C; c #FD4844",
+"D; c #FD4A45",
+"E; c #FD4D45",
+"F; c #FD5045",
+"G; c #FD5345",
+"H; c #FE5346",
+"I; c #FE5445",
+"J; c #FD5444",
+"K; c #FC4F41",
+"L; c #FA513D",
+"M; c #F95339",
+"N; c #F63736",
+"O; c #F75737",
+"P; c #F95F3B",
+"Q; c #FB5840",
+"R; c #FD5F43",
+"S; c #FE6345",
+"T; c #FE6547",
+"U; c #FE6548",
+"V; c #FE6448",
+"W; c #FE6248",
+"X; c #FE6348",
+"Y; c #FE6748",
+"Z; c #FE6848",
+"`; c #FE6846",
+" > c #FE6A45",
+".> c #FE6D43",
+"+> c #FE703F",
+"@> c #FC6F36",
+"#> c #6F302B",
+"$> c #140A22",
+"%> c #FA3B42",
+"&> c #FC4243",
+"*> c #FD4744",
+"=> c #FE4A45",
+"-> c #FE4C47",
+";> c #FE4D47",
+">> c #FE5047",
+",> c #FE5347",
+"'> c #FE5447",
+")> c #FD5246",
+"!> c #FB503F",
+"~> c #FA543D",
+"{> c #9B3D3B",
+"]> c #A3433B",
+"^> c #F9683D",
+"/> c #FC6940",
+"(> c #FE6342",
+"_> c #FE6645",
+":> c #FE6646",
+"<> c #FE6147",
+"[> c #FE6048",
+"}> c #FE6148",
+"|> c #FE6746",
+"1> c #FE6A46",
+"2> c #FE6F45",
+"3> c #FE7441",
+"4> c #FC7D39",
+"5> c #6C422E",
+"6> c #0F0F23",
+"7> c #FA4142",
+"8> c #FC4643",
+"9> c #FE4D46",
+"0> c #FE4E47",
+"a> c #FE4F48",
+"b> c #FE5148",
+"c> c #FE5348",
+"d> c #FE5548",
+"e> c #FE5247",
+"f> c #FD5445",
+"g> c #FC5544",
+"h> c #F96041",
+"i> c #D33F3D",
+"j> c #392D39",
+"k> c #973C38",
+"l> c #F94E3A",
+"m> c #FD693E",
+"n> c #FE6C43",
+"o> c #FE6047",
+"p> c #FE5D47",
+"q> c #FE5E48",
+"r> c #FE6948",
+"s> c #FE6947",
+"t> c #FE6B47",
+"u> c #FE6E46",
+"v> c #FD6D43",
+"w> c #FB723D",
+"x> c #D54A33",
+"y> c #301C29",
+"z> c #FB4A42",
+"A> c #FD4B44",
+"B> c #FE4F47",
+"C> c #FE5048",
+"D> c #FE5648",
+"E> c #FE5848",
+"F> c #FE5747",
+"G> c #FE5547",
+"H> c #FC5945",
+"I> c #F95742",
+"J> c #F3543D",
+"K> c #A33336",
+"L> c #302032",
+"M> c #152433",
+"N> c #CD3E38",
+"O> c #FD5A3F",
+"P> c #FE6343",
+"Q> c #FE6446",
+"R> c #FE6247",
+"S> c #FE6A47",
+"T> c #FC6542",
+"U> c #FB6A3B",
+"V> c #FA6D34",
+"W> c #D73C2D",
+"X> c #442428",
+"Y> c #281323",
+"Z> c #FD4E42",
+"`> c #FD4D43",
+" , c #FE4D45",
+"., c #FE5248",
+"+, c #FE5947",
+"@, c #FE5C47",
+"#, c #FE5B47",
+"$, c #FE5A47",
+"%, c #FE5847",
+"&, c #FC5C45",
+"*, c #F95B43",
+"=, c #F3613F",
+"-, c #E74F37",
+";, c #8C2431",
+">, c #161E2F",
+",, c #CD4E33",
+"', c #FD503A",
+"), c #FE5D40",
+"!, c #FE6445",
+"~, c #FE6946",
+"{, c #FE6847",
+"], c #FE6747",
+"^, c #FD6644",
+"/, c #FD6241",
+"(, c #FD5B3D",
+"_, c #FE6739",
+":, c #FE6135",
+"<, c #AB4830",
+"[, c #733E2A",
+"}, c #161224",
+"|, c #FC4E42",
+"1, c #FE4D44",
+"2, c #FE4E46",
+"3, c #FE5147",
+"4, c #FE5E47",
+"5, c #FD5C46",
+"6, c #FA5B44",
+"7, c #F45441",
+"8, c #EB393A",
+"9, c #CC3433",
+"0, c #47212F",
+"a, c #59242F",
+"b, c #FC6734",
+"c, c #FC6F3A",
+"d, c #FC723E",
+"e, c #FD6540",
+"f, c #FE6442",
+"g, c #FE6643",
+"h, c #FE6944",
+"i, c #FE6546",
+"j, c #FE6444",
+"k, c #FE6143",
+"l, c #FE5E41",
+"m, c #FE613F",
+"n, c #FE683C",
+"o, c #FE7937",
+"p, c #A25030",
+"q, c #692629",
+"r, c #151122",
+"s, c #FA573F",
+"t, c #FB4D40",
+"u, c #FC4F43",
+"v, c #FE5246",
+"w, c #FF6347",
+"x, c #FE5F48",
+"y, c #F65942",
+"z, c #F0493D",
+"A, c #ED3736",
+"B, c #73262F",
+"C, c #10152C",
+"D, c #3B292F",
+"E, c #363034",
+"F, c #AC3938",
+"G, c #FC6B3B",
+"H, c #FD763C",
+"I, c #FE6D3F",
+"J, c #FE6341",
+"K, c #FE6642",
+"L, c #FE6745",
+"M, c #FE6245",
+"N, c #FE6244",
+"O, c #FE6841",
+"P, c #FF683B",
+"Q, c #EC7035",
+"R, c #D0412D",
+"S, c #3A1627",
+"T, c #CF3938",
+"U, c #F6543C",
+"V, c #FB5040",
+"W, c #FD5544",
+"X, c #FE5A48",
+"Y, c #FE5D48",
+"Z, c #FE5F47",
+"`, c #FF6147",
+" ' c #FD5C45",
+".' c #FB5B43",
+"+' c #FA5A42",
+"@' c #F76040",
+"#' c #F4623D",
+"$' c #F26D38",
+"%' c #EC4130",
+"&' c #380E2B",
+"*' c #13122C",
+"=' c #362D31",
+"-' c #353435",
+";' c #352E37",
+">' c #2D3337",
+",' c #CC5838",
+"'' c #CD6F3A",
+")' c #CE6E3D",
+"!' c #FE793F",
+"~' c #FD7541",
+"{' c #FD6243",
+"]' c #FE6545",
+"^' c #FF6543",
+"/' c #FF6240",
+"(' c #FE723B",
+"_' c #FE8034",
+":' c #442D2C",
+"<' c #311725",
+"[' c #222830",
+"}' c #B73B36",
+"|' c #F94C3D",
+"1' c #FD5543",
+"2' c #FE5B48",
+"3' c #FF5E47",
+"4' c #FE5C48",
+"5' c #FC5B44",
+"6' c #F95640",
+"7' c #C34E3D",
+"8' c #A45A3A",
+"9' c #F37438",
+"0' c #F28935",
+"a' c #AF422F",
+"b' c #240D2B",
+"c' c #88292F",
+"d' c #FA8E34",
+"e' c #FC7E38",
+"f' c #FC5939",
+"g' c #694A37",
+"h' c #693437",
+"i' c #382638",
+"j' c #142439",
+"k' c #9F483A",
+"l' c #C45E3C",
+"m' c #FD7240",
+"n' c #FF6645",
+"o' c #FF6245",
+"p' c #FF6045",
+"q' c #FF6146",
+"r' c #FF6246",
+"s' c #FF6446",
+"t' c #FF6545",
+"u' c #FE763F",
+"v' c #FE7237",
+"w' c #C65331",
+"x' c #3D272A",
+"y' c #0D1E2B",
+"z' c #683032",
+"A' c #F9453A",
+"B' c #FD5341",
+"C' c #FE5A46",
+"D' c #FF5A48",
+"E' c #FE5948",
+"F' c #FD5A47",
+"G' c #FC5D43",
+"H' c #F95B3D",
+"I' c #713F37",
+"J' c #1E2D32",
+"K' c #C44531",
+"L' c #EF7A2F",
+"M' c #6B2E2C",
+"N' c #0F0E2C",
+"O' c #F56633",
+"P' c #FA803A",
+"Q' c #FC673E",
+"R' c #FD673E",
+"S' c #FC6F3C",
+"T' c #FA6E3B",
+"U' c #C6633A",
+"V' c #A06739",
+"W' c #835638",
+"X' c #381F38",
+"Y' c #713B38",
+"Z' c #7B503C",
+"`' c #FE7741",
+" ) c #FE7344",
+".) c #FE6D46",
+"+) c #FF6946",
+"@) c #FF5E46",
+"#) c #FF5D46",
+"$) c #FF5D47",
+"%) c #FF5F48",
+"&) c #FF6248",
+"*) c #FE6941",
+"=) c #FC783C",
+"-) c #C46B35",
+";) c #892730",
+">) c #111629",
+",) c #1F2630",
+"') c #AD3939",
+")) c #FC5D41",
+"!) c #FE5946",
+"~) c #FF5848",
+"{) c #FE5549",
+"]) c #FC5E42",
+"^) c #FA673B",
+"/) c #DB7033",
+"() c #392E2B",
+"_) c #311A28",
+":) c #3C2127",
+"<) c #1D1027",
+"[) c #92102C",
+"}) c #F58336",
+"|) c #FA673E",
+"1) c #FD6642",
+"2) c #FD5A41",
+"3) c #FC6D41",
+"4) c #FC6D3F",
+"5) c #FD683E",
+"6) c #F38C39",
+"7) c #CE6535",
+"8) c #612E34",
+"9) c #1D2637",
+"0) c #71513E",
+"a) c #FF6847",
+"b) c #FF5F47",
+"c) c #FF5A46",
+"d) c #FF5847",
+"e) c #FF5748",
+"f) c #FF594A",
+"g) c #FF5E4B",
+"h) c #FE654C",
+"i) c #FE694B",
+"j) c #FE6B48",
+"k) c #FC6A43",
+"l) c #F7683E",
+"m) c #EC6E39",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" . + @ # $ % ",
+" & * = - ; > , ' ) ! ~ ",
+" { ] ^ / ( _ : < [ } | 1 2 ",
+" 3 4 5 6 7 8 9 0 a b c d e f g h i j ",
+" k l m n o p q r s t u v w x y z A B C D ",
+" E F G H I J K L M N O P Q R S T U V W X Y Z ` ",
+" ...+.@.#.$.%.&.*.=.-.;.>.,.S '.).!.~.{.].^./.(._. ",
+" :.<.[.}.|.1.2.3.4.5.6.7.8.9.0.a.b.c.d.e.!.S f.g.h.i.j.k. ",
+" l.m.n.o.p.q.r.s.t.u.J v.w.x.y.z.A.c.d.d.B.C.D.E.F.G.H.I. ",
+" J.K.L.M.N.O.P.Q.R.t S.T.U.V.W.X.Y.Z.`. +d.d..+B.'.++@+#+$+%+ ",
+" &+*+=+-+;+>+,+'+)+!+~+{+]+^+/+(+_+:+<+[+}+|+1+d.2+3+4+d.5+6+7+8+9+0+ ",
+" a+b+c+d+e+f+g+h+i+j+k+l+m+n+^+o+p+q+r+s+t+u+v+b.w+x+y+z+A+w+B+C+D+E+F+G+ ",
+" H+I+J+K+L+M+N+O+P+Q+R+S+T+U+V+W+Q ,.X+Y+Z+`+ @.@+@@@#@$@%@&@*@=@#@-@;@>@,@'@ ",
+" )@!@~@{@]@^@/@(@_@:@<@[@}@|@1@2@3@R ,.4@5@6@7@8@9@0@a@#@b@c@=@d@e@f@g@>@h@i@j@ ",
+" k@l@m@n@o@p@q@r@s@t@u@v@w@x@y@^+R S z@A@z.q+B@C@D@E@F@G@H@#@e@#@#@f@g@I@J@K@L@ ",
+" M@N@O@P@Q@R@S@T@U@V@W@X@Y@Z@`@ #.#+#+#S A@@###$#%#&#*#=#-#f@B+B+B+f@;#>#,#'#)# ",
+" !#~#{#]#^#/#(#(#_#:#<#[#}#|#1#^+.#S +#+#z@2#3#4#5#6#7#8#9#0#A.B+B+a#A.@@b#c#d# ",
+" e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#.#w#S R ^+x#y#z#A#B#C#D#-#A.a#`.`.b.g@E#d#F# ",
+" G#0@H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#>.W#3@v#R R X+X#Y#s#Z#`# $.$+$@$g@f@5+5+#$6+$$%$&$ ",
+" *$=$-$;$>$,$'$)$!$~${$]$^$/$($_$*$u#:$Q 3@,.X+z.<$[$}$|$1$2$3$4$5$6$7$e@8$#$G@9$0$a$ ",
+" ,.4@E#b$c$d$e$f$g$h$i$j$k$l$m$n$`@>.:$o$3@,. #a.p$q$r$s$t$u$v$w$x$y$z$A$B$#@C$D$E$F$G$ ",
+" R S H$v+I$J$K$n+L$:$o$o$M$N$L$O$P$Q$R$N$o$3@S$T$U$V$W$X$Y$Z$`$ %.%+%@%#%$%%%&%*%=%-%;%>% ",
+" E.,%~.'%Z.4@v W#o$)%)%)%Q !%~%{%]%^%Q$u u#/%(%_%:%<%[%}%|%1%2%3%4%=%5%6%7%8%9%0%a%b%c%d% ",
+" e%f%g%a#,%,%z@R 3@3@3@)%Q h%i%j%k%l%m%{+n%o%p%q%r%s%t%u%v%w%x%y%z%A%*%B%C%D%E%F%G%H%I% ",
+" J%K%L%M%N%D.S v#)%)%O%P%Q%R%S%T%U%V%W%X%Y%Z%`% &.&+&@&#&$&%&&&*&f@a##@=&-&;&>&,&'&)& ",
+" !&~&{&]&^&.#w#^&/%/&(&_&:&<&[&}&|&1&2&3&4&5&6&7&8&9&0&a&b&c&d&e&e@1+5+e@f&g&h&i&j& ",
+" k&l&m&n&o&p&q&r&i%s&3.t&u&v&w&x&y&z&A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&1+`.e@f&Q&R&S&T& ",
+" 0 U&V&W&X&<&Y&j%Z&`& *.*+*@*#*$*%*&***=*-*;*>*>*,*'*)*!*~*{*]*^*/*(*a#B+#@_*:*<*[*}* ",
+" |*1*2*3*4*5*6*7*8*9*0*a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*E.w*d.e@x*y*z*A*B* ",
+" C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V*W*l*X*o*o*Y*Z*`* =.=+=@=#='%$=%=e@&=*===-=;= ",
+" >=,='=)=!=~={=]=^=/=(=_=:=<=[=}=|=1=2=3=4=5=p*6=6=7=8=9=0=a=b=c=d=A@~.b.B+e=f=g=h=i= ",
+" j=k=l=m=n=o=p=q=r=s=t=u=v=w=x=y=z=A=5=Z*B=C=D=E=8=F=G=H=I=J=K=S$R z@'%L=M=N=O= ",
+" P=Q=R=S=T=U=V=W=X=Y=Z=`= -.-+-@-#-$-5=p*E=D=%-%-q*&-*-=---;->-,-/%3@^+'-)-!-~- ",
+" {-]-^-/-(-_-:-<-[-}-|-1-2- -3-4-5-6-7-8-n*m*9-0-9-o*a-b-c-d-e-f-g-(&h%w c h-i- ",
+" j-k-l-m-n-o-p-q-r-s-t-u-v-w-,-x-y-z-A-B-C-D-E-E-F-G-_@m*H-I-J-K-L-M-N-O-P-(+Q- ",
+" R-S-T-U-V-W-X-Y-Z-`- ;.;+;@;#;$;%;&;*;=;-;-;;;>;,;';);!;~;{;];^;/;(;_;:;<;[;}; ",
+" |;1;2;3;4;5;6;7;8;9;0;a;b;c;d;e;f;g;h;i;j;j;k;k;l;m;n;o;p;q;r;s;t;u;v;w;x;y; ",
+" z;A;B;C;D;E;F;G;H;I;J;K;L;M;N;O;P;Q;R;S;T;U;V;W;X;k;Y;Z;`; >r;.>+>@>#>$> ",
+" %>&>*>=>->;>>>,>'>,>)>F;8;!>~>{>]>^>/>(>_>:>i;<>[>X;}>i;|>1>q;2>3>4>5>6> ",
+" 7>8>=>9>0>a>b>c>d>,>e>e>f>g>h>i>j>k>l>m>n>:>i;o>p>q>W;r>s>t>p;u>v>w>x>y> ",
+" z>A>9>0>B>C>c>D>E>F>G>G>F>H>I>J>K>L>M>N>O>P>Q>R>o>R>T;s>S>S>S>t>1>T>U>V>W>X>Y> ",
+" Z>`> ,9>B>.,D>+,@,#,$,%,$,&,*,=,-,;,>,,,',),P>!,!,_>~,t>s>{,],{,],^,/,(,_,:,<,[,}, ",
+" |,`>1,2,3,G>+,4,o>o>4,@,@,5,6,7,8,9,0,a,b,c,d,e,f,g,h, >~,|>T;T;T;i,j,k,l,m,n,o,p,q,r, ",
+" s,t,u,v,G>%,@,o>w,R>x,p>@,5,6,y,z,A,B,C,D,E,F,G,H,I,J,K,L,L,i,i;i;i;Q>S;M,N,P>O,P,Q,R,S, ",
+" T,U,V,W,%,X,Y,Z,`,[>q>@, '.'+'@'#'$'%'&'*'='-';'>',''')'!'~'{'N,i,:>_>]'M,M,Q>_>^'/'('_':'<' ",
+" ['}'|'1'$,X,2'p>3'4'2'@,5'6'7'8'9'0'a'b'c'd'e'f'g'h'i'j'k'l'd,m'g, > >n'o'p'q'r's't'.>u'v'w'x' ",
+" y'z'A'B'C'X,X,2'D'E'E'F'G'H'I'J'K'L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'`' ).)+)r'@)#)$)%)&)l;1>*)=)-);) ",
+" >),)')))!)X,E'X,~){)d>!)])^)/)()_):)<)[)})|)1)f,2)3)4)5)6)7)8)9)0)*--*a)b)c)d)e)f)g)h)i)j)k)l)m) ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" "};
diff --git a/lib/json/pure.rb b/lib/json/pure.rb
new file mode 100644
index 0000000..b86d905
--- /dev/null
+++ b/lib/json/pure.rb
@@ -0,0 +1,75 @@
+require 'json/common'
+require 'json/pure/parser'
+require 'json/pure/generator'
+
+module JSON
+ begin
+ require 'iconv'
+ # An iconv instance to convert from UTF8 to UTF16 Big Endian.
+ UTF16toUTF8 = Iconv.new('utf-8', 'utf-16be') # :nodoc:
+ # An iconv instance to convert from UTF16 Big Endian to UTF8.
+ UTF8toUTF16 = Iconv.new('utf-16be', 'utf-8') # :nodoc:
+ UTF8toUTF16.iconv('no bom')
+ rescue Errno::EINVAL, Iconv::InvalidEncoding
+ # Iconv doesn't support big endian utf-16. Let's try to hack this manually
+ # into the converters.
+ begin
+ old_verbose, $VERBSOSE = $VERBOSE, nil
+ # An iconv instance to convert from UTF8 to UTF16 Big Endian.
+ UTF16toUTF8 = Iconv.new('utf-8', 'utf-16') # :nodoc:
+ # An iconv instance to convert from UTF16 Big Endian to UTF8.
+ UTF8toUTF16 = Iconv.new('utf-16', 'utf-8') # :nodoc:
+ UTF8toUTF16.iconv('no bom')
+ if UTF8toUTF16.iconv("\xe2\x82\xac") == "\xac\x20"
+ swapper = Class.new do
+ def initialize(iconv) # :nodoc:
+ @iconv = iconv
+ end
+
+ def iconv(string) # :nodoc:
+ result = @iconv.iconv(string)
+ JSON.swap!(result)
+ end
+ end
+ UTF8toUTF16 = swapper.new(UTF8toUTF16) # :nodoc:
+ end
+ if UTF16toUTF8.iconv("\xac\x20") == "\xe2\x82\xac"
+ swapper = Class.new do
+ def initialize(iconv) # :nodoc:
+ @iconv = iconv
+ end
+
+ def iconv(string) # :nodoc:
+ string = JSON.swap!(string.dup)
+ @iconv.iconv(string)
+ end
+ end
+ UTF16toUTF8 = swapper.new(UTF16toUTF8) # :nodoc:
+ end
+ rescue Errno::EINVAL, Iconv::InvalidEncoding
+ raise MissingUnicodeSupport, "iconv doesn't seem to support UTF-8/UTF-16 conversions"
+ ensure
+ $VERBOSE = old_verbose
+ end
+ rescue LoadError
+ raise MissingUnicodeSupport,
+ "iconv couldn't be loaded, which is required for UTF-8/UTF-16 conversions"
+ end
+
+ # Swap consecutive bytes of _string_ in place.
+ def self.swap!(string) # :nodoc:
+ 0.upto(string.size / 2) do |i|
+ break unless string[2 * i + 1]
+ string[2 * i], string[2 * i + 1] = string[2 * i + 1], string[2 * i]
+ end
+ string
+ end
+
+ # This module holds all the modules/classes that implement JSON's
+ # functionality in pure ruby.
+ module Pure
+ $DEBUG and warn "Using pure library for JSON."
+ JSON.parser = Parser
+ JSON.generator = Generator
+ end
+end
diff --git a/lib/json/pure/generator.rb b/lib/json/pure/generator.rb
new file mode 100644
index 0000000..498d78a
--- /dev/null
+++ b/lib/json/pure/generator.rb
@@ -0,0 +1,321 @@
+module JSON
+ MAP = {
+ "\x0" => '\u0000',
+ "\x1" => '\u0001',
+ "\x2" => '\u0002',
+ "\x3" => '\u0003',
+ "\x4" => '\u0004',
+ "\x5" => '\u0005',
+ "\x6" => '\u0006',
+ "\x7" => '\u0007',
+ "\b" => '\b',
+ "\t" => '\t',
+ "\n" => '\n',
+ "\xb" => '\u000b',
+ "\f" => '\f',
+ "\r" => '\r',
+ "\xe" => '\u000e',
+ "\xf" => '\u000f',
+ "\x10" => '\u0010',
+ "\x11" => '\u0011',
+ "\x12" => '\u0012',
+ "\x13" => '\u0013',
+ "\x14" => '\u0014',
+ "\x15" => '\u0015',
+ "\x16" => '\u0016',
+ "\x17" => '\u0017',
+ "\x18" => '\u0018',
+ "\x19" => '\u0019',
+ "\x1a" => '\u001a',
+ "\x1b" => '\u001b',
+ "\x1c" => '\u001c',
+ "\x1d" => '\u001d',
+ "\x1e" => '\u001e',
+ "\x1f" => '\u001f',
+ '"' => '\"',
+ '\\' => '\\\\',
+ '/' => '\/',
+ } # :nodoc:
+
+ # Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
+ # UTF16 big endian characters as \u????, and return it.
+ def utf8_to_json(string) # :nodoc:
+ string = string.gsub(/["\\\/\x0-\x1f]/) { |c| MAP[c] }
+ string.gsub!(/(
+ (?:
+ [\xc2-\xdf][\x80-\xbf] |
+ [\xe0-\xef][\x80-\xbf]{2} |
+ [\xf0-\xf4][\x80-\xbf]{3}
+ )+ |
+ [\x80-\xc1\xf5-\xff] # invalid
+ )/nx) { |c|
+ c.size == 1 and raise GeneratorError, "invalid utf8 byte: '#{c}'"
+ s = JSON::UTF8toUTF16.iconv(c).unpack('H*')[0]
+ s.gsub!(/.{4}/n, '\\\\u\&')
+ }
+ string
+ rescue Iconv::Failure => e
+ raise GeneratorError, "Caught #{e.class}: #{e}"
+ end
+ module_function :utf8_to_json
+
+ module Pure
+ module Generator
+ # This class is used to create State instances, that are use to hold data
+ # while generating a JSON text from a a Ruby data structure.
+ class State
+ # Creates a State object from _opts_, which ought to be Hash to create
+ # a new State instance configured by _opts_, something else to create
+ # an unconfigured instance. If _opts_ is a State object, it is just
+ # returned.
+ def self.from_state(opts)
+ case opts
+ when self
+ opts
+ when Hash
+ new(opts)
+ else
+ new
+ end
+ end
+
+ # Instantiates a new State object, configured by _opts_.
+ #
+ # _opts_ can have the following keys:
+ #
+ # * *indent*: a string used to indent levels (default: ''),
+ # * *space*: a string that is put after, a : or , delimiter (default: ''),
+ # * *space_before*: a string that is put before a : pair delimiter (default: ''),
+ # * *object_nl*: a string that is put at the end of a JSON object (default: ''),
+ # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
+ # * *check_circular*: true if checking for circular data structures
+ # should be done, false (the default) otherwise.
+ def initialize(opts = {})
+ @indent = opts[:indent] || ''
+ @space = opts[:space] || ''
+ @space_before = opts[:space_before] || ''
+ @object_nl = opts[:object_nl] || ''
+ @array_nl = opts[:array_nl] || ''
+ @check_circular = !!(opts[:check_circular] || false)
+ @seen = {}
+ end
+
+ # This string is used to indent levels in the JSON text.
+ attr_accessor :indent
+
+ # This string is used to insert a space between the tokens in a JSON
+ # string.
+ attr_accessor :space
+
+ # This string is used to insert a space before the ':' in JSON objects.
+ attr_accessor :space_before
+
+ # This string is put at the end of a line that holds a JSON object (or
+ # Hash).
+ attr_accessor :object_nl
+
+ # This string is put at the end of a line that holds a JSON array.
+ attr_accessor :array_nl
+
+ # Returns true, if circular data structures should be checked,
+ # otherwise returns false.
+ def check_circular?
+ @check_circular
+ end
+
+ # Returns _true_, if _object_ was already seen during this generating
+ # run.
+ def seen?(object)
+ @seen.key?(object.__id__)
+ end
+
+ # Remember _object_, to find out if it was already encountered (if a
+ # cyclic data structure is if a cyclic data structure is rendered).
+ def remember(object)
+ @seen[object.__id__] = true
+ end
+
+ # Forget _object_ for this generating run.
+ def forget(object)
+ @seen.delete object.__id__
+ end
+ end
+
+ module GeneratorMethods
+ module Object
+ # Converts this object to a string (calling #to_s), converts
+ # it to a JSON string, and returns the result. This is a fallback, if no
+ # special method #to_json was defined for some object.
+ def to_json(*) to_s.to_json end
+ end
+
+ module Hash
+ # Returns a JSON string containing a JSON object, that is unparsed from
+ # this Hash instance.
+ # _state_ is a JSON::State object, that can also be used to configure the
+ # produced JSON string output further.
+ # _depth_ is used to find out nesting depth, to indent accordingly.
+ def to_json(state = nil, depth = 0, *)
+ if state
+ state = JSON.state.from_state(state)
+ json_check_circular(state) { json_transform(state, depth) }
+ else
+ json_transform(state, depth)
+ end
+ end
+
+ private
+
+ def json_check_circular(state)
+ if state
+ state.seen?(self) and raise JSON::CircularDatastructure,
+ "circular data structures not supported!"
+ state.remember self
+ end
+ yield
+ ensure
+ state and state.forget self
+ end
+
+ def json_shift(state, depth)
+ state and not state.object_nl.empty? or return ''
+ state.indent * depth
+ end
+
+ def json_transform(state, depth)
+ delim = ','
+ delim << state.object_nl if state
+ result = '{'
+ result << state.object_nl if state
+ result << map { |key,value|
+ s = json_shift(state, depth + 1)
+ s << key.to_s.to_json(state, depth + 1)
+ s << state.space_before if state
+ s << ':'
+ s << state.space if state
+ s << value.to_json(state, depth + 1)
+ }.join(delim)
+ result << state.object_nl if state
+ result << json_shift(state, depth)
+ result << '}'
+ result
+ end
+ end
+
+ module Array
+ # Returns a JSON string containing a JSON array, that is unparsed from
+ # this Array instance.
+ # _state_ is a JSON::State object, that can also be used to configure the
+ # produced JSON string output further.
+ # _depth_ is used to find out nesting depth, to indent accordingly.
+ def to_json(state = nil, depth = 0, *)
+ if state
+ state = JSON.state.from_state(state)
+ json_check_circular(state) { json_transform(state, depth) }
+ else
+ json_transform(state, depth)
+ end
+ end
+
+ private
+
+ def json_check_circular(state)
+ if state
+ state.seen?(self) and raise JSON::CircularDatastructure,
+ "circular data structures not supported!"
+ state.remember self
+ end
+ yield
+ ensure
+ state and state.forget self
+ end
+
+ def json_shift(state, depth)
+ state and not state.array_nl.empty? or return ''
+ state.indent * depth
+ end
+
+ def json_transform(state, depth)
+ delim = ','
+ delim << state.array_nl if state
+ result = '['
+ result << state.array_nl if state
+ result << map { |value|
+ json_shift(state, depth + 1) << value.to_json(state, depth + 1)
+ }.join(delim)
+ result << state.array_nl if state
+ result << json_shift(state, depth)
+ result << ']'
+ result
+ end
+ end
+
+ module Integer
+ # Returns a JSON string representation for this Integer number.
+ def to_json(*) to_s end
+ end
+
+ module Float
+ # Returns a JSON string representation for this Float number.
+ def to_json(*) to_s end
+ end
+
+ module String
+ # This string should be encoded with UTF-8 A call to this method
+ # returns a JSON string encoded with UTF16 big endian characters as
+ # \u????.
+ def to_json(*)
+ '"' << JSON.utf8_to_json(self) << '"'
+ end
+
+ # Module that holds the extinding methods if, the String module is
+ # included.
+ module Extend
+ # Raw Strings are JSON Objects (the raw bytes are stored in an array for the
+ # key "raw"). The Ruby String can be created by this module method.
+ def json_create(o)
+ o['raw'].pack('C*')
+ end
+ end
+
+ # Extends _modul_ with the String::Extend module.
+ def self.included(modul)
+ modul.extend Extend
+ end
+
+ # This method creates a raw object hash, that can be nested into
+ # other data structures and will be unparsed as a raw string. This
+ # method should be used, if you want to convert raw strings to JSON
+ # instead of UTF-8 strings, e. g. binary data.
+ def to_json_raw_object
+ {
+ JSON.create_id => self.class.name,
+ 'raw' => self.unpack('C*'),
+ }
+ end
+
+ # This method creates a JSON text from the result of
+ # a call to to_json_raw_object of this String.
+ def to_json_raw(*args)
+ to_json_raw_object.to_json(*args)
+ end
+ end
+
+ module TrueClass
+ # Returns a JSON string for true: 'true'.
+ def to_json(*) 'true' end
+ end
+
+ module FalseClass
+ # Returns a JSON string for false: 'false'.
+ def to_json(*) 'false' end
+ end
+
+ module NilClass
+ # Returns a JSON string for nil: 'null'.
+ def to_json(*) 'null' end
+ end
+ end
+ end
+ end
+end
diff --git a/lib/json/pure/parser.rb b/lib/json/pure/parser.rb
new file mode 100644
index 0000000..6118fe4
--- /dev/null
+++ b/lib/json/pure/parser.rb
@@ -0,0 +1,241 @@
+require 'strscan'
+
+module JSON
+ module Pure
+ # This class implements the JSON parser that is used to parse a JSON string
+ # into a Ruby data structure.
+ class Parser < StringScanner
+ STRING = /" ((?:[^\x0-\x1f"\\] |
+ \\["\\\/bfnrt] |
+ \\u[0-9a-fA-F]{4} |
+ \\[\x20-\xff])*)
+ "/nx
+ INTEGER = /(-?0|-?[1-9]\d*)/
+ FLOAT = /(-?
+ (?:0|[1-9]\d*)
+ (?:
+ \.\d+(?i:e[+-]?\d+) |
+ \.\d+ |
+ (?i:e[+-]?\d+)
+ )
+ )/x
+ OBJECT_OPEN = /\{/
+ OBJECT_CLOSE = /\}/
+ ARRAY_OPEN = /\[/
+ ARRAY_CLOSE = /\]/
+ PAIR_DELIMITER = /:/
+ COLLECTION_DELIMITER = /,/
+ TRUE = /true/
+ FALSE = /false/
+ NULL = /null/
+ IGNORE = %r(
+ (?:
+ //[^\n\r]*[\n\r]| # line comments
+ /\* # c-style comments
+ (?:
+ [^*/]| # normal chars
+ /[^*]| # slashes that do not start a nested comment
+ \*[^/]| # asterisks that do not end this comment
+ /(?=\*/) # single slash before this comment's end
+ )*
+ \*/ # the End of this comment
+ |[ \t\r\n]+ # whitespaces: space, horicontal tab, lf, cr
+ )+
+ )mx
+
+ UNPARSED = Object.new
+
+ # Creates a new JSON::Pure::Parser instance for the string _source_.
+ #
+ # It will be configured by the _opts_ hash. _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.
+ def initialize(source, opts = {})
+ super
+ if !opts.key?(:max_nesting) # defaults to 19
+ @max_nesting = 19
+ elsif opts[:max_nesting]
+ @max_nesting = opts[:max_nesting]
+ else
+ @max_nesting = 0
+ end
+ @create_id = JSON.create_id
+ end
+
+ alias source string
+
+ # Parses the current JSON string _source_ and returns the complete data
+ # structure as a result.
+ def parse
+ reset
+ obj = nil
+ until eos?
+ case
+ when scan(OBJECT_OPEN)
+ obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+ @current_nesting = 1
+ obj = parse_object
+ when scan(ARRAY_OPEN)
+ obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+ @current_nesting = 1
+ obj = parse_array
+ when skip(IGNORE)
+ ;
+ else
+ raise ParserError, "source '#{peek(20)}' not in JSON!"
+ end
+ end
+ obj or raise ParserError, "source did not contain any JSON!"
+ obj
+ end
+
+ private
+
+ # Unescape characters in strings.
+ UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+ UNESCAPE_MAP.update({
+ ?" => '"',
+ ?\\ => '\\',
+ ?/ => '/',
+ ?b => "\b",
+ ?f => "\f",
+ ?n => "\n",
+ ?r => "\r",
+ ?t => "\t",
+ ?u => nil,
+ })
+
+ def parse_string
+ if scan(STRING)
+ return '' if self[1].empty?
+ self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+ if u = UNESCAPE_MAP[c[1]]
+ u
+ else # \uXXXX
+ bytes = ''
+ i = 0
+ while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
+ bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
+ i += 1
+ end
+ JSON::UTF16toUTF8.iconv(bytes)
+ end
+ end
+ else
+ UNPARSED
+ end
+ rescue Iconv::Failure => e
+ raise GeneratorError, "Caught #{e.class}: #{e}"
+ end
+
+ def parse_value
+ case
+ when scan(FLOAT)
+ Float(self[1])
+ when scan(INTEGER)
+ Integer(self[1])
+ when scan(TRUE)
+ true
+ when scan(FALSE)
+ false
+ when scan(NULL)
+ nil
+ when (string = parse_string) != UNPARSED
+ string
+ when scan(ARRAY_OPEN)
+ @current_nesting += 1
+ ary = parse_array
+ @current_nesting -= 1
+ ary
+ when scan(OBJECT_OPEN)
+ @current_nesting += 1
+ obj = parse_object
+ @current_nesting -= 1
+ obj
+ else
+ UNPARSED
+ end
+ end
+
+ def parse_array
+ raise NestingError, "nesting of #@current_nesting is to deep" if
+ @max_nesting.nonzero? && @current_nesting > @max_nesting
+ result = []
+ delim = false
+ until eos?
+ case
+ when (value = parse_value) != UNPARSED
+ delim = false
+ result << value
+ skip(IGNORE)
+ if scan(COLLECTION_DELIMITER)
+ delim = true
+ elsif match?(ARRAY_CLOSE)
+ ;
+ else
+ raise ParserError, "expected ',' or ']' in array at '#{peek(20)}'!"
+ end
+ when scan(ARRAY_CLOSE)
+ if delim
+ raise ParserError, "expected next element in array at '#{peek(20)}'!"
+ end
+ break
+ when skip(IGNORE)
+ ;
+ else
+ raise ParserError, "unexpected token in array at '#{peek(20)}'!"
+ end
+ end
+ result
+ end
+
+ def parse_object
+ raise NestingError, "nesting of #@current_nesting is to deep" if
+ @max_nesting.nonzero? && @current_nesting > @max_nesting
+ result = {}
+ delim = false
+ until eos?
+ case
+ when (string = parse_string) != UNPARSED
+ skip(IGNORE)
+ unless scan(PAIR_DELIMITER)
+ raise ParserError, "expected ':' in object at '#{peek(20)}'!"
+ end
+ skip(IGNORE)
+ unless (value = parse_value).equal? UNPARSED
+ result[string] = value
+ delim = false
+ skip(IGNORE)
+ if scan(COLLECTION_DELIMITER)
+ delim = true
+ elsif match?(OBJECT_CLOSE)
+ ;
+ else
+ raise ParserError, "expected ',' or '}' in object at '#{peek(20)}'!"
+ end
+ else
+ raise ParserError, "expected value in object at '#{peek(20)}'!"
+ end
+ when scan(OBJECT_CLOSE)
+ if delim
+ raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
+ end
+ if klassname = result[@create_id]
+ klass = JSON.deep_const_get klassname
+ break unless klass and klass.json_creatable?
+ result = klass.json_create(result)
+ result
+ end
+ break
+ when skip(IGNORE)
+ ;
+ else
+ raise ParserError, "unexpected token in object at '#{peek(20)}'!"
+ end
+ end
+ result
+ end
+ end
+ end
+end
diff --git a/lib/json/version.rb b/lib/json/version.rb
new file mode 100755
index 0000000..464bb60
--- /dev/null
+++ b/lib/json/version.rb
@@ -0,0 +1,9 @@
+module JSON
+ # JSON version
+ VERSION = '1.1.0'
+ VERSION_ARRAY = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+ VERSION_MAJOR = VERSION_ARRAY[0] # :nodoc:
+ VERSION_MINOR = VERSION_ARRAY[1] # :nodoc:
+ VERSION_BUILD = VERSION_ARRAY[2] # :nodoc:
+ VARIANT_BINARY = false
+end
diff --git a/test/json/fixtures/fail1.json b/test/json/fixtures/fail1.json
new file mode 100644
index 0000000..6216b86
--- /dev/null
+++ b/test/json/fixtures/fail1.json
@@ -0,0 +1 @@
+"A JSON payload should be an object or array, not a string." \ No newline at end of file
diff --git a/test/json/fixtures/fail10.json b/test/json/fixtures/fail10.json
new file mode 100644
index 0000000..5d8c004
--- /dev/null
+++ b/test/json/fixtures/fail10.json
@@ -0,0 +1 @@
+{"Extra value after close": true} "misplaced quoted value" \ No newline at end of file
diff --git a/test/json/fixtures/fail11.json b/test/json/fixtures/fail11.json
new file mode 100644
index 0000000..76eb95b
--- /dev/null
+++ b/test/json/fixtures/fail11.json
@@ -0,0 +1 @@
+{"Illegal expression": 1 + 2} \ No newline at end of file
diff --git a/test/json/fixtures/fail12.json b/test/json/fixtures/fail12.json
new file mode 100644
index 0000000..77580a4
--- /dev/null
+++ b/test/json/fixtures/fail12.json
@@ -0,0 +1 @@
+{"Illegal invocation": alert()} \ No newline at end of file
diff --git a/test/json/fixtures/fail13.json b/test/json/fixtures/fail13.json
new file mode 100644
index 0000000..379406b
--- /dev/null
+++ b/test/json/fixtures/fail13.json
@@ -0,0 +1 @@
+{"Numbers cannot have leading zeroes": 013} \ No newline at end of file
diff --git a/test/json/fixtures/fail14.json b/test/json/fixtures/fail14.json
new file mode 100644
index 0000000..0ed366b
--- /dev/null
+++ b/test/json/fixtures/fail14.json
@@ -0,0 +1 @@
+{"Numbers cannot be hex": 0x14} \ No newline at end of file
diff --git a/test/json/fixtures/fail18.json b/test/json/fixtures/fail18.json
new file mode 100644
index 0000000..d61a345
--- /dev/null
+++ b/test/json/fixtures/fail18.json
@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]] // No, we don't limit our depth: Moved to pass...
diff --git a/test/json/fixtures/fail19.json b/test/json/fixtures/fail19.json
new file mode 100644
index 0000000..3b9c46f
--- /dev/null
+++ b/test/json/fixtures/fail19.json
@@ -0,0 +1 @@
+{"Missing colon" null} \ No newline at end of file
diff --git a/test/json/fixtures/fail2.json b/test/json/fixtures/fail2.json
new file mode 100644
index 0000000..6b7c11e
--- /dev/null
+++ b/test/json/fixtures/fail2.json
@@ -0,0 +1 @@
+["Unclosed array" \ No newline at end of file
diff --git a/test/json/fixtures/fail20.json b/test/json/fixtures/fail20.json
new file mode 100644
index 0000000..27c1af3
--- /dev/null
+++ b/test/json/fixtures/fail20.json
@@ -0,0 +1 @@
+{"Double colon":: null} \ No newline at end of file
diff --git a/test/json/fixtures/fail21.json b/test/json/fixtures/fail21.json
new file mode 100644
index 0000000..6247457
--- /dev/null
+++ b/test/json/fixtures/fail21.json
@@ -0,0 +1 @@
+{"Comma instead of colon", null} \ No newline at end of file
diff --git a/test/json/fixtures/fail22.json b/test/json/fixtures/fail22.json
new file mode 100644
index 0000000..a775258
--- /dev/null
+++ b/test/json/fixtures/fail22.json
@@ -0,0 +1 @@
+["Colon instead of comma": false] \ No newline at end of file
diff --git a/test/json/fixtures/fail23.json b/test/json/fixtures/fail23.json
new file mode 100644
index 0000000..494add1
--- /dev/null
+++ b/test/json/fixtures/fail23.json
@@ -0,0 +1 @@
+["Bad value", truth] \ No newline at end of file
diff --git a/test/json/fixtures/fail24.json b/test/json/fixtures/fail24.json
new file mode 100644
index 0000000..caff239
--- /dev/null
+++ b/test/json/fixtures/fail24.json
@@ -0,0 +1 @@
+['single quote'] \ No newline at end of file
diff --git a/test/json/fixtures/fail25.json b/test/json/fixtures/fail25.json
new file mode 100644
index 0000000..2dfbd25
--- /dev/null
+++ b/test/json/fixtures/fail25.json
@@ -0,0 +1 @@
+["tab character in string "]
diff --git a/test/json/fixtures/fail27.json b/test/json/fixtures/fail27.json
new file mode 100644
index 0000000..6b01a2c
--- /dev/null
+++ b/test/json/fixtures/fail27.json
@@ -0,0 +1,2 @@
+["line
+break"] \ No newline at end of file
diff --git a/test/json/fixtures/fail28.json b/test/json/fixtures/fail28.json
new file mode 100644
index 0000000..621a010
--- /dev/null
+++ b/test/json/fixtures/fail28.json
@@ -0,0 +1,2 @@
+["line\
+break"] \ No newline at end of file
diff --git a/test/json/fixtures/fail3.json b/test/json/fixtures/fail3.json
new file mode 100644
index 0000000..168c81e
--- /dev/null
+++ b/test/json/fixtures/fail3.json
@@ -0,0 +1 @@
+{unquoted_key: "keys must be quoted"} \ No newline at end of file
diff --git a/test/json/fixtures/fail4.json b/test/json/fixtures/fail4.json
new file mode 100644
index 0000000..9de168b
--- /dev/null
+++ b/test/json/fixtures/fail4.json
@@ -0,0 +1 @@
+["extra comma",] \ No newline at end of file
diff --git a/test/json/fixtures/fail5.json b/test/json/fixtures/fail5.json
new file mode 100644
index 0000000..ddf3ce3
--- /dev/null
+++ b/test/json/fixtures/fail5.json
@@ -0,0 +1 @@
+["double extra comma",,] \ No newline at end of file
diff --git a/test/json/fixtures/fail6.json b/test/json/fixtures/fail6.json
new file mode 100644
index 0000000..ed91580
--- /dev/null
+++ b/test/json/fixtures/fail6.json
@@ -0,0 +1 @@
+[ , "<-- missing value"] \ No newline at end of file
diff --git a/test/json/fixtures/fail7.json b/test/json/fixtures/fail7.json
new file mode 100644
index 0000000..8a96af3
--- /dev/null
+++ b/test/json/fixtures/fail7.json
@@ -0,0 +1 @@
+["Comma after the close"], \ No newline at end of file
diff --git a/test/json/fixtures/fail8.json b/test/json/fixtures/fail8.json
new file mode 100644
index 0000000..b28479c
--- /dev/null
+++ b/test/json/fixtures/fail8.json
@@ -0,0 +1 @@
+["Extra close"]] \ No newline at end of file
diff --git a/test/json/fixtures/fail9.json b/test/json/fixtures/fail9.json
new file mode 100644
index 0000000..5815574
--- /dev/null
+++ b/test/json/fixtures/fail9.json
@@ -0,0 +1 @@
+{"Extra comma": true,} \ No newline at end of file
diff --git a/test/json/fixtures/pass1.json b/test/json/fixtures/pass1.json
new file mode 100644
index 0000000..7828fcc
--- /dev/null
+++ b/test/json/fixtures/pass1.json
@@ -0,0 +1,56 @@
+[
+ "JSON Test Pattern pass1",
+ {"object with 1 member":["array with 1 element"]},
+ {},
+ [],
+ -42,
+ true,
+ false,
+ null,
+ {
+ "integer": 1234567890,
+ "real": -9876.543210,
+ "e": 0.123456789e-12,
+ "E": 1.234567890E+34,
+ "": 23456789012E666,
+ "zero": 0,
+ "one": 1,
+ "space": " ",
+ "quote": "\"",
+ "backslash": "\\",
+ "controls": "\b\f\n\r\t",
+ "slash": "/ & \/",
+ "alpha": "abcdefghijklmnopqrstuvwyz",
+ "ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ",
+ "digit": "0123456789",
+ "special": "`1~!@#$%^&*()_+-={':[,]}|;.</>?",
+ "hex": "\u0123\u4567\u89AB\uCDEF\uabcd\uef4A",
+ "true": true,
+ "false": false,
+ "null": null,
+ "array":[ ],
+ "object":{ },
+ "address": "50 St. James Street",
+ "url": "http://www.JSON.org/",
+ "comment": "// /* <!-- --",
+ "# -- --> */": " ",
+ " s p a c e d " :[1,2 , 3
+
+,
+
+4 , 5 , 6 ,7 ],
+ "compact": [1,2,3,4,5,6,7],
+ "jsontext": "{\"object with 1 member\":[\"array with 1 element\"]}",
+ "quotes": "&#34; \u0022 %22 0x22 034 &#x22;",
+ "\/\\\"\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"
+: "A key can be any string"
+ },
+ 0.5 ,98.6
+,
+99.44
+,
+
+1066
+
+
+,"rosebud"] \ No newline at end of file
diff --git a/test/json/fixtures/pass15.json b/test/json/fixtures/pass15.json
new file mode 100644
index 0000000..fc8376b
--- /dev/null
+++ b/test/json/fixtures/pass15.json
@@ -0,0 +1 @@
+["Illegal backslash escape: \x15"] \ No newline at end of file
diff --git a/test/json/fixtures/pass16.json b/test/json/fixtures/pass16.json
new file mode 100644
index 0000000..c43ae3c
--- /dev/null
+++ b/test/json/fixtures/pass16.json
@@ -0,0 +1 @@
+["Illegal backslash escape: \'"] \ No newline at end of file
diff --git a/test/json/fixtures/pass17.json b/test/json/fixtures/pass17.json
new file mode 100644
index 0000000..62b9214
--- /dev/null
+++ b/test/json/fixtures/pass17.json
@@ -0,0 +1 @@
+["Illegal backslash escape: \017"] \ No newline at end of file
diff --git a/test/json/fixtures/pass2.json b/test/json/fixtures/pass2.json
new file mode 100644
index 0000000..d3c63c7
--- /dev/null
+++ b/test/json/fixtures/pass2.json
@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]] \ No newline at end of file
diff --git a/test/json/fixtures/pass26.json b/test/json/fixtures/pass26.json
new file mode 100644
index 0000000..845d26a
--- /dev/null
+++ b/test/json/fixtures/pass26.json
@@ -0,0 +1 @@
+["tab\ character\ in\ string\ "] \ No newline at end of file
diff --git a/test/json/fixtures/pass3.json b/test/json/fixtures/pass3.json
new file mode 100644
index 0000000..4528d51
--- /dev/null
+++ b/test/json/fixtures/pass3.json
@@ -0,0 +1,6 @@
+{
+ "JSON Test Pattern pass3": {
+ "The outermost value": "must be an object or array.",
+ "In this test": "It is an object."
+ }
+}
diff --git a/test/json/runner.rb b/test/json/runner.rb
new file mode 100644
index 0000000..930fed7
--- /dev/null
+++ b/test/json/runner.rb
@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'test/unit/ui/console/testrunner'
+require 'test/unit/testsuite'
+$:.unshift File.expand_path(File.dirname($0))
+$:.unshift 'tests'
+require 'test_json'
+require 'test_json_generate'
+require 'test_json_unicode'
+require 'test_json_addition'
+require 'test_json_fixtures'
+
+class TS_AllTests
+ def self.suite
+ suite = Test::Unit::TestSuite.new name
+ suite << TC_JSONGenerate.suite
+ suite << TC_JSON.suite
+ suite << TC_JSONUnicode.suite
+ suite << TC_JSONAddition.suite
+ suite << TC_JSONFixtures.suite
+ end
+end
+Test::Unit::UI::Console::TestRunner.run(TS_AllTests)
+ # vim: set et sw=2 ts=2:
diff --git a/test/json/test_json.rb b/test/json/test_json.rb
new file mode 100755
index 0000000..2be7b4a
--- /dev/null
+++ b/test/json/test_json.rb
@@ -0,0 +1,255 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'json'
+
+class TC_JSON < Test::Unit::TestCase
+ include JSON
+
+ def setup
+ $KCODE = 'UTF8'
+ @ary = [1, "foo", 3.14, 4711.0, 2.718, nil, [1,-2,3], false, true].map do
+ |x| [x]
+ end
+ @ary_to_parse = ["1", '"foo"', "3.14", "4711.0", "2.718", "null",
+ "[1,-2,3]", "false", "true"].map do
+ |x| "[#{x}]"
+ end
+ @hash = {
+ 'a' => 2,
+ 'b' => 3.141,
+ 'c' => 'c',
+ 'd' => [ 1, "b", 3.14 ],
+ 'e' => { 'foo' => 'bar' },
+ 'g' => "\"\0\037",
+ 'h' => 1000.0,
+ 'i' => 0.001
+ }
+ @json = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},' +
+ '"g":"\\"\\u0000\\u001f","h":1.0E3,"i":1.0E-3}'
+ end
+ suite << TC_JSON.suite
+
+ def test_construction
+ parser = JSON::Parser.new('test')
+ assert_equal 'test', parser.source
+ end
+
+ def assert_equal_float(expected, is)
+ assert_in_delta(expected.first, is.first, 1e-2)
+ end
+
+ def test_parse_simple_arrays
+ assert_equal([], parse('[]'))
+ assert_equal([], parse(' [ ] '))
+ assert_equal([nil], parse('[null]'))
+ assert_equal([false], parse('[false]'))
+ assert_equal([true], parse('[true]'))
+ assert_equal([-23], parse('[-23]'))
+ assert_equal([23], parse('[23]'))
+ assert_equal([0.23], parse('[0.23]'))
+ assert_equal([0.0], parse('[0e0]'))
+ assert_raises(JSON::ParserError) { parse('[+23.2]') }
+ assert_raises(JSON::ParserError) { parse('[+23]') }
+ assert_raises(JSON::ParserError) { parse('[.23]') }
+ assert_raises(JSON::ParserError) { parse('[023]') }
+ assert_equal_float [3.141], parse('[3.141]')
+ assert_equal_float [-3.141], parse('[-3.141]')
+ assert_equal_float [3.141], parse('[3141e-3]')
+ assert_equal_float [3.141], parse('[3141.1e-3]')
+ assert_equal_float [3.141], parse('[3141E-3]')
+ assert_equal_float [3.141], parse('[3141.0E-3]')
+ assert_equal_float [-3.141], parse('[-3141.0e-3]')
+ assert_equal_float [-3.141], parse('[-3141e-3]')
+ assert_equal([""], parse('[""]'))
+ assert_equal(["foobar"], parse('["foobar"]'))
+ assert_equal([{}], parse('[{}]'))
+ end
+
+ def test_parse_simple_objects
+ assert_equal({}, parse('{}'))
+ assert_equal({}, parse(' { } '))
+ assert_equal({ "a" => nil }, parse('{ "a" : null}'))
+ assert_equal({ "a" => nil }, parse('{"a":null}'))
+ assert_equal({ "a" => false }, parse('{ "a" : false } '))
+ assert_equal({ "a" => false }, parse('{"a":false}'))
+ assert_raises(JSON::ParserError) { parse('{false}') }
+ assert_equal({ "a" => true }, parse('{"a":true}'))
+ assert_equal({ "a" => true }, parse(' { "a" : true } '))
+ assert_equal({ "a" => -23 }, parse(' { "a" : -23 } '))
+ assert_equal({ "a" => -23 }, parse(' { "a" : -23 } '))
+ assert_equal({ "a" => 23 }, parse('{"a":23 } '))
+ assert_equal({ "a" => 23 }, parse(' { "a" : 23 } '))
+ assert_equal({ "a" => 0.23 }, parse(' { "a" : 0.23 } '))
+ assert_equal({ "a" => 0.23 }, parse(' { "a" : 0.23 } '))
+ end
+
+ begin
+ require 'permutation'
+ def test_parse_more_complex_arrays
+ a = [ nil, false, true, "fobar", [ "nstd", true ], { "nested" => true, "nt2" => {} }]
+ perms = Permutation.for a
+ perms.each do |perm|
+ orig_ary = perm.project
+ json = pretty_generate(orig_ary)
+ assert_equal orig_ary, parse(json)
+ end
+ end
+
+ def test_parse_complex_objects
+ a = [ nil, false, true, "fobar", [ "nstd", true ], { "nested" => true, "nt2" => {} }]
+ perms = Permutation.for a
+ perms.each do |perm|
+ s = "a"
+ orig_obj = perm.project.inject({}) { |h, x| h[s.dup] = x; s = s.succ; h }
+ json = pretty_generate(orig_obj)
+ assert_equal orig_obj, parse(json)
+ end
+ end
+ rescue LoadError
+ warn "Skipping permutation tests."
+ end
+
+ def test_parse_arrays
+ assert_equal([1,2,3], parse('[1,2,3]'))
+ assert_equal([1.2,2,3], parse('[1.2,2,3]'))
+ assert_equal([[],[[],[]]], parse('[[],[[],[]]]'))
+ end
+
+ def test_parse_values
+ assert_equal([""], parse('[""]'))
+ assert_equal(["\\"], parse('["\\\\"]'))
+ assert_equal(['"'], parse('["\""]'))
+ assert_equal(['\\"\\'], parse('["\\\\\\"\\\\"]'))
+ assert_equal(["\"\b\n\r\t\0\037"],
+ parse('["\"\b\n\r\t\u0000\u001f"]'))
+ for i in 0 ... @ary.size
+ assert_equal(@ary[i], parse(@ary_to_parse[i]))
+ end
+ end
+
+ def test_parse_array
+ assert_equal([], parse('[]'))
+ assert_equal([], parse(' [ ] '))
+ assert_equal([1], parse('[1]'))
+ assert_equal([1], parse(' [ 1 ] '))
+ assert_equal(@ary,
+ parse('[[1],["foo"],[3.14],[47.11e+2],[2718.0E-3],[null],[[1,-2,3]]'\
+ ',[false],[true]]'))
+ assert_equal(@ary, parse(%Q{ [ [1] , ["foo"] , [3.14] \t , [47.11e+2]
+ , [2718.0E-3 ],\r[ null] , [[1, -2, 3 ]], [false ],[ true]\n ] }))
+ end
+
+ def test_parse_object
+ assert_equal({}, parse('{}'))
+ assert_equal({}, parse(' { } '))
+ assert_equal({'foo'=>'bar'}, parse('{"foo":"bar"}'))
+ assert_equal({'foo'=>'bar'}, parse(' { "foo" : "bar" } '))
+ end
+
+ def test_parser_reset
+ parser = Parser.new(@json)
+ assert_equal(@hash, parser.parse)
+ assert_equal(@hash, parser.parse)
+ end
+
+ def test_comments
+ json = <<EOT
+{
+ "key1":"value1", // eol comment
+ "key2":"value2" /* multi line
+ * comment */,
+ "key3":"value3" /* multi line
+ // nested eol comment
+ * comment */
+}
+EOT
+ assert_equal(
+ { "key1" => "value1", "key2" => "value2", "key3" => "value3" },
+ parse(json))
+ json = <<EOT
+{
+ "key1":"value1" /* multi line
+ // nested eol comment
+ /* illegal nested multi line comment */
+ * comment */
+}
+EOT
+ assert_raises(ParserError) { parse(json) }
+ json = <<EOT
+{
+ "key1":"value1" /* multi line
+ // nested eol comment
+ closed multi comment */
+ and again, throw an Error */
+}
+EOT
+ assert_raises(ParserError) { parse(json) }
+ json = <<EOT
+{
+ "key1":"value1" /*/*/
+}
+EOT
+ assert_equal({ "key1" => "value1" }, parse(json))
+ end
+
+ def test_backslash
+ data = [ '\\.(?i:gif|jpe?g|png)$' ]
+ json = '["\\\\.(?i:gif|jpe?g|png)$"]'
+ assert_equal json, JSON.unparse(data)
+ assert_equal data, JSON.parse(json)
+ #
+ data = [ '\\"' ]
+ json = '["\\\\\""]'
+ assert_equal json, JSON.unparse(data)
+ assert_equal data, JSON.parse(json)
+ #
+ json = '["\/"]'
+ data = JSON.parse(json)
+ assert_equal ['/'], data
+ assert_equal json, JSON.unparse(data)
+ #
+ json = '["\""]'
+ data = JSON.parse(json)
+ assert_equal ['"'], data
+ assert_equal json, JSON.unparse(data)
+ json = '["\\\'"]'
+ data = JSON.parse(json)
+ assert_equal ["'"], data
+ assert_equal '["\'"]', JSON.unparse(data)
+ end
+
+ def test_wrong_inputs
+ assert_raises(ParserError) { JSON.parse('"foo"') }
+ assert_raises(ParserError) { JSON.parse('123') }
+ assert_raises(ParserError) { JSON.parse('[] bla') }
+ assert_raises(ParserError) { JSON.parse('[] 1') }
+ assert_raises(ParserError) { JSON.parse('[] []') }
+ assert_raises(ParserError) { JSON.parse('[] {}') }
+ assert_raises(ParserError) { JSON.parse('{} []') }
+ assert_raises(ParserError) { JSON.parse('{} {}') }
+ assert_raises(ParserError) { JSON.parse('[NULL]') }
+ assert_raises(ParserError) { JSON.parse('[FALSE]') }
+ assert_raises(ParserError) { JSON.parse('[TRUE]') }
+ assert_raises(ParserError) { JSON.parse('[07] ') }
+ assert_raises(ParserError) { JSON.parse('[0a]') }
+ assert_raises(ParserError) { JSON.parse('[1.]') }
+ assert_raises(ParserError) { JSON.parse(' ') }
+ end
+
+ def test_nesting
+ to_deep = '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]'
+ assert_raises(JSON::NestingError) { JSON.parse to_deep }
+ assert_raises(JSON::NestingError) { JSON.parser.new(to_deep).parse }
+ assert_raises(JSON::NestingError) { JSON.parse to_deep, :max_nesting => 19 }
+ ok = JSON.parse to_deep, :max_nesting => 20
+ assert_kind_of Array, ok
+ ok = JSON.parse to_deep, :max_nesting => nil
+ assert_kind_of Array, ok
+ ok = JSON.parse to_deep, :max_nesting => false
+ assert_kind_of Array, ok
+ ok = JSON.parse to_deep, :max_nesting => 0
+ assert_kind_of Array, ok
+ end
+end
+ # vim: set et sw=2 ts=2:
diff --git a/test/json/test_json_addition.rb b/test/json/test_json_addition.rb
new file mode 100755
index 0000000..e527f70
--- /dev/null
+++ b/test/json/test_json_addition.rb
@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'json'
+
+class TC_JSONAddition < Test::Unit::TestCase
+ include JSON
+
+ class A
+ def initialize(a)
+ @a = a
+ end
+
+ attr_reader :a
+
+ def ==(other)
+ a == other.a
+ end
+
+ def self.json_create(object)
+ new(*object['args'])
+ end
+
+ def to_json(*args)
+ {
+ 'json_class' => self.class,
+ 'args' => [ @a ],
+ }.to_json(*args)
+ end
+ end
+
+ class B
+ def to_json(*args)
+ {
+ 'json_class' => self.class,
+ }.to_json(*args)
+ end
+ end
+
+ class C
+ def to_json(*args)
+ {
+ 'json_class' => 'TC_JSONAddition::Nix',
+ }.to_json(*args)
+ end
+ end
+
+ def setup
+ $KCODE = 'UTF8'
+ end
+
+ def test_extended_json
+ a = A.new(666)
+ assert A.json_creatable?
+ json = generate(a)
+ a_again = JSON.parse(json)
+ assert_kind_of a.class, a_again
+ assert_equal a, a_again
+ end
+
+ def test_extended_json_fail
+ b = B.new
+ assert !B.json_creatable?
+ json = generate(b)
+ assert_equal({ 'json_class' => B.name }, JSON.parse(json))
+ end
+
+ def test_extended_json_fail
+ c = C.new
+ assert !C.json_creatable?
+ json = generate(c)
+ assert_raises(ArgumentError) { JSON.parse(json) }
+ end
+
+ def test_raw_strings
+ raw = ''
+ raw_array = []
+ for i in 0..255
+ raw << i
+ raw_array << i
+ end
+ json = raw.to_json_raw
+ json_raw_object = raw.to_json_raw_object
+ hash = { 'json_class' => 'String', 'raw'=> raw_array }
+ assert_equal hash, json_raw_object
+ json_raw = <<EOT.chomp
+{\"json_class\":\"String\",\"raw\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255]}
+EOT
+# "
+ assert_equal json_raw, json
+ raw_again = JSON.parse(json)
+ assert_equal raw, raw_again
+ end
+end
diff --git a/test/json/test_json_fixtures.rb b/test/json/test_json_fixtures.rb
new file mode 100755
index 0000000..665dcbd
--- /dev/null
+++ b/test/json/test_json_fixtures.rb
@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'json'
+
+class TC_JSONFixtures < Test::Unit::TestCase
+ def setup
+ $KCODE = 'UTF8'
+ fixtures = File.join(File.dirname(__FILE__), 'fixtures/*.json')
+ passed, failed = Dir[fixtures].partition { |f| f['pass'] }
+ @passed = passed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+ @failed = failed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+ end
+
+ def test_passing
+ for name, source in @passed
+ assert JSON.parse(source),
+ "Did not pass for fixture '#{name}'"
+ end
+ end
+
+ def test_failing
+ for name, source in @failed
+ assert_raises(JSON::ParserError, JSON::NestingError,
+ "Did not fail for fixture '#{name}'") do
+ JSON.parse(source)
+ end
+ end
+ end
+end
diff --git a/test/json/test_json_generate.rb b/test/json/test_json_generate.rb
new file mode 100755
index 0000000..519d56a
--- /dev/null
+++ b/test/json/test_json_generate.rb
@@ -0,0 +1,81 @@
+require 'test/unit'
+require 'json'
+
+class TC_JSONGenerate < Test::Unit::TestCase
+ include JSON
+
+ def setup
+ $KCODE = 'UTF8'
+ @hash = {
+ 'a' => 2,
+ 'b' => 3.141,
+ 'c' => 'c',
+ 'd' => [ 1, "b", 3.14 ],
+ 'e' => { 'foo' => 'bar' },
+ 'g' => "\"\0\037",
+ 'h' => 1000.0,
+ 'i' => 0.001
+ }
+ @json2 = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},' +
+ '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
+ @json3 = <<'EOT'.chomp
+{
+ "a": 2,
+ "b": 3.141,
+ "c": "c",
+ "d": [
+ 1,
+ "b",
+ 3.14
+ ],
+ "e": {
+ "foo": "bar"
+ },
+ "g": "\"\u0000\u001f",
+ "h": 1000.0,
+ "i": 0.001
+}
+EOT
+ end
+
+ def test_unparse
+ json = unparse(@hash)
+ assert_equal(@json2, json)
+ parsed_json = parse(json)
+ assert_equal(@hash, parsed_json)
+ json = generate({1=>2})
+ assert_equal('{"1":2}', json)
+ parsed_json = parse(json)
+ assert_equal({"1"=>2}, parsed_json)
+ end
+
+ def test_unparse_pretty
+ json = pretty_unparse(@hash)
+ assert_equal(@json3, json)
+ parsed_json = parse(json)
+ assert_equal(@hash, parsed_json)
+ json = pretty_generate({1=>2})
+ assert_equal(<<'EOT'.chomp, json)
+{
+ "1": 2
+}
+EOT
+ parsed_json = parse(json)
+ assert_equal({"1"=>2}, parsed_json)
+ end
+
+ def test_states
+ json = generate({1=>2}, nil)
+ assert_equal('{"1":2}', json)
+ s = JSON.state.new(:check_circular => true)
+ #assert s.check_circular
+ h = { 1=>2 }
+ h[3] = h
+ assert_raises(JSON::CircularDatastructure) { generate(h, s) }
+ s = JSON.state.new(:check_circular => true)
+ #assert s.check_circular
+ a = [ 1, 2 ]
+ a << a
+ assert_raises(JSON::CircularDatastructure) { generate(a, s) }
+ end
+end
diff --git a/test/json/test_json_unicode.rb b/test/json/test_json_unicode.rb
new file mode 100755
index 0000000..a23e50e
--- /dev/null
+++ b/test/json/test_json_unicode.rb
@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'json'
+
+class TC_JSONUnicode < Test::Unit::TestCase
+ include JSON
+
+ def setup
+ $KCODE = 'UTF8'
+ end
+
+ def test_unicode
+ assert_equal '""', ''.to_json
+ assert_equal '"\\b"', "\b".to_json
+ assert_equal '"\u0001"', 0x1.chr.to_json
+ assert_equal '"\u001f"', 0x1f.chr.to_json
+ assert_equal '" "', ' '.to_json
+ assert_equal "\"#{0x7f.chr}\"", 0x7f.chr.to_json
+ utf8 = [ " ! \01" ]
+ json = '["\u00a9 \u2260 \u20ac! \u0001"]'
+ assert_equal json, utf8.to_json
+ assert_equal utf8, parse(json)
+ utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
+ json = "[\"\\u3042\\u3044\\u3046\\u3048\\u304a\"]"
+ assert_equal json, utf8.to_json
+ assert_equal utf8, parse(json)
+ utf8 = ['']
+ json = "[\"\\u10e1\\u10d0\\u10e5\\u10d0\\u10e0\\u10d7\\u10d5\\u10d4\\u10da\\u10dd\"]"
+ assert_equal json, utf8.to_json
+ assert_equal utf8, parse(json)
+ assert_equal '["\\u00c3"]', JSON.generate([""])
+ assert_equal [""], JSON.parse('["\u20ac"]')
+ utf8 = ["\xf0\xa0\x80\x81"]
+ json = '["\ud840\udc01"]'
+ assert_equal json, JSON.generate(utf8)
+ assert_equal utf8, JSON.parse(json)
+ end
+
+ def test_chars
+ (0..0x7f).each do |i|
+ c = ('%c' % i)[0] # c is a character object
+ json = '["\u%04x"]' % i
+ assert_equal c, JSON.parse(json).first
+ if c == ?\b
+ generated = JSON.generate(["" << i])
+ assert '["\b"]' == generated || '["\10"]' == generated
+ elsif [?\n, ?\r, ?\t, ?\f].include?(c)
+ assert_equal '[' << ('' << i).dump << ']', JSON.generate(["" << i])
+ elsif i < 0x20
+ assert_equal json, JSON.generate(["" << i])
+ end
+ end
+ assert_raises(JSON::GeneratorError) do
+ JSON.generate(["" << 0x80])
+ end
+ assert_equal "\302\200", JSON.parse('["\u0080"]').first
+ end
+end