scout 5.1.2 → 5.1.3

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: scout
 version: !ruby/object:Gem::Version 
-  version: 5.1.2
+  prerelease: false
+  segments: 
+  - 5
+  - 1
+  - 3
+  version: 5.1.3
 platform: ruby
 authors: 
 - Highgroove Studios
@@ -9,19 +14,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-27 00:00:00 -07:00
+date: 2010-04-30 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: elif
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: |
   Scout makes monitoring and reporting on your web applications as flexible and simple as possible.
   
@@ -83,24 +90,26 @@ files:
 - vendor/json_pure/benchmarks/data-p4-3GHz-ruby18/ParserBenchmarkYAML#parser-autocorrelation.dat
 - vendor/json_pure/benchmarks/data-p4-3GHz-ruby18/ParserBenchmarkYAML#parser.dat
 - vendor/json_pure/benchmarks/data-p4-3GHz-ruby18/ParserBenchmarkYAML.log
+- vendor/json_pure/benchmarks/generator2_benchmark.rb
 - vendor/json_pure/benchmarks/generator_benchmark.rb
+- vendor/json_pure/benchmarks/ohai.json
+- vendor/json_pure/benchmarks/ohai.ruby
+- vendor/json_pure/benchmarks/parser2_benchmark.rb
 - vendor/json_pure/benchmarks/parser_benchmark.rb
 - vendor/json_pure/bin/edit_json.rb
 - vendor/json_pure/bin/prettify_json.rb
 - vendor/json_pure/CHANGES
+- vendor/json_pure/COPYING
 - vendor/json_pure/data/example.json
 - vendor/json_pure/data/index.html
 - vendor/json_pure/data/prototype.js
-- vendor/json_pure/doc-templates/main.txt
 - vendor/json_pure/ext/json/ext/generator/extconf.rb
 - vendor/json_pure/ext/json/ext/generator/generator.c
-- vendor/json_pure/ext/json/ext/generator/unicode.c
-- vendor/json_pure/ext/json/ext/generator/unicode.h
+- vendor/json_pure/ext/json/ext/generator/generator.h
 - vendor/json_pure/ext/json/ext/parser/extconf.rb
 - vendor/json_pure/ext/json/ext/parser/parser.c
+- vendor/json_pure/ext/json/ext/parser/parser.h
 - vendor/json_pure/ext/json/ext/parser/parser.rl
-- vendor/json_pure/ext/json/ext/parser/unicode.c
-- vendor/json_pure/ext/json/ext/parser/unicode.h
 - vendor/json_pure/GPL
 - vendor/json_pure/install.rb
 - vendor/json_pure/lib/json/add/core.rb
@@ -124,7 +133,6 @@ files:
 - vendor/json_pure/lib/json.rb
 - vendor/json_pure/Rakefile
 - vendor/json_pure/README
-- vendor/json_pure/RUBY
 - vendor/json_pure/tests/fixtures/fail1.json
 - vendor/json_pure/tests/fixtures/fail10.json
 - vendor/json_pure/tests/fixtures/fail11.json
@@ -158,6 +166,7 @@ files:
 - vendor/json_pure/tests/fixtures/pass3.json
 - vendor/json_pure/tests/test_json.rb
 - vendor/json_pure/tests/test_json_addition.rb
+- vendor/json_pure/tests/test_json_encoding.rb
 - vendor/json_pure/tests/test_json_fixtures.rb
 - vendor/json_pure/tests/test_json_generate.rb
 - vendor/json_pure/tests/test_json_rails.rb
@@ -190,18 +199,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: scout
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Scout makes monitoring and reporting on your web applications as flexible and simple as possible.

data/vendor/json_pure/doc-templates/main.txt

@@ -1,283 +0,0 @@
-# = 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
-#
-# == Usage
-# 
-# To use JSON you can
-#   require 'json'
-# to load the installed variant (either the extension 'json' or the pure
-# variant 'json_pure'). If you have installed the extension variant, you can
-# pick either the extension variant or the pure variant by typing
-#   require 'json/ext'
-# or
-#   require 'json/pure'
-#
-# You can choose to load a set of common additions to ruby core's objects if
-# you
-#   require 'json/add/core'
-#
-# After requiring this you can, e. g., serialise/deserialise Ruby ranges:
-#
-#   JSON JSON(1..10) # => 1..10
-#
-# To find out how to add JSON support to other or your own classes, read the
-# Examples section below.
-#
-# To get the best compatibility to rails' JSON implementation, you can
-#   require 'json/add/rails'
-#
-# Both of the additions attempt to require 'json' (like above) first, if it has
-# not been required yet.
-#
-# == Speed Comparisons
-#
-# I have created some benchmark results (see the benchmarks/data-p4-3Ghz
-# subdir of the package) for the JSON-parser to estimate the speed up in the C
-# extension:
-#
-#  Comparing times (call_time_mean):
-#   1 ParserBenchmarkExt#parser   900 repeats:
-#         553.922304770 (  real) ->   21.500x 
-#           0.001805307
-#   2 ParserBenchmarkYAML#parser  1000 repeats:
-#         224.513358139 (  real) ->    8.714x 
-#           0.004454078
-#   3 ParserBenchmarkPure#parser  1000 repeats:
-#          26.755020642 (  real) ->    1.038x 
-#           0.037376163
-#   4 ParserBenchmarkRails#parser 1000 repeats:
-#          25.763381731 (  real) ->    1.000x 
-#           0.038814780
-#             calls/sec (  time) ->    speed  covers
-#             secs/call
-#
-# In the table above 1 is JSON::Ext::Parser, 2 is YAML.load with YAML
-# compatbile JSON document, 3 is is JSON::Pure::Parser, and 4 is
-# ActiveSupport::JSON.decode. The ActiveSupport JSON-decoder converts the
-# input first to YAML and then uses the YAML-parser, the conversion seems to
-# slow it down so much that it is only as fast as the JSON::Pure::Parser!
-#
-# If you look at the benchmark data you can see that this is mostly caused by
-# the frequent high outliers - the median of the Rails-parser runs is still
-# overall smaller than the median of the JSON::Pure::Parser runs:
-#
-#  Comparing times (call_time_median):
-#   1 ParserBenchmarkExt#parser   900 repeats:
-#         800.592479481 (  real) ->   26.936x 
-#           0.001249075
-#   2 ParserBenchmarkYAML#parser  1000 repeats:
-#         271.002390644 (  real) ->    9.118x 
-#           0.003690004
-#   3 ParserBenchmarkRails#parser 1000 repeats:
-#          30.227910865 (  real) ->    1.017x 
-#           0.033082008
-#   4 ParserBenchmarkPure#parser  1000 repeats:
-#          29.722384421 (  real) ->    1.000x 
-#           0.033644676
-#             calls/sec (  time) ->    speed  covers
-#             secs/call
-#
-# I have benchmarked the JSON-Generator as well. This generated a few more
-# values, because there are different modes that also influence the achieved
-# speed:
-#
-#  Comparing times (call_time_mean):
-#   1 GeneratorBenchmarkExt#generator_fast    1000 repeats:
-#         547.354332608 (  real) ->   15.090x 
-#           0.001826970
-#   2 GeneratorBenchmarkExt#generator_safe    1000 repeats:
-#         443.968212317 (  real) ->   12.240x 
-#           0.002252414
-#   3 GeneratorBenchmarkExt#generator_pretty  900 repeats:
-#         375.104545883 (  real) ->   10.341x 
-#           0.002665923
-#   4 GeneratorBenchmarkPure#generator_fast   1000 repeats:
-#          49.978706968 (  real) ->    1.378x 
-#           0.020008521
-#   5 GeneratorBenchmarkRails#generator       1000 repeats:
-#          38.531868759 (  real) ->    1.062x 
-#           0.025952543
-#   6 GeneratorBenchmarkPure#generator_safe   1000 repeats:
-#          36.927649925 (  real) ->    1.018x 7 (>=3859)
-#           0.027079979
-#   7 GeneratorBenchmarkPure#generator_pretty 1000 repeats:
-#          36.272134441 (  real) ->    1.000x 6 (>=3859)
-#           0.027569373
-#             calls/sec (  time) ->    speed  covers
-#             secs/call
-#
-# In the table above 1-3 are JSON::Ext::Generator methods. 4, 6, and 7 are
-# JSON::Pure::Generator methods and 5 is the Rails JSON generator. It is now a
-# bit faster than the generator_safe and generator_pretty methods of the pure
-# variant but slower than the others.
-#
-# To achieve the fastest JSON text output, you can use the fast_generate
-# method. Beware, that this will disable the checking for circular Ruby data
-# structures, which may cause JSON to go into an infinite loop.
-#
-# Here are the median comparisons for completeness' sake:
-#
-#  Comparing times (call_time_median):
-#   1 GeneratorBenchmarkExt#generator_fast    1000 repeats:
-#         708.258020939 (  real) ->   16.547x 
-#           0.001411915
-#   2 GeneratorBenchmarkExt#generator_safe    1000 repeats:
-#         569.105020353 (  real) ->   13.296x 
-#           0.001757145
-#   3 GeneratorBenchmarkExt#generator_pretty  900 repeats:
-#         482.825371244 (  real) ->   11.280x 
-#           0.002071142
-#   4 GeneratorBenchmarkPure#generator_fast   1000 repeats:
-#          62.717626652 (  real) ->    1.465x 
-#           0.015944481
-#   5 GeneratorBenchmarkRails#generator       1000 repeats:
-#          43.965681162 (  real) ->    1.027x 
-#           0.022745013
-#   6 GeneratorBenchmarkPure#generator_safe   1000 repeats:
-#          43.929073409 (  real) ->    1.026x 7 (>=3859)
-#           0.022763968
-#   7 GeneratorBenchmarkPure#generator_pretty 1000 repeats:
-#          42.802514491 (  real) ->    1.000x 6 (>=3859)
-#           0.023363113
-#             calls/sec (  time) ->    speed  covers
-#             secs/call
-#
-# == Examples
-#
-# To create a JSON text from a ruby data structure, you can call JSON.generate
-# 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\"]"
-#
-# 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 add JSON support serialization to 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 deserialise 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 deserialised.
-#
-# 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 deserialised by implementing Range.json_create like this:
-# 
-#  class Range
-#    def self.json_create(o)
-#      new(*o['data'])
-#    end
-#  end
-#
-# Now it possible to serialise/deserialise 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 generate, and Kernel#jj for
-# pretty_generate 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.
-#

data/vendor/json_pure/ext/json/ext/generator/unicode.c

@@ -1,182 +0,0 @@
-#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));
-        }
-    }
-}