diff options
| author | nbarth@chromium.org <nbarth@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-06-10 08:19:10 +0000 |
|---|---|---|
| committer | nbarth@chromium.org <nbarth@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-06-10 08:19:10 +0000 |
| commit | 487b14133b2d97e19e2a8e6663b4230e9d58bf14 (patch) | |
| tree | ce1fb42ed01ccb7a678c8d837564290457756cd3 /third_party/JSON | |
| parent | ede9ea833d0ab5b7e952b7939a2787ef0e592600 (diff) | |
| download | chromium_src-487b14133b2d97e19e2a8e6663b4230e9d58bf14.zip chromium_src-487b14133b2d97e19e2a8e6663b4230e9d58bf14.tar.gz chromium_src-487b14133b2d97e19e2a8e6663b4230e9d58bf14.tar.bz2 | |
Add JSON.pm to third_party
We're using JSON as an exchange format both:
1. To make the existing Perl more modular
(so we can connect the parser and code generator via intermediate files),
2. To ease porting to Python, so we can connect existing Perl scripts
to new Python scripts.
This is build-only: the module is used during the build, but not included
in the distributed binary, and thus should not pose licensing problems.
Source: http://www.cpan.org/authors/id/M/MA/MAKAMAKA/JSON-2.59.tar.gz
SHA-1: 8a82c442088ffa0d605747fd5e65f51e037aad94
License is same as Perl, meaning GPL v1+ or Artistic license:
http://search.cpan.org/~makamaka/JSON-2.58/lib/JSON.pm#COPYRIGHT_AND_LICENSE
http://dev.perl.org/licenses/
BUG=239771
Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=205057
Review URL: https://chromiumcodereview.appspot.com/15736030
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@205157 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'third_party/JSON')
109 files changed, 30654 insertions, 0 deletions
diff --git a/third_party/JSON/JSON-2.59.tar.gz.sha1 b/third_party/JSON/JSON-2.59.tar.gz.sha1 new file mode 100644 index 0000000..a2772e0 --- /dev/null +++ b/third_party/JSON/JSON-2.59.tar.gz.sha1 @@ -0,0 +1 @@ +8a82c442088ffa0d605747fd5e65f51e037aad94 JSON-2.59.tar.gz diff --git a/third_party/JSON/JSON-2.59/Changes b/third_party/JSON/JSON-2.59/Changes new file mode 100644 index 0000000..ee2e784 --- /dev/null +++ b/third_party/JSON/JSON-2.59/Changes @@ -0,0 +1,372 @@ +Revision history for Perl extension JSON. + +## JSON version 2.xx ##################################################### + +From version 1.xx to 2.xx, JSON was totally rewritten. + + * JSON becomes a wrapper to JSON::XS or JSON::PP! + * objToJson() and jsonToObj() are obsoleted! + * $JSON::* variables are no longer available! + * JSON::Parser and JSON::Converter are deleted from the distribution! + * JSONRPC* and Apache::JSONRPC are deleted from the distribution! + Please check JSON::RPC (supports JSON-RPC protocol v1.1 and 1.0). + +########################################################################## + +2.59 Wed Jun 5 14:35:54 2013 + - PUREPERL_ONLY support was not supported... + and finally remove all PP options from Makefile.PL. + - recommend JSON::XS instead of conditionally requiring it + patched by miyagaw + ( for example, $ cpanm --with-recommends JSON) + - Hide more packages from PAUSE (and other stuff) + patched by miyagawa + +2.58 Thu May 23 09:04:37 2013 + - support PUREPERL_ONLY install option. (rt#84876) + (PERL_ONLY and NO_XS are not yet removed) + - stop installing JSON::XS automatically on Perl 5.18 + +2.57 + - t/x17_strage_overload.t didn't work correctly. + +2.56 Sat Apr 6 09:58:32 2013 + - fixed t/x17_strage_overload.t (rt#84451 by Ricardo Signes) + +2.55 + - update JSON::BackportPP version + +2.54 Fri Apr 5 16:15:08 2013 + - fixed t/19_incr.t on perl >= 5.17.10 (wyant, rt#84154) + pathced by mbeijen and modified with demerphq's patch + - Fixed some spelling (by briandfoy) + - fixed sppeling (by Perlover) + - enhanced documents (Thanks to Justin Hunter and Olof Johansson) + - changed backend module loading for overloaded object behavior + (reported by tokuhirom) + +2.53 Sun May 22 16:11:05 2011 + - made Makefile.PL skipping a installing XS question + when set $ENV{PERL_ONLY} or $ENV{NO_XS} (rt#66820) + +2.52 Sun May 22 15:05:49 2011 + - fixed to_json (pointed and patched by mmcleric in rt#68359) + - backport JSON::PP 2.27200 + * fixed incr_parse docodeing string more correctly (rt#68032 by LCONS) + +2.51 Tue Mar 8 16:03:34 2011 + - import JSON::PP 2.27105 as BackportPP + - fixed documentations (pointed by Britton Kerin and rt#64738) + +2.50 Mon Dec 20 14:56:42 2010 + [JSON] + - stable release + +2.49_01 Sat Nov 27 22:03:17 2010 + [JSON] + - JSON::PP is split away JSON distributino for perl 5.14 + - JSON::backportPP is included in instead. + +2.27 Sun Oct 31 20:32:46 2010 + [JSON::PP] + - Some optimizations (gfx) + [JSON::PP::5005] + - added missing B module varibales (makamaka) + +2.26 Tue Sep 28 17:41:37 2010 + [JSON::PP] + - cleaned up code and enhanced sort option efficiency in encode. + +2.25 Tue Sep 28 16:47:08 2010 + [JSON] + - JSON::Backend::XS::Supportable always executed a needless process + with JSON::XS backend. This made encode/decode a bit slower. + +2.24 Mon Sep 27 10:56:24 2010 + [JSON::PP] + - tweaked code. + - optimized code in hash object encoding. + +2.23 Sun Sep 26 22:08:12 2010 + [JSON::PP] + - modified tied object handling in encode. it made encoding speed faster. + pointed by https://rt.cpan.org/Ticket/Display.html?id=61604 + - modified t/e10_bignum.t + for avoiding a warning in using Math::BigInt dev version + +2.22 Wed Aug 25 12:46:13 2010 + [JSON] + - added JSON::XS installing feature in Makefile.PL + with cpan or cpanm (some points suggested by gfx) + - check that to_json and from_json are not called as methods (CHORNY) + [JSON::PP] + - modified for -Duse64bitall -Duselongdouble compiled perl. + 11_pc_expo.t too. (these are patched by H.Merijn Brand) + +2.21 Mon Apr 5 14:56:52 2010 + [JSON] + - enhanced 'HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER' + - renamed eg/bench_pp_xs.pl to eg/bench_decode.pl + - added eg/bench_encode.pl + +2.20 Fri Apr 2 12:50:08 2010 + [JSON] + - added eg/bench_pp_xs.pl for benchmark sample + - updated 'INCREMENTAL PARSING' section + [JSON::PP] + - decode_prefix() didn't count a consumed text length properly. + - enhanced XS compatibilty + in the case of decoding a white space garbaged text. + +2.19 Tue Mar 30 13:40:24 2010 + [JSON] + - fixed typo (rt#53535 by Angel Abad) + - added a recommendation + refering to (en|de)code_json to pod (suggested by tokuhirom) + - added 'HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER' to pod. + +2.18 Tue Mar 23 15:18:10 2010 + [JSON] + - updated document (compatible with JSON::XS 2.29) + [JSON::PP] + - fixed encode an overloaded 'eq' object bug (reported by Alexey A. Kiritchun) + - enhanced an error message compatible to JSON::XS + +2.17 Thu Jan 7 12:23:13 2010 + [JSON] + - fixed a problem caused by JSON::XS backend and support_by_pp option + (rt#52842, rt#52847 by ikegami) + [JSON::PP] + - made compatible with JSON::XS 2.27 + - patched decode for incr_parse (rt#52820 by ikegami) + - relaxed option caused an infinite loop in some condition. + +2.16 Fri Oct 16 15:07:37 2009 + [JSON][JSON::PP] + - made compatible with JSON::XS 2.26 + *indent adds a final newline + - corrected copyrights in JSON::PP58. + +2.15 Tue Jun 2 16:36:42 2009 + [JSON] + - made compatible with JSON::XS 2.24 + - corrected copyrights in some modules. + [JSON::PP] + - modified incr_parse, pointed by Martin J. Evans (rt#46439) + - deleted a meaningless code + +2.14 Tue Feb 24 11:20:24 2009 + [JSON] + - the compatible XS version was miswritten in document. + +2.13 Sat Feb 21 17:01:05 2009 + [JSON::PP] + - decode() didn't upgrade unicode escaped charcters \u0080-\u00ff. + this problem was pointed by rt#43424 (Mika Raento) + [JSON::PP::56] + - fixed utf8::encode/decode emulators bugs. + - defined a missing B module constant in Perl 5.6.0. + (reported by Clinton Pierce) + [JSON::PP::5005] + - _decode_unicode() returned a 0x80-0xff value as UTF8 encoded byte. + [JSON] + - added a refference to JSON::XS's document "JSON and ECMAscript". + - fixed a typo in the document (pointed by Jim Cromie). + +2.12 Wed Jul 16 11:14:35 2008 + [JSON] + - made compatible with JSON::XS 2.22 + + [JSON::PP] + - fixed the incremental parser in negative nest level + (pointed and patched by Yuval Kogman) + +2.11 Tue Jun 17 14:30:01 2008 + [JSON::PP] + - fixed the decoding process which checks number. + regarded number like chars in Unicode (ex. U+FF11) as [\d]. + - enhanced error messages compatible to JSON::XS. + +2.10 Tue Jun 3 18:42:11 2008 + [JSON] + - made compatible with JSON::XS 2.21 + * updated the document. + - added an item pointed by rt#32361 to the doc. + + [JSON::PP] [JSON::PP58] [JSON::PP56] [JSON::PP5005] + - made compatible with JSON::XS 2.21 + * added incr_reset + - removed useless codes. + +2.09 Sun Apr 20 20:45:33 2008 + [JSON] + - made compatible with JSON::XS 2.2 + - changed pod section totally. + + [JSON::PP] 2.20001 + - made compatible witg JSON::XS 2.2 + * lifted the log2 rounding restriction of max_depth and max_size. + * incremental json parsing (EXPERIMENTAL). + * allow_unknown/get_allow_unknown methods. + - the version format was changed. + X.YYZZZ => X.YY is the same as JSON::XS. ZZZ is the PP own version. + - changed pod section totally. + +2.08 Sat Apr 12 22:49:39 2008 + [JSON] + - fixed JSON::Boolean inheritance mechanism. + If the backend is XS with support_by_pp mode and using PP only + support method, JSON::Boolean did not work correctly. + Thanks to hg[at]apteryx's point. + + [JSON::PP] 2.07 + - Now split into JSON::PP58 for Perl 5.8 and lator. + - enhanced an error message compatible to JSON::XS + did not croak when TO_JSON method returns same object as passed. + + [JSON::PP58] + - modified for Perls post 5.8.0 that don't have utf8::is_utf8. + Thanks to Andreas Koenig. + +2.07 Sat Feb 16 15:52:29 2008 + [JSON] + - experimentally added -convert_blessed_universally to define + UNIVERSAL::TO_JSON subroutine. + + use JSON -convert_blessed_universally; + $json->convert_blessed->encode( $blessed ); + + - and as_nonbleesed is obsoleted (not yet removed). OK? + - fixed t/04_pretty.t. + +2.06 Fri Feb 8 16:21:59 2008 + [JSON::PP] 2.06 + - enhanced the XS compatibility for pretty-printing + and the indent handling was broken! + +2.05 Tue Feb 5 13:57:19 2008 + [JSON::PP] 2.05 + - enhanced some XS compatibilities for de/encode. + - now decode_error can dump high (>127) chars. + - enhanced the XS combatilbity of the decoding error. + - fixed the utf8 checker while decoding (is_valid_utf8). + - implemented utf8::downgrade in JSON::PP56. + - enhanced utf8::encode in JSON::PP56. + - made utf8::downgrade return a true in JSON::PP5005. + +2.04 Sat Jan 5 16:10:01 2008 + [JSON] + - fixed a document typo pointed by kawasaki@annocpan + - make DATA handle closed for error mssages in support_by_pp mode. + - switched JSON::Backend::XS::Supportable wrapper de/encode + to changing symbolic tables for croak messages and speed. + - fixed support_by_pp setting + + [JSON::PP] 2.04 + - enhanced the error message compatiblity to XS. + +2.03 Fri Jan 4 14:10:58 2008 + [JSON] + - fixed the description - Transition ways from 1.xx to 2.xx. + $JSON::ConvBlessed compat => $json->allow_blessed->as_nonbleesed + - support_by_pp supports 'as_nonbleesed' (experimental) + - clean up the code for saving memory + + [JSON::PP] 2.03 + - Now the allo_bignum flag also affects the encoding process. + encode() can convert Math::BigInt/Float objects into JSON numbers + - added as_nonblessed option (experimental) + - cleaned up internal function names (renamed camel case names) + +2.02 Wed Dec 26 11:08:19 2007 + [JSON] + - Now support_by_pp allows to use indent_length() + + [JSON::PP] 2.02 + - added get_indent_length + +2.01 Thu Dec 20 11:30:59 2007 + [JSON] + - made the object methods - jsonToObj and objToJson + available for a while with warnings. + +2.00 Wed Dec 19 11:48:04 2007 + [JSON] + - new version! + - modified Makefile.PL for broken Perls (when PERL_DL_NONLAZY = 1). + + [JSON::PP] 2.0104 + - clean up the document. + - use 'subs' instead of CORE::GLOBAL for fixing join() in 5.8.0 - 5.8.2 + - enhanced decoding error messages for JSON::XS compatibility. + - jsonToObj and objToJson warn. + + +1.99_05 Fri Dec 14 18:30:43 2007 + [JSON] + - added a description about the Unicode handling to document. + + [JSON::PP] (2.0103) + - Now the JSON::PP56 unicode handling does not require Unicode::String. + - Now JSON::PP5005 can de/enocde properly within the Perl 5.005 world. + - decode() always utf8::decode()ed to strings. + - decode() returned a big integer as string though the integer is + smaller than it is so. + - a bad know how - added the join() wrapper for Perl 5.8.0 - 5.8.2 bug. + - JSON::PP56 encode() did not handle Unicode properly. + - added a section about the unicode handling on Perls to JSON::PP doc. + +1.99_04 Mon Dec 10 14:28:15 2007 + [JSON] + - modified the tests and source for Perl 5.005 + + [JSON::PP] (2.0102) + - modified some prototypes in JSON::PP5005. + +1.99_03 Mon Dec 10 11:43:02 2007 + [JSON] + - modified tests and document. + in Perl5.8.2 or earlier, decoding with utf8 is broken because of + a Perl side problem. (join() had a bug.) + - modified Makefile.PL for Perl 5.005. + in the version, 'require JSON' is fail.... + + [JSON::PP] (2.0102) + - modified string decode function. + - enhanced error messages for compatibility to JSON::XS. + - enhanced utf8::decode emulator and unpack emulator in JSON::PP56. + +1.99_02 Sun Dec 9 05:06:19 2007 + [JSON::PP] (2.0101) + - decoding with utf8 was broken in Perl 5.10 + as the behaviour of unpack was changed. + - added a fake in JSON::PP5005 (bytes.pm) + - added the missing file JONS::PP::Boolean.pm + +1.99_01 Sat Dec 8 12:01:43 2007 + [JSON] + - released as version 2.0 + this module is incompatible to 1.xx, so check the document. + + [JSON::PP] (2.01 from 0.97) + - updated JSON::PP for compatible to JSON::XS 2.01 + - renamed from_json and to_json to decode_json and encode_json + - added get_* to JSON::PP + - deleted property() from JSON::PP + - deleted strict() and added loose() + - deleted disable_UTF8() and self_encode() + - renamed singlequote to allow_singlequote + - renamed allow_bigint to allow_bignum + - max_depth and max_size round up their arguments. + - added indent_length and sort_by + + +## JSON version 1.xx + +1.15 Wed Nov 14 14:52:31 2007 + - 1.xx final version. + +0.09 Sat Apr 9 15:27:47 2005 + - original version; created by h2xs 1.22 with options + -XA -b 5.5.3 -n JSON + diff --git a/third_party/JSON/JSON-2.59/MANIFEST b/third_party/JSON/JSON-2.59/MANIFEST new file mode 100644 index 0000000..d4f803b --- /dev/null +++ b/third_party/JSON/JSON-2.59/MANIFEST @@ -0,0 +1,71 @@ +Changes +eg/bench_decode.pl +eg/bench_encode.pl +lib/JSON.pm +lib/JSON/backportPP.pm +lib/JSON/backportPP/Boolean.pm +lib/JSON/backportPP/Compat5005.pm +lib/JSON/backportPP/Compat5006.pm +Makefile.PL +MANIFEST +META.yml Module meta-data (added by MakeMaker) +README +t/00_load.t +t/00_pod.t +t/01_utf8.t +t/02_error.t +t/03_types.t +t/06_pc_pretty.t +t/07_pc_esc.t +t/08_pc_base.t +t/09_pc_extra_number.t +t/10_pc_keysort.t +t/11_pc_expo.t +t/12_blessed.t +t/13_limit.t +t/14_latin1.t +t/15_prefix.t +t/16_tied.t +t/17_relaxed.t +t/18_json_checker.t +t/19_incr.t +t/20_unknown.t +t/21_evans_bugrep.t +t/22_comment_at_eof.t +t/99_binary.t +t/_unicode_handling.pm +t/e00_func.t +t/e01_property.t +t/e02_bool.t +t/e03_bool2.t +t/e04_sortby.t +t/e05_esc_slash.t +t/e06_allow_barekey.t +t/e07_allow_singlequote.t +t/e08_decode.t +t/e09_encode.t +t/e10_bignum.t +t/e11_conv_blessed_univ.t +t/e12_upgrade.t +t/e13_overloaded_eq.t +t/e14_decode_prefix.t +t/e15_tie_ixhash.t +t/e16_incr_parse_fixed.t +t/e90_misc.t +t/x00_load.t +t/x02_error.t +t/x12_blessed.t +t/x16_tied.t +t/x17_strange_overload.t +t/xe01_property.t +t/xe02_bool.t +t/xe03_bool2.t +t/xe04support_by_pp.t +t/xe05_indent_length.t +t/xe08_decode.t +t/xe10_bignum.t +t/xe11_conv_blessed_univ.t +t/xe12_boolean.t +t/xe19_xs_and_suportbypp.t +t/xe20_croak_message.t +META.json Module JSON meta-data (added by MakeMaker) diff --git a/third_party/JSON/JSON-2.59/META.json b/third_party/JSON/JSON-2.59/META.json new file mode 100644 index 0000000..8f02346 --- /dev/null +++ b/third_party/JSON/JSON-2.59/META.json @@ -0,0 +1,49 @@ +{ + "abstract" : "JSON (JavaScript Object Notation) encoder/decoder", + "author" : [ + "Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>" + ], + "dynamic_config" : 1, + "generated_by" : "ExtUtils::MakeMaker version 6.62, CPAN::Meta::Converter version 2.130880", + "license" : [ + "perl_5" + ], + "meta-spec" : { + "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", + "version" : "2" + }, + "name" : "JSON", + "no_index" : { + "directory" : [ + "t", + "inc" + ] + }, + "prereqs" : { + "build" : { + "requires" : { + "ExtUtils::MakeMaker" : "0" + } + }, + "configure" : { + "requires" : { + "ExtUtils::MakeMaker" : "0" + } + }, + "runtime" : { + "recommends" : { + "JSON::XS" : "2.34" + }, + "requires" : { + "Test::More" : "0" + } + } + }, + "release_status" : "stable", + "resources" : { + "repository" : { + "url" : "https://github.com/makamaka/JSON" + } + }, + "version" : "2.59" +} diff --git a/third_party/JSON/JSON-2.59/META.yml b/third_party/JSON/JSON-2.59/META.yml new file mode 100644 index 0000000..c85fce1 --- /dev/null +++ b/third_party/JSON/JSON-2.59/META.yml @@ -0,0 +1,26 @@ +--- +abstract: 'JSON (JavaScript Object Notation) encoder/decoder' +author: + - 'Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>' +build_requires: + ExtUtils::MakeMaker: 0 +configure_requires: + ExtUtils::MakeMaker: 0 +dynamic_config: 1 +generated_by: 'ExtUtils::MakeMaker version 6.62, CPAN::Meta::Converter version 2.130880' +license: perl +meta-spec: + url: http://module-build.sourceforge.net/META-spec-v1.4.html + version: 1.4 +name: JSON +no_index: + directory: + - t + - inc +recommends: + JSON::XS: 2.34 +requires: + Test::More: 0 +resources: + repository: https://github.com/makamaka/JSON +version: 2.59 diff --git a/third_party/JSON/JSON-2.59/MYMETA.yml b/third_party/JSON/JSON-2.59/MYMETA.yml new file mode 100644 index 0000000..2b513fd --- /dev/null +++ b/third_party/JSON/JSON-2.59/MYMETA.yml @@ -0,0 +1,27 @@ +--- +abstract: 'JSON (JavaScript Object Notation) encoder/decoder' +author: + - 'Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>' +build_requires: + ExtUtils::MakeMaker: 0 +configure_requires: + ExtUtils::MakeMaker: 0 +distribution_type: module +dynamic_config: 0 +generated_by: 'ExtUtils::MakeMaker version 6.57_05' +license: perl +meta-spec: + url: http://module-build.sourceforge.net/META-spec-v1.4.html + version: 1.4 +name: JSON +no_index: + directory: + - t + - inc +recommends: + JSON::XS: 2.34 +requires: + Test::More: 0 +resources: + repository: https://github.com/makamaka/JSON +version: 2.59 diff --git a/third_party/JSON/JSON-2.59/Makefile b/third_party/JSON/JSON-2.59/Makefile new file mode 100644 index 0000000..62326ef --- /dev/null +++ b/third_party/JSON/JSON-2.59/Makefile @@ -0,0 +1,823 @@ +# This Makefile is for the JSON extension to perl. +# +# It was generated automatically by MakeMaker version +# 6.57_05 (Revision: 65705) from the contents of +# Makefile.PL. Don't edit this file, edit Makefile.PL instead. +# +# ANY CHANGES MADE HERE WILL BE LOST! +# +# MakeMaker ARGV: (q[INSTALL_BASE=/w/chr/src/third_party/JSON/out]) +# + +# MakeMaker Parameters: + +# ABSTRACT_FROM => q[lib/JSON.pm] +# AUTHOR => [q[Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>]] +# BUILD_REQUIRES => { } +# LICENSE => q[perl] +# META_MERGE => { resources=>{ repository=>q[https://github.com/makamaka/JSON] }, recommends=>{ JSON::XS=>q[2.34] } } +# NAME => q[JSON] +# PREREQ_PM => { Test::More=>q[0] } +# VERSION_FROM => q[lib/JSON.pm] + +# --- MakeMaker post_initialize section: + + +# --- MakeMaker const_config section: + +# These definitions are from config.sh (via /usr/lib/perl/5.14/Config.pm). +# They may have been overridden via Makefile.PL or on the command line. +AR = ar +CC = cc +CCCDLFLAGS = -fPIC +CCDLFLAGS = -Wl,-E +DLEXT = so +DLSRC = dl_dlopen.xs +EXE_EXT = +FULL_AR = /usr/bin/ar +LD = cc +LDDLFLAGS = -shared -O2 -g -L/usr/local/lib -fstack-protector +LDFLAGS = -fstack-protector -L/usr/local/lib +LIBC = +LIB_EXT = .a +OBJ_EXT = .o +OSNAME = linux +OSVERS = 2.6.42-37-generic +RANLIB = : +SITELIBEXP = /usr/local/share/perl/5.14.2 +SITEARCHEXP = /usr/local/lib/perl/5.14.2 +SO = so +VENDORARCHEXP = /usr/lib/perl5 +VENDORLIBEXP = /usr/share/perl5 + + +# --- MakeMaker constants section: +AR_STATIC_ARGS = cr +DIRFILESEP = / +DFSEP = $(DIRFILESEP) +NAME = JSON +NAME_SYM = JSON +VERSION = 2.59 +VERSION_MACRO = VERSION +VERSION_SYM = 2_59 +DEFINE_VERSION = -D$(VERSION_MACRO)=\"$(VERSION)\" +XS_VERSION = 2.59 +XS_VERSION_MACRO = XS_VERSION +XS_DEFINE_VERSION = -D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\" +INST_ARCHLIB = blib/arch +INST_SCRIPT = blib/script +INST_BIN = blib/bin +INST_LIB = blib/lib +INST_MAN1DIR = blib/man1 +INST_MAN3DIR = blib/man3 +MAN1EXT = 1p +MAN3EXT = 3pm +INSTALLDIRS = site +INSTALL_BASE = /w/chr/src/third_party/JSON/out +DESTDIR = +PREFIX = $(INSTALL_BASE) +INSTALLPRIVLIB = $(INSTALL_BASE)/lib/perl5 +DESTINSTALLPRIVLIB = $(DESTDIR)$(INSTALLPRIVLIB) +INSTALLSITELIB = $(INSTALL_BASE)/lib/perl5 +DESTINSTALLSITELIB = $(DESTDIR)$(INSTALLSITELIB) +INSTALLVENDORLIB = $(INSTALL_BASE)/lib/perl5 +DESTINSTALLVENDORLIB = $(DESTDIR)$(INSTALLVENDORLIB) +INSTALLARCHLIB = $(INSTALL_BASE)/lib/perl5/x86_64-linux-gnu-thread-multi +DESTINSTALLARCHLIB = $(DESTDIR)$(INSTALLARCHLIB) +INSTALLSITEARCH = $(INSTALL_BASE)/lib/perl5/x86_64-linux-gnu-thread-multi +DESTINSTALLSITEARCH = $(DESTDIR)$(INSTALLSITEARCH) +INSTALLVENDORARCH = $(INSTALL_BASE)/lib/perl5/x86_64-linux-gnu-thread-multi +DESTINSTALLVENDORARCH = $(DESTDIR)$(INSTALLVENDORARCH) +INSTALLBIN = $(INSTALL_BASE)/bin +DESTINSTALLBIN = $(DESTDIR)$(INSTALLBIN) +INSTALLSITEBIN = $(INSTALL_BASE)/bin +DESTINSTALLSITEBIN = $(DESTDIR)$(INSTALLSITEBIN) +INSTALLVENDORBIN = $(INSTALL_BASE)/bin +DESTINSTALLVENDORBIN = $(DESTDIR)$(INSTALLVENDORBIN) +INSTALLSCRIPT = $(INSTALL_BASE)/bin +DESTINSTALLSCRIPT = $(DESTDIR)$(INSTALLSCRIPT) +INSTALLSITESCRIPT = $(INSTALL_BASE)/bin +DESTINSTALLSITESCRIPT = $(DESTDIR)$(INSTALLSITESCRIPT) +INSTALLVENDORSCRIPT = $(INSTALL_BASE)/bin +DESTINSTALLVENDORSCRIPT = $(DESTDIR)$(INSTALLVENDORSCRIPT) +INSTALLMAN1DIR = $(INSTALL_BASE)/man/man1 +DESTINSTALLMAN1DIR = $(DESTDIR)$(INSTALLMAN1DIR) +INSTALLSITEMAN1DIR = $(INSTALL_BASE)/man/man1 +DESTINSTALLSITEMAN1DIR = $(DESTDIR)$(INSTALLSITEMAN1DIR) +INSTALLVENDORMAN1DIR = $(INSTALL_BASE)/man/man1 +DESTINSTALLVENDORMAN1DIR = $(DESTDIR)$(INSTALLVENDORMAN1DIR) +INSTALLMAN3DIR = $(INSTALL_BASE)/man/man3 +DESTINSTALLMAN3DIR = $(DESTDIR)$(INSTALLMAN3DIR) +INSTALLSITEMAN3DIR = $(INSTALL_BASE)/man/man3 +DESTINSTALLSITEMAN3DIR = $(DESTDIR)$(INSTALLSITEMAN3DIR) +INSTALLVENDORMAN3DIR = $(INSTALL_BASE)/man/man3 +DESTINSTALLVENDORMAN3DIR = $(DESTDIR)$(INSTALLVENDORMAN3DIR) +PERL_LIB = /usr/share/perl/5.14 +PERL_ARCHLIB = /usr/lib/perl/5.14 +LIBPERL_A = libperl.a +FIRST_MAKEFILE = Makefile +MAKEFILE_OLD = Makefile.old +MAKE_APERL_FILE = Makefile.aperl +PERLMAINCC = $(CC) +PERL_INC = /usr/lib/perl/5.14/CORE +PERL = /usr/bin/perl +FULLPERL = /usr/bin/perl +ABSPERL = $(PERL) +PERLRUN = $(PERL) +FULLPERLRUN = $(FULLPERL) +ABSPERLRUN = $(ABSPERL) +PERLRUNINST = $(PERLRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" +FULLPERLRUNINST = $(FULLPERLRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" +ABSPERLRUNINST = $(ABSPERLRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" +PERL_CORE = 0 +PERM_DIR = 755 +PERM_RW = 644 +PERM_RWX = 755 + +MAKEMAKER = /usr/share/perl/5.14/ExtUtils/MakeMaker.pm +MM_VERSION = 6.57_05 +MM_REVISION = 65705 + +# FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle). +# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle) +# PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar) +# DLBASE = Basename part of dynamic library. May be just equal BASEEXT. +MAKE = make +FULLEXT = JSON +BASEEXT = JSON +PARENT_NAME = +DLBASE = $(BASEEXT) +VERSION_FROM = lib/JSON.pm +OBJECT = +LDFROM = $(OBJECT) +LINKTYPE = dynamic +BOOTDEP = + +# Handy lists of source code files: +XS_FILES = +C_FILES = +O_FILES = +H_FILES = +MAN1PODS = +MAN3PODS = lib/JSON.pm \ + lib/JSON/backportPP.pm \ + lib/JSON/backportPP/Boolean.pm \ + lib/JSON/backportPP/Compat5005.pm \ + lib/JSON/backportPP/Compat5006.pm + +# Where is the Config information that we are using/depend on +CONFIGDEP = $(PERL_ARCHLIB)$(DFSEP)Config.pm $(PERL_INC)$(DFSEP)config.h + +# Where to build things +INST_LIBDIR = $(INST_LIB) +INST_ARCHLIBDIR = $(INST_ARCHLIB) + +INST_AUTODIR = $(INST_LIB)/auto/$(FULLEXT) +INST_ARCHAUTODIR = $(INST_ARCHLIB)/auto/$(FULLEXT) + +INST_STATIC = +INST_DYNAMIC = +INST_BOOT = + +# Extra linker info +EXPORT_LIST = +PERL_ARCHIVE = +PERL_ARCHIVE_AFTER = + + +TO_INST_PM = lib/JSON.pm \ + lib/JSON/backportPP.pm \ + lib/JSON/backportPP/Boolean.pm \ + lib/JSON/backportPP/Compat5005.pm \ + lib/JSON/backportPP/Compat5006.pm + +PM_TO_BLIB = lib/JSON/backportPP/Compat5005.pm \ + blib/lib/JSON/backportPP/Compat5005.pm \ + lib/JSON.pm \ + blib/lib/JSON.pm \ + lib/JSON/backportPP/Boolean.pm \ + blib/lib/JSON/backportPP/Boolean.pm \ + lib/JSON/backportPP/Compat5006.pm \ + blib/lib/JSON/backportPP/Compat5006.pm \ + lib/JSON/backportPP.pm \ + blib/lib/JSON/backportPP.pm + + +# --- MakeMaker platform_constants section: +MM_Unix_VERSION = 6.57_05 +PERL_MALLOC_DEF = -DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc -Dfree=Perl_mfree -Drealloc=Perl_realloc -Dcalloc=Perl_calloc + + +# --- MakeMaker tool_autosplit section: +# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto +AUTOSPLITFILE = $(ABSPERLRUN) -e 'use AutoSplit; autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1)' -- + + + +# --- MakeMaker tool_xsubpp section: + + +# --- MakeMaker tools_other section: +SHELL = /bin/sh +CHMOD = chmod +CP = cp +MV = mv +NOOP = $(TRUE) +NOECHO = @ +RM_F = rm -f +RM_RF = rm -rf +TEST_F = test -f +TOUCH = touch +UMASK_NULL = umask 0 +DEV_NULL = > /dev/null 2>&1 +MKPATH = $(ABSPERLRUN) -MExtUtils::Command -e 'mkpath' -- +EQUALIZE_TIMESTAMP = $(ABSPERLRUN) -MExtUtils::Command -e 'eqtime' -- +FALSE = false +TRUE = true +ECHO = echo +ECHO_N = echo -n +UNINST = 0 +VERBINST = 0 +MOD_INSTALL = $(ABSPERLRUN) -MExtUtils::Install -e 'install([ from_to => {@ARGV}, verbose => '\''$(VERBINST)'\'', uninstall_shadows => '\''$(UNINST)'\'', dir_mode => '\''$(PERM_DIR)'\'' ]);' -- +DOC_INSTALL = $(ABSPERLRUN) -MExtUtils::Command::MM -e 'perllocal_install' -- +UNINSTALL = $(ABSPERLRUN) -MExtUtils::Command::MM -e 'uninstall' -- +WARN_IF_OLD_PACKLIST = $(ABSPERLRUN) -MExtUtils::Command::MM -e 'warn_if_old_packlist' -- +MACROSTART = +MACROEND = +USEMAKEFILE = -f +FIXIN = $(ABSPERLRUN) -MExtUtils::MY -e 'MY->fixin(shift)' -- + + +# --- MakeMaker makemakerdflt section: +makemakerdflt : all + $(NOECHO) $(NOOP) + + +# --- MakeMaker dist section: +TAR = tar +TARFLAGS = cvf +ZIP = zip +ZIPFLAGS = -r +COMPRESS = gzip --best +SUFFIX = .gz +SHAR = shar +PREOP = $(NOECHO) $(NOOP) +POSTOP = $(NOECHO) $(NOOP) +TO_UNIX = $(NOECHO) $(NOOP) +CI = ci -u +RCS_LABEL = rcs -Nv$(VERSION_SYM): -q +DIST_CP = best +DIST_DEFAULT = tardist +DISTNAME = JSON +DISTVNAME = JSON-2.59 + + +# --- MakeMaker macro section: + + +# --- MakeMaker depend section: + + +# --- MakeMaker cflags section: + + +# --- MakeMaker const_loadlibs section: + + +# --- MakeMaker const_cccmd section: + + +# --- MakeMaker post_constants section: + + +# --- MakeMaker pasthru section: + +PASTHRU = LIBPERL_A="$(LIBPERL_A)"\ + LINKTYPE="$(LINKTYPE)"\ + PREFIX="$(PREFIX)"\ + INSTALL_BASE="$(INSTALL_BASE)" + + +# --- MakeMaker special_targets section: +.SUFFIXES : .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT) + +.PHONY: all config static dynamic test linkext manifest blibdirs clean realclean disttest distdir + + + +# --- MakeMaker c_o section: + + +# --- MakeMaker xs_c section: + + +# --- MakeMaker xs_o section: + + +# --- MakeMaker top_targets section: +all :: pure_all manifypods + $(NOECHO) $(NOOP) + + +pure_all :: config pm_to_blib subdirs linkext + $(NOECHO) $(NOOP) + +subdirs :: $(MYEXTLIB) + $(NOECHO) $(NOOP) + +config :: $(FIRST_MAKEFILE) blibdirs + $(NOECHO) $(NOOP) + +help : + perldoc ExtUtils::MakeMaker + + +# --- MakeMaker blibdirs section: +blibdirs : $(INST_LIBDIR)$(DFSEP).exists $(INST_ARCHLIB)$(DFSEP).exists $(INST_AUTODIR)$(DFSEP).exists $(INST_ARCHAUTODIR)$(DFSEP).exists $(INST_BIN)$(DFSEP).exists $(INST_SCRIPT)$(DFSEP).exists $(INST_MAN1DIR)$(DFSEP).exists $(INST_MAN3DIR)$(DFSEP).exists + $(NOECHO) $(NOOP) + +# Backwards compat with 6.18 through 6.25 +blibdirs.ts : blibdirs + $(NOECHO) $(NOOP) + +$(INST_LIBDIR)$(DFSEP).exists :: Makefile.PL + $(NOECHO) $(MKPATH) $(INST_LIBDIR) + $(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_LIBDIR) + $(NOECHO) $(TOUCH) $(INST_LIBDIR)$(DFSEP).exists + +$(INST_ARCHLIB)$(DFSEP).exists :: Makefile.PL + $(NOECHO) $(MKPATH) $(INST_ARCHLIB) + $(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_ARCHLIB) + $(NOECHO) $(TOUCH) $(INST_ARCHLIB)$(DFSEP).exists + +$(INST_AUTODIR)$(DFSEP).exists :: Makefile.PL + $(NOECHO) $(MKPATH) $(INST_AUTODIR) + $(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_AUTODIR) + $(NOECHO) $(TOUCH) $(INST_AUTODIR)$(DFSEP).exists + +$(INST_ARCHAUTODIR)$(DFSEP).exists :: Makefile.PL + $(NOECHO) $(MKPATH) $(INST_ARCHAUTODIR) + $(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_ARCHAUTODIR) + $(NOECHO) $(TOUCH) $(INST_ARCHAUTODIR)$(DFSEP).exists + +$(INST_BIN)$(DFSEP).exists :: Makefile.PL + $(NOECHO) $(MKPATH) $(INST_BIN) + $(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_BIN) + $(NOECHO) $(TOUCH) $(INST_BIN)$(DFSEP).exists + +$(INST_SCRIPT)$(DFSEP).exists :: Makefile.PL + $(NOECHO) $(MKPATH) $(INST_SCRIPT) + $(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_SCRIPT) + $(NOECHO) $(TOUCH) $(INST_SCRIPT)$(DFSEP).exists + +$(INST_MAN1DIR)$(DFSEP).exists :: Makefile.PL + $(NOECHO) $(MKPATH) $(INST_MAN1DIR) + $(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_MAN1DIR) + $(NOECHO) $(TOUCH) $(INST_MAN1DIR)$(DFSEP).exists + +$(INST_MAN3DIR)$(DFSEP).exists :: Makefile.PL + $(NOECHO) $(MKPATH) $(INST_MAN3DIR) + $(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_MAN3DIR) + $(NOECHO) $(TOUCH) $(INST_MAN3DIR)$(DFSEP).exists + + + +# --- MakeMaker linkext section: + +linkext :: $(LINKTYPE) + $(NOECHO) $(NOOP) + + +# --- MakeMaker dlsyms section: + + +# --- MakeMaker dynamic section: + +dynamic :: $(FIRST_MAKEFILE) $(INST_DYNAMIC) $(INST_BOOT) + $(NOECHO) $(NOOP) + + +# --- MakeMaker dynamic_bs section: + +BOOTSTRAP = + + +# --- MakeMaker dynamic_lib section: + + +# --- MakeMaker static section: + +## $(INST_PM) has been moved to the all: target. +## It remains here for awhile to allow for old usage: "make static" +static :: $(FIRST_MAKEFILE) $(INST_STATIC) + $(NOECHO) $(NOOP) + + +# --- MakeMaker static_lib section: + + +# --- MakeMaker manifypods section: + +POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--" +POD2MAN = $(POD2MAN_EXE) + + +manifypods : pure_all \ + lib/JSON/backportPP/Compat5005.pm \ + lib/JSON.pm \ + lib/JSON/backportPP/Boolean.pm \ + lib/JSON/backportPP/Compat5006.pm \ + lib/JSON/backportPP.pm + $(NOECHO) $(POD2MAN) --section=$(MAN3EXT) --perm_rw=$(PERM_RW) \ + lib/JSON/backportPP/Compat5005.pm $(INST_MAN3DIR)/JSON::backportPP::Compat5005.$(MAN3EXT) \ + lib/JSON.pm $(INST_MAN3DIR)/JSON.$(MAN3EXT) \ + lib/JSON/backportPP/Boolean.pm $(INST_MAN3DIR)/JSON::backportPP::Boolean.$(MAN3EXT) \ + lib/JSON/backportPP/Compat5006.pm $(INST_MAN3DIR)/JSON::backportPP::Compat5006.$(MAN3EXT) \ + lib/JSON/backportPP.pm $(INST_MAN3DIR)/JSON::backportPP.$(MAN3EXT) + + + + +# --- MakeMaker processPL section: + + +# --- MakeMaker installbin section: + + +# --- MakeMaker subdirs section: + +# none + +# --- MakeMaker clean_subdirs section: +clean_subdirs : + $(NOECHO) $(NOOP) + + +# --- MakeMaker clean section: + +# Delete temporary files but do not touch installed files. We don't delete +# the Makefile here so a later make realclean still has a makefile to use. + +clean :: clean_subdirs + - $(RM_F) \ + *$(LIB_EXT) core \ + core.[0-9] $(INST_ARCHAUTODIR)/extralibs.all \ + core.[0-9][0-9] $(BASEEXT).bso \ + pm_to_blib.ts core.[0-9][0-9][0-9][0-9] \ + MYMETA.yml $(BASEEXT).x \ + $(BOOTSTRAP) perl$(EXE_EXT) \ + tmon.out *$(OBJ_EXT) \ + pm_to_blib $(INST_ARCHAUTODIR)/extralibs.ld \ + blibdirs.ts core.[0-9][0-9][0-9][0-9][0-9] \ + *perl.core core.*perl.*.? \ + $(MAKE_APERL_FILE) $(BASEEXT).def \ + perl core.[0-9][0-9][0-9] \ + mon.out lib$(BASEEXT).def \ + perlmain.c perl.exe \ + so_locations $(BASEEXT).exp + - $(RM_RF) \ + blib + - $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) $(DEV_NULL) + + +# --- MakeMaker realclean_subdirs section: +realclean_subdirs : + $(NOECHO) $(NOOP) + + +# --- MakeMaker realclean section: +# Delete temporary files (via clean) and also delete dist files +realclean purge :: clean realclean_subdirs + - $(RM_F) \ + $(MAKEFILE_OLD) $(FIRST_MAKEFILE) + - $(RM_RF) \ + $(DISTVNAME) + + +# --- MakeMaker metafile section: +metafile : create_distdir + $(NOECHO) $(ECHO) Generating META.yml + $(NOECHO) $(ECHO) '--- #YAML:1.0' > META_new.yml + $(NOECHO) $(ECHO) 'name: JSON' >> META_new.yml + $(NOECHO) $(ECHO) 'version: 2.59' >> META_new.yml + $(NOECHO) $(ECHO) 'abstract: JSON (JavaScript Object Notation) encoder/decoder' >> META_new.yml + $(NOECHO) $(ECHO) 'author:' >> META_new.yml + $(NOECHO) $(ECHO) ' - Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>' >> META_new.yml + $(NOECHO) $(ECHO) 'license: perl' >> META_new.yml + $(NOECHO) $(ECHO) 'distribution_type: module' >> META_new.yml + $(NOECHO) $(ECHO) 'configure_requires:' >> META_new.yml + $(NOECHO) $(ECHO) ' ExtUtils::MakeMaker: 0' >> META_new.yml + $(NOECHO) $(ECHO) 'build_requires:' >> META_new.yml + $(NOECHO) $(ECHO) ' ExtUtils::MakeMaker: 0' >> META_new.yml + $(NOECHO) $(ECHO) 'requires:' >> META_new.yml + $(NOECHO) $(ECHO) ' Test::More: 0' >> META_new.yml + $(NOECHO) $(ECHO) 'resources:' >> META_new.yml + $(NOECHO) $(ECHO) ' repository: https://github.com/makamaka/JSON' >> META_new.yml + $(NOECHO) $(ECHO) 'no_index:' >> META_new.yml + $(NOECHO) $(ECHO) ' directory:' >> META_new.yml + $(NOECHO) $(ECHO) ' - t' >> META_new.yml + $(NOECHO) $(ECHO) ' - inc' >> META_new.yml + $(NOECHO) $(ECHO) 'generated_by: ExtUtils::MakeMaker version 6.57_05' >> META_new.yml + $(NOECHO) $(ECHO) 'meta-spec:' >> META_new.yml + $(NOECHO) $(ECHO) ' url: http://module-build.sourceforge.net/META-spec-v1.4.html' >> META_new.yml + $(NOECHO) $(ECHO) ' version: 1.4' >> META_new.yml + $(NOECHO) $(ECHO) 'recommends:' >> META_new.yml + $(NOECHO) $(ECHO) ' JSON::XS: 2.34' >> META_new.yml + -$(NOECHO) $(MV) META_new.yml $(DISTVNAME)/META.yml + + +# --- MakeMaker signature section: +signature : + cpansign -s + + +# --- MakeMaker dist_basics section: +distclean :: realclean distcheck + $(NOECHO) $(NOOP) + +distcheck : + $(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck + +skipcheck : + $(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck + +manifest : + $(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest + +veryclean : realclean + $(RM_F) *~ */*~ *.orig */*.orig *.bak */*.bak *.old */*.old + + + +# --- MakeMaker dist_core section: + +dist : $(DIST_DEFAULT) $(FIRST_MAKEFILE) + $(NOECHO) $(ABSPERLRUN) -l -e 'print '\''Warning: Makefile possibly out of date with $(VERSION_FROM)'\''' \ + -e ' if -e '\''$(VERSION_FROM)'\'' and -M '\''$(VERSION_FROM)'\'' < -M '\''$(FIRST_MAKEFILE)'\'';' -- + +tardist : $(DISTVNAME).tar$(SUFFIX) + $(NOECHO) $(NOOP) + +uutardist : $(DISTVNAME).tar$(SUFFIX) + uuencode $(DISTVNAME).tar$(SUFFIX) $(DISTVNAME).tar$(SUFFIX) > $(DISTVNAME).tar$(SUFFIX)_uu + +$(DISTVNAME).tar$(SUFFIX) : distdir + $(PREOP) + $(TO_UNIX) + $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME) + $(RM_RF) $(DISTVNAME) + $(COMPRESS) $(DISTVNAME).tar + $(POSTOP) + +zipdist : $(DISTVNAME).zip + $(NOECHO) $(NOOP) + +$(DISTVNAME).zip : distdir + $(PREOP) + $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME) + $(RM_RF) $(DISTVNAME) + $(POSTOP) + +shdist : distdir + $(PREOP) + $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar + $(RM_RF) $(DISTVNAME) + $(POSTOP) + + +# --- MakeMaker distdir section: +create_distdir : + $(RM_RF) $(DISTVNAME) + $(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \ + -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');" + +distdir : create_distdir distmeta + $(NOECHO) $(NOOP) + + + +# --- MakeMaker dist_test section: +disttest : distdir + cd $(DISTVNAME) && $(ABSPERLRUN) Makefile.PL "INSTALL_BASE=/w/chr/src/third_party/JSON/out" + cd $(DISTVNAME) && $(MAKE) $(PASTHRU) + cd $(DISTVNAME) && $(MAKE) test $(PASTHRU) + + + +# --- MakeMaker dist_ci section: + +ci : + $(PERLRUN) "-MExtUtils::Manifest=maniread" \ + -e "@all = keys %{ maniread() };" \ + -e "print(qq{Executing $(CI) @all\n}); system(qq{$(CI) @all});" \ + -e "print(qq{Executing $(RCS_LABEL) ...\n}); system(qq{$(RCS_LABEL) @all});" + + +# --- MakeMaker distmeta section: +distmeta : create_distdir metafile + $(NOECHO) cd $(DISTVNAME) && $(ABSPERLRUN) -MExtUtils::Manifest=maniadd -e 'eval { maniadd({q{META.yml} => q{Module meta-data (added by MakeMaker)}}) } ' \ + -e ' or print "Could not add META.yml to MANIFEST: $${'\''@'\''}\n"' -- + + + +# --- MakeMaker distsignature section: +distsignature : create_distdir + $(NOECHO) cd $(DISTVNAME) && $(ABSPERLRUN) -MExtUtils::Manifest=maniadd -e 'eval { maniadd({q{SIGNATURE} => q{Public-key signature (added by MakeMaker)}}) } ' \ + -e ' or print "Could not add SIGNATURE to MANIFEST: $${'\''@'\''}\n"' -- + $(NOECHO) cd $(DISTVNAME) && $(TOUCH) SIGNATURE + cd $(DISTVNAME) && cpansign -s + + + +# --- MakeMaker install section: + +install :: pure_install doc_install + $(NOECHO) $(NOOP) + +install_perl :: pure_perl_install doc_perl_install + $(NOECHO) $(NOOP) + +install_site :: pure_site_install doc_site_install + $(NOECHO) $(NOOP) + +install_vendor :: pure_vendor_install doc_vendor_install + $(NOECHO) $(NOOP) + +pure_install :: pure_$(INSTALLDIRS)_install + $(NOECHO) $(NOOP) + +doc_install :: doc_$(INSTALLDIRS)_install + $(NOECHO) $(NOOP) + +pure__install : pure_site_install + $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site + +doc__install : doc_site_install + $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site + +pure_perl_install :: all + $(NOECHO) umask 022; $(MOD_INSTALL) \ + $(INST_LIB) $(DESTINSTALLPRIVLIB) \ + $(INST_ARCHLIB) $(DESTINSTALLARCHLIB) \ + $(INST_BIN) $(DESTINSTALLBIN) \ + $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \ + $(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \ + $(INST_MAN3DIR) $(DESTINSTALLMAN3DIR) + $(NOECHO) $(WARN_IF_OLD_PACKLIST) \ + $(SITEARCHEXP)/auto/$(FULLEXT) + + +pure_site_install :: all + $(NOECHO) umask 02; $(MOD_INSTALL) \ + read $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist \ + write $(DESTINSTALLSITEARCH)/auto/$(FULLEXT)/.packlist \ + $(INST_LIB) $(DESTINSTALLSITELIB) \ + $(INST_ARCHLIB) $(DESTINSTALLSITEARCH) \ + $(INST_BIN) $(DESTINSTALLSITEBIN) \ + $(INST_SCRIPT) $(DESTINSTALLSITESCRIPT) \ + $(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \ + $(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR) + $(NOECHO) $(WARN_IF_OLD_PACKLIST) \ + $(PERL_ARCHLIB)/auto/$(FULLEXT) + +pure_vendor_install :: all + $(NOECHO) umask 022; $(MOD_INSTALL) \ + $(INST_LIB) $(DESTINSTALLVENDORLIB) \ + $(INST_ARCHLIB) $(DESTINSTALLVENDORARCH) \ + $(INST_BIN) $(DESTINSTALLVENDORBIN) \ + $(INST_SCRIPT) $(DESTINSTALLVENDORSCRIPT) \ + $(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \ + $(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR) + +doc_perl_install :: all + +doc_site_install :: all + $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLSITEARCH)/perllocal.pod + -$(NOECHO) umask 02; $(MKPATH) $(DESTINSTALLSITEARCH) + -$(NOECHO) umask 02; $(DOC_INSTALL) \ + "Module" "$(NAME)" \ + "installed into" "$(INSTALLSITELIB)" \ + LINKTYPE "$(LINKTYPE)" \ + VERSION "$(VERSION)" \ + EXE_FILES "$(EXE_FILES)" \ + >> $(DESTINSTALLSITEARCH)/perllocal.pod + +doc_vendor_install :: all + + +uninstall :: uninstall_from_$(INSTALLDIRS)dirs + $(NOECHO) $(NOOP) + +uninstall_from_perldirs :: + +uninstall_from_sitedirs :: + $(NOECHO) $(UNINSTALL) $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist + +uninstall_from_vendordirs :: + + + +# --- MakeMaker force section: +# Phony target to force checking subdirectories. +FORCE : + $(NOECHO) $(NOOP) + + +# --- MakeMaker perldepend section: + + +# --- MakeMaker makefile section: +# We take a very conservative approach here, but it's worth it. +# We move Makefile to Makefile.old here to avoid gnu make looping. +$(FIRST_MAKEFILE) : Makefile.PL $(CONFIGDEP) + $(NOECHO) $(ECHO) "Makefile out-of-date with respect to $?" + $(NOECHO) $(ECHO) "Cleaning current config before rebuilding Makefile..." + -$(NOECHO) $(RM_F) $(MAKEFILE_OLD) + -$(NOECHO) $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) + - $(MAKE) $(USEMAKEFILE) $(MAKEFILE_OLD) clean $(DEV_NULL) + $(PERLRUN) Makefile.PL "INSTALL_BASE=/w/chr/src/third_party/JSON/out" + $(NOECHO) $(ECHO) "==> Your Makefile has been rebuilt. <==" + $(NOECHO) $(ECHO) "==> Please rerun the $(MAKE) command. <==" + $(FALSE) + + + +# --- MakeMaker staticmake section: + +# --- MakeMaker makeaperl section --- +MAP_TARGET = perl +FULLPERL = /usr/bin/perl + +$(MAP_TARGET) :: static $(MAKE_APERL_FILE) + $(MAKE) $(USEMAKEFILE) $(MAKE_APERL_FILE) $@ + +$(MAKE_APERL_FILE) : $(FIRST_MAKEFILE) pm_to_blib + $(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET) + $(NOECHO) $(PERLRUNINST) \ + Makefile.PL DIR= \ + MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \ + MAKEAPERL=1 NORECURS=1 CCCDLFLAGS= \ + INSTALL_BASE=/w/chr/src/third_party/JSON/out + + +# --- MakeMaker test section: + +TEST_VERBOSE=0 +TEST_TYPE=test_$(LINKTYPE) +TEST_FILE = test.pl +TEST_FILES = t/*.t +TESTDB_SW = -d + +testdb :: testdb_$(LINKTYPE) + +test :: $(TEST_TYPE) subdirs-test + +subdirs-test :: + $(NOECHO) $(NOOP) + + +test_dynamic :: pure_all + PERL_DL_NONLAZY=1 $(FULLPERLRUN) "-MExtUtils::Command::MM" "-e" "test_harness($(TEST_VERBOSE), '$(INST_LIB)', '$(INST_ARCHLIB)')" $(TEST_FILES) + +testdb_dynamic :: pure_all + PERL_DL_NONLAZY=1 $(FULLPERLRUN) $(TESTDB_SW) "-I$(INST_LIB)" "-I$(INST_ARCHLIB)" $(TEST_FILE) + +test_ : test_dynamic + +test_static :: test_dynamic +testdb_static :: testdb_dynamic + + +# --- MakeMaker ppd section: +# Creates a PPD (Perl Package Description) for a binary distribution. +ppd : + $(NOECHO) $(ECHO) '<SOFTPKG NAME="$(DISTNAME)" VERSION="2.59">' > $(DISTNAME).ppd + $(NOECHO) $(ECHO) ' <ABSTRACT>JSON (JavaScript Object Notation) encoder/decoder</ABSTRACT>' >> $(DISTNAME).ppd + $(NOECHO) $(ECHO) ' <AUTHOR>Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt></AUTHOR>' >> $(DISTNAME).ppd + $(NOECHO) $(ECHO) ' <IMPLEMENTATION>' >> $(DISTNAME).ppd + $(NOECHO) $(ECHO) ' <REQUIRE NAME="Test::More" />' >> $(DISTNAME).ppd + $(NOECHO) $(ECHO) ' <ARCHITECTURE NAME="x86_64-linux-gnu-thread-multi-5.14" />' >> $(DISTNAME).ppd + $(NOECHO) $(ECHO) ' <CODEBASE HREF="" />' >> $(DISTNAME).ppd + $(NOECHO) $(ECHO) ' </IMPLEMENTATION>' >> $(DISTNAME).ppd + $(NOECHO) $(ECHO) '</SOFTPKG>' >> $(DISTNAME).ppd + + +# --- MakeMaker pm_to_blib section: + +pm_to_blib : $(FIRST_MAKEFILE) $(TO_INST_PM) + $(NOECHO) $(ABSPERLRUN) -MExtUtils::Install -e 'pm_to_blib({@ARGV}, '\''$(INST_LIB)/auto'\'', q[$(PM_FILTER)], '\''$(PERM_DIR)'\'')' -- \ + lib/JSON/backportPP/Compat5005.pm blib/lib/JSON/backportPP/Compat5005.pm \ + lib/JSON.pm blib/lib/JSON.pm \ + lib/JSON/backportPP/Boolean.pm blib/lib/JSON/backportPP/Boolean.pm \ + lib/JSON/backportPP/Compat5006.pm blib/lib/JSON/backportPP/Compat5006.pm \ + lib/JSON/backportPP.pm blib/lib/JSON/backportPP.pm + $(NOECHO) $(TOUCH) pm_to_blib + + +# --- MakeMaker selfdocument section: + + +# --- MakeMaker postamble section: + + +# End. diff --git a/third_party/JSON/JSON-2.59/Makefile.PL b/third_party/JSON/JSON-2.59/Makefile.PL new file mode 100644 index 0000000..a14ee3c --- /dev/null +++ b/third_party/JSON/JSON-2.59/Makefile.PL @@ -0,0 +1,77 @@ +require 5.00503; +use strict; +use ExtUtils::MakeMaker; + +use lib qw( ./lib ); + +$| = 1; + +eval q| require JSON |; + +# B module can't install? I'm not careful for such a problem. +# Leave us alone today? +if ($@) { + print "We try to look up lib/JSON.pm, but in vain. B module can't install?\n"; + print "Set the environmental variable 'PERL_DL_NONLAZY' with 0.\n"; + print "And see to ExtUtils::MM_Unix.\n"; + print "perl says : $@"; + print "We do not make Makefile by requiring Perl version 7.0.\n"; + require 7.0000; +} + + +my $version = JSON->VERSION; +my $message; + + +print <<EOF; +Welcome to JSON (v.$version) +============================= +$message + + ************************** CAUTION ************************** + * This is 'JSON version 2' and there are many differences * + * to version 1.xx * + * Please check your applications useing old version. * + * See to 'INCOMPATIBLE CHANGES TO OLD VERSION' and 'TIPS' * + ************************************************************* + + +EOF + + +WriteMakefile( + 'NAME' => 'JSON', + 'VERSION_FROM' => 'lib/JSON.pm', # finds $VERSION + 'PREREQ_PM' => { + 'Test::More' => 0, + }, + ($] >= 5.005 ? ## Add these new keywords supported since 5.005 + (ABSTRACT_FROM => 'lib/JSON.pm', # retrieve abstract from module + AUTHOR => 'Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>') : ()), + ( $ExtUtils::MakeMaker::VERSION >= 6.3002 ? ('LICENSE' => 'perl', ) : () ), + + ( $ExtUtils::MakeMaker::VERSION >= 6.46 ? ( + 'META_MERGE' => { + resources => { + repository => 'https://github.com/makamaka/JSON', + }, + recommends => { + 'JSON::XS' => JSON->require_xs_version, + }, + } ) : () + ), +); + + +if ($] < 5.006) { # I saw to http://d.hatena.ne.jp/asakusabashi/20051231/p1 + open(IN, "Makefile"); + open(OUT,">Makefile.tmp") || die; + while(<IN>) { + s/PERL_DL_NONLAZY=1//g; + print OUT; + } + close(OUT); + close(IN); + rename("Makefile.tmp" => "Makefile"); +} diff --git a/third_party/JSON/JSON-2.59/README b/third_party/JSON/JSON-2.59/README new file mode 100644 index 0000000..839c462 --- /dev/null +++ b/third_party/JSON/JSON-2.59/README @@ -0,0 +1,1566 @@ +JSON version 2.58 +================= + +"JSON::PP" was earlier included in the "JSON" distribution, +but has since Perl 5.14 been a core module. For this reason, +"JSON::PP" was removed from the "JSON" distribution and can +now be found also in the Perl5 repository at + + http://perl5.git.perl.org/perl.git + +(The newest "JSON::PP" version still exists in CPAN.) + +Instead, the "JSON" distribution will include "JSON::backportPP" +for backwards computability. JSON.pm should thus work as it did before. + +================= + +INSTALLATION + +To install this module type the following: + + perl Makefile.PL + make + make test + make install + +if you use cpanm, can install JSON::XS at once. + + cpanm --with-recommends JSON + + +NAME + JSON - JSON (JavaScript Object Notation) encoder/decoder + +SYNOPSIS + use JSON; # imports encode_json, decode_json, to_json and from_json. + + # simple and fast interfaces (expect/generate UTF-8) + + $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; + $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; + + # OO-interface + + $json = JSON->new->allow_nonref; + + $json_text = $json->encode( $perl_scalar ); + $perl_scalar = $json->decode( $json_text ); + + $pretty_printed = $json->pretty->encode( $perl_scalar ); # pretty-printing + + # If you want to use PP only support features, call with '-support_by_pp' + # When XS unsupported feature is enable, using PP (de|en)code instead of XS ones. + + use JSON -support_by_pp; + + # option-acceptable interfaces (expect/generate UNICODE by default) + + $json_text = to_json( $perl_scalar, { ascii => 1, pretty => 1 } ); + $perl_scalar = from_json( $json_text, { utf8 => 1 } ); + + # Between (en|de)code_json and (to|from)_json, if you want to write + # a code which communicates to an outer world (encoded in UTF-8), + # recommend to use (en|de)code_json. + +VERSION + 2.58 + + This version is compatible with JSON::XS 2.27 and later. + +NOTE + JSON::PP was earlier included in the "JSON" distribution, but has since + Perl 5.14 been a core module. For this reason, JSON::PP was removed from + the JSON distribution and can now be found also in the Perl5 repository + at + + * <http://perl5.git.perl.org/perl.git> + + (The newest JSON::PP version still exists in CPAN.) + + Instead, the "JSON" distribution will include JSON::backportPP for + backwards computability. JSON.pm should thus work as it did before. + +DESCRIPTION + ************************** CAUTION ******************************** + * This is 'JSON module version 2' and there are many differences * + * to version 1.xx * + * Please check your applications using old version. * + * See to 'INCOMPATIBLE CHANGES TO OLD VERSION' * + ******************************************************************* + + JSON (JavaScript Object Notation) is a simple data format. See to + <http://www.json.org/> and + "RFC4627"(<http://www.ietf.org/rfc/rfc4627.txt>). + + This module converts Perl data structures to JSON and vice versa using + either JSON::XS or JSON::PP. + + JSON::XS is the fastest and most proper JSON module on CPAN which must + be compiled and installed in your environment. JSON::PP is a pure-Perl + module which is bundled in this distribution and has a strong + compatibility to JSON::XS. + + This module try to use JSON::XS by default and fail to it, use JSON::PP + instead. So its features completely depend on JSON::XS or JSON::PP. + + See to "BACKEND MODULE DECISION". + + To distinguish the module name 'JSON' and the format type JSON, the + former is quoted by C<> (its results vary with your using media), and + the latter is left just as it is. + + Module name : "JSON" + + Format type : JSON + + FEATURES + * correct unicode handling + + This module (i.e. backend modules) knows how to handle Unicode, + documents how and when it does so, and even documents what "correct" + means. + + Even though there are limitations, this feature is available since + Perl version 5.6. + + JSON::XS requires Perl 5.8.2 (but works correctly in 5.8.8 or + later), so in older versions "JSON" should call JSON::PP as the + backend which can be used since Perl 5.005. + + With Perl 5.8.x JSON::PP works, but from 5.8.0 to 5.8.2, because of + a Perl side problem, JSON::PP works slower in the versions. And in + 5.005, the Unicode handling is not available. See to "UNICODE + HANDLING ON PERLS" in JSON::PP for more information. + + See also to "A FEW NOTES ON UNICODE AND PERL" in JSON::XS and + "ENCODING/CODESET_FLAG_NOTES" in JSON::XS. + + * round-trip integrity + + When you serialise a perl data structure using only data types + supported by JSON and Perl, the deserialised data structure is + identical on the Perl level. (e.g. the string "2.0" doesn't suddenly + become "2" just because it looks like a number). There *are* minor + exceptions to this, read the "MAPPING" section below to learn about + those. + + * strict checking of JSON correctness + + There is no guessing, no generating of illegal JSON texts by + default, and only JSON is accepted as input by default (the latter + is a security feature). + + See to "FEATURES" in JSON::XS and "FEATURES" in JSON::PP. + + * fast + + This module returns a JSON::XS object itself if available. Compared + to other JSON modules and other serialisers such as Storable, + JSON::XS usually compares favorably in terms of speed, too. + + If not available, "JSON" returns a JSON::PP object instead of + JSON::XS and it is very slow as pure-Perl. + + * simple to use + + This module has both a simple functional interface as well as an + object oriented interface interface. + + * reasonably versatile output formats + + You can choose between the most compact guaranteed-single-line + format possible (nice for simple line-based protocols), a pure-ASCII + format (for when your transport is not 8-bit clean, still supports + the whole Unicode range), or a pretty-printed format (for when you + want to read that stuff). Or you can combine those features in + whatever way you like. + +FUNCTIONAL INTERFACE + Some documents are copied and modified from "FUNCTIONAL INTERFACE" in + JSON::XS. "to_json" and "from_json" are additional functions. + + encode_json + $json_text = encode_json $perl_scalar + + Converts the given Perl data structure to a UTF-8 encoded, binary + string. + + This function call is functionally identical to: + + $json_text = JSON->new->utf8->encode($perl_scalar) + + decode_json + $perl_scalar = decode_json $json_text + + The opposite of "encode_json": expects an UTF-8 (binary) string and + tries to parse that as an UTF-8 encoded JSON text, returning the + resulting reference. + + This function call is functionally identical to: + + $perl_scalar = JSON->new->utf8->decode($json_text) + + to_json + $json_text = to_json($perl_scalar) + + Converts the given Perl data structure to a json string. + + This function call is functionally identical to: + + $json_text = JSON->new->encode($perl_scalar) + + Takes a hash reference as the second. + + $json_text = to_json($perl_scalar, $flag_hashref) + + So, + + $json_text = to_json($perl_scalar, {utf8 => 1, pretty => 1}) + + equivalent to: + + $json_text = JSON->new->utf8(1)->pretty(1)->encode($perl_scalar) + + If you want to write a modern perl code which communicates to outer + world, you should use "encode_json" (supposed that JSON data are encoded + in UTF-8). + + from_json + $perl_scalar = from_json($json_text) + + The opposite of "to_json": expects a json string and tries to parse it, + returning the resulting reference. + + This function call is functionally identical to: + + $perl_scalar = JSON->decode($json_text) + + Takes a hash reference as the second. + + $perl_scalar = from_json($json_text, $flag_hashref) + + So, + + $perl_scalar = from_json($json_text, {utf8 => 1}) + + equivalent to: + + $perl_scalar = JSON->new->utf8(1)->decode($json_text) + + If you want to write a modern perl code which communicates to outer + world, you should use "decode_json" (supposed that JSON data are encoded + in UTF-8). + + JSON::is_bool + $is_boolean = JSON::is_bool($scalar) + + Returns true if the passed scalar represents either JSON::true or + JSON::false, two constants that act like 1 and 0 respectively and are + also used to represent JSON "true" and "false" in Perl strings. + + JSON::true + Returns JSON true value which is blessed object. It "isa" JSON::Boolean + object. + + JSON::false + Returns JSON false value which is blessed object. It "isa" JSON::Boolean + object. + + JSON::null + Returns "undef". + + See MAPPING, below, for more information on how JSON values are mapped + to Perl. + +HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER + This section supposes that your perl version is 5.8 or later. + + If you know a JSON text from an outer world - a network, a file content, + and so on, is encoded in UTF-8, you should use "decode_json" or "JSON" + module object with "utf8" enable. And the decoded result will contain + UNICODE characters. + + # from network + my $json = JSON->new->utf8; + my $json_text = CGI->new->param( 'json_data' ); + my $perl_scalar = $json->decode( $json_text ); + + # from file content + local $/; + open( my $fh, '<', 'json.data' ); + $json_text = <$fh>; + $perl_scalar = decode_json( $json_text ); + + If an outer data is not encoded in UTF-8, firstly you should "decode" + it. + + use Encode; + local $/; + open( my $fh, '<', 'json.data' ); + my $encoding = 'cp932'; + my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE + + # or you can write the below code. + # + # open( my $fh, "<:encoding($encoding)", 'json.data' ); + # $unicode_json_text = <$fh>; + + In this case, $unicode_json_text is of course UNICODE string. So you + cannot use "decode_json" nor "JSON" module object with "utf8" enable. + Instead of them, you use "JSON" module object with "utf8" disable or + "from_json". + + $perl_scalar = $json->utf8(0)->decode( $unicode_json_text ); + # or + $perl_scalar = from_json( $unicode_json_text ); + + Or "encode 'utf8'" and "decode_json": + + $perl_scalar = decode_json( encode( 'utf8', $unicode_json_text ) ); + # this way is not efficient. + + And now, you want to convert your $perl_scalar into JSON data and send + it to an outer world - a network or a file content, and so on. + + Your data usually contains UNICODE strings and you want the converted + data to be encoded in UTF-8, you should use "encode_json" or "JSON" + module object with "utf8" enable. + + print encode_json( $perl_scalar ); # to a network? file? or display? + # or + print $json->utf8->encode( $perl_scalar ); + + If $perl_scalar does not contain UNICODE but $encoding-encoded strings + for some reason, then its characters are regarded as latin1 for perl + (because it does not concern with your $encoding). You cannot use + "encode_json" nor "JSON" module object with "utf8" enable. Instead of + them, you use "JSON" module object with "utf8" disable or "to_json". + Note that the resulted text is a UNICODE string but no problem to print + it. + + # $perl_scalar contains $encoding encoded string values + $unicode_json_text = $json->utf8(0)->encode( $perl_scalar ); + # or + $unicode_json_text = to_json( $perl_scalar ); + # $unicode_json_text consists of characters less than 0x100 + print $unicode_json_text; + + Or "decode $encoding" all string values and "encode_json": + + $perl_scalar->{ foo } = decode( $encoding, $perl_scalar->{ foo } ); + # ... do it to each string values, then encode_json + $json_text = encode_json( $perl_scalar ); + + This method is a proper way but probably not efficient. + + See to Encode, perluniintro. + +COMMON OBJECT-ORIENTED INTERFACE + new + $json = JSON->new + + Returns a new "JSON" object inherited from either JSON::XS or JSON::PP + that can be used to de/encode JSON strings. + + All boolean flags described below are by default *disabled*. + + The mutators for flags all return the JSON object again and thus calls + can be chained: + + my $json = JSON->new->utf8->space_after->encode({a => [1,2]}) + => {"a": [1, 2]} + + ascii + $json = $json->ascii([$enable]) + + $enabled = $json->get_ascii + + If $enable is true (or missing), then the encode method will not + generate characters outside the code range 0..127. Any Unicode + characters outside that range will be escaped using either a single + \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627. + + If $enable is false, then the encode method will not escape Unicode + characters unless required by the JSON syntax or other flags. This + results in a faster and more compact format. + + This feature depends on the used Perl version and environment. + + See to "UNICODE HANDLING ON PERLS" in JSON::PP if the backend is PP. + + JSON->new->ascii(1)->encode([chr 0x10401]) + => ["\ud801\udc01"] + + latin1 + $json = $json->latin1([$enable]) + + $enabled = $json->get_latin1 + + If $enable is true (or missing), then the encode method will encode the + resulting JSON text as latin1 (or iso-8859-1), escaping any characters + outside the code range 0..255. + + If $enable is false, then the encode method will not escape Unicode + characters unless required by the JSON syntax or other flags. + + JSON->new->latin1->encode (["\x{89}\x{abc}"] + => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not) + + utf8 + $json = $json->utf8([$enable]) + + $enabled = $json->get_utf8 + + If $enable is true (or missing), then the encode method will encode the + JSON result into UTF-8, as required by many protocols, while the decode + method expects to be handled an UTF-8-encoded string. Please note that + UTF-8-encoded strings do not contain any characters outside the range + 0..255, they are thus useful for bytewise/binary I/O. + + In future versions, enabling this option might enable autodetection of + the UTF-16 and UTF-32 encoding families, as described in RFC4627. + + If $enable is false, then the encode method will return the JSON string + as a (non-encoded) Unicode string, while decode expects thus a Unicode + string. Any decoding or encoding (e.g. to UTF-8 or UTF-16) needs to be + done yourself, e.g. using the Encode module. + + Example, output UTF-16BE-encoded JSON: + + use Encode; + $jsontext = encode "UTF-16BE", JSON::XS->new->encode ($object); + + Example, decode UTF-32LE-encoded JSON: + + use Encode; + $object = JSON::XS->new->decode (decode "UTF-32LE", $jsontext); + + See to "UNICODE HANDLING ON PERLS" in JSON::PP if the backend is PP. + + pretty + $json = $json->pretty([$enable]) + + This enables (or disables) all of the "indent", "space_before" and + "space_after" (and in the future possibly more) flags in one call to + generate the most readable (or most compact) form possible. + + Equivalent to: + + $json->indent->space_before->space_after + + The indent space length is three and JSON::XS cannot change the indent + space length. + + indent + $json = $json->indent([$enable]) + + $enabled = $json->get_indent + + If $enable is true (or missing), then the "encode" method will use a + multiline format as output, putting every array member or object/hash + key-value pair into its own line, identifying them properly. + + If $enable is false, no newlines or indenting will be produced, and the + resulting JSON text is guaranteed not to contain any "newlines". + + This setting has no effect when decoding JSON texts. + + The indent space length is three. With JSON::PP, you can also access + "indent_length" to change indent space length. + + space_before + $json = $json->space_before([$enable]) + + $enabled = $json->get_space_before + + If $enable is true (or missing), then the "encode" method will add an + extra optional space before the ":" separating keys from values in JSON + objects. + + If $enable is false, then the "encode" method will not add any extra + space at those places. + + This setting has no effect when decoding JSON texts. + + Example, space_before enabled, space_after and indent disabled: + + {"key" :"value"} + + space_after + $json = $json->space_after([$enable]) + + $enabled = $json->get_space_after + + If $enable is true (or missing), then the "encode" method will add an + extra optional space after the ":" separating keys from values in JSON + objects and extra whitespace after the "," separating key-value pairs + and array members. + + If $enable is false, then the "encode" method will not add any extra + space at those places. + + This setting has no effect when decoding JSON texts. + + Example, space_before and indent disabled, space_after enabled: + + {"key": "value"} + + relaxed + $json = $json->relaxed([$enable]) + + $enabled = $json->get_relaxed + + If $enable is true (or missing), then "decode" will accept some + extensions to normal JSON syntax (see below). "encode" will not be + affected in anyway. *Be aware that this option makes you accept invalid + JSON texts as if they were valid!*. I suggest only to use this option to + parse application-specific files written by humans (configuration files, + resource files etc.) + + If $enable is false (the default), then "decode" will only accept valid + JSON texts. + + Currently accepted extensions are: + + * list items can have an end-comma + + JSON *separates* array elements and key-value pairs with commas. + This can be annoying if you write JSON texts manually and want to be + able to quickly append elements, so this extension accepts comma at + the end of such items not just between them: + + [ + 1, + 2, <- this comma not normally allowed + ] + { + "k1": "v1", + "k2": "v2", <- this comma not normally allowed + } + + * shell-style '#'-comments + + Whenever JSON allows whitespace, shell-style comments are + additionally allowed. They are terminated by the first + carriage-return or line-feed character, after which more white-space + and comments are allowed. + + [ + 1, # this comment not allowed in JSON + # neither this one... + ] + + canonical + $json = $json->canonical([$enable]) + + $enabled = $json->get_canonical + + If $enable is true (or missing), then the "encode" method will output + JSON objects by sorting their keys. This is adding a comparatively high + overhead. + + If $enable is false, then the "encode" method will output key-value + pairs in the order Perl stores them (which will likely change between + runs of the same script). + + This option is useful if you want the same data structure to be encoded + as the same JSON text (given the same overall settings). If it is + disabled, the same hash might be encoded differently even if contains + the same data, as key-value pairs have no inherent ordering in Perl. + + This setting has no effect when decoding JSON texts. + + allow_nonref + $json = $json->allow_nonref([$enable]) + + $enabled = $json->get_allow_nonref + + If $enable is true (or missing), then the "encode" method can convert a + non-reference into its corresponding string, number or null JSON value, + which is an extension to RFC4627. Likewise, "decode" will accept those + JSON values instead of croaking. + + If $enable is false, then the "encode" method will croak if it isn't + passed an arrayref or hashref, as JSON texts must either be an object or + array. Likewise, "decode" will croak if given something that is not a + JSON object or array. + + JSON->new->allow_nonref->encode ("Hello, World!") + => "Hello, World!" + + allow_unknown + $json = $json->allow_unknown ([$enable]) + + $enabled = $json->get_allow_unknown + + If $enable is true (or missing), then "encode" will *not* throw an + exception when it encounters values it cannot represent in JSON (for + example, filehandles) but instead will encode a JSON "null" value. Note + that blessed objects are not included here and are handled separately by + c<allow_nonref>. + + If $enable is false (the default), then "encode" will throw an exception + when it encounters anything it cannot encode as JSON. + + This option does not affect "decode" in any way, and it is recommended + to leave it off unless you know your communications partner. + + allow_blessed + $json = $json->allow_blessed([$enable]) + + $enabled = $json->get_allow_blessed + + If $enable is true (or missing), then the "encode" method will not barf + when it encounters a blessed reference. Instead, the value of the + convert_blessed option will decide whether "null" ("convert_blessed" + disabled or no "TO_JSON" method found) or a representation of the object + ("convert_blessed" enabled and "TO_JSON" method found) is being encoded. + Has no effect on "decode". + + If $enable is false (the default), then "encode" will throw an exception + when it encounters a blessed object. + + convert_blessed + $json = $json->convert_blessed([$enable]) + + $enabled = $json->get_convert_blessed + + If $enable is true (or missing), then "encode", upon encountering a + blessed object, will check for the availability of the "TO_JSON" method + on the object's class. If found, it will be called in scalar context and + the resulting scalar will be encoded instead of the object. If no + "TO_JSON" method is found, the value of "allow_blessed" will decide what + to do. + + The "TO_JSON" method may safely call die if it wants. If "TO_JSON" + returns other blessed objects, those will be handled in the same way. + "TO_JSON" must take care of not causing an endless recursion cycle (== + crash) in this case. The name of "TO_JSON" was chosen because other + methods called by the Perl core (== not by the user of the object) are + usually in upper case letters and to avoid collisions with the "to_json" + function or method. + + This setting does not yet influence "decode" in any way. + + If $enable is false, then the "allow_blessed" setting will decide what + to do when a blessed object is found. + + convert_blessed_universally mode + If use "JSON" with "-convert_blessed_universally", the + "UNIVERSAL::TO_JSON" subroutine is defined as the below code: + + *UNIVERSAL::TO_JSON = sub { + my $b_obj = B::svref_2object( $_[0] ); + return $b_obj->isa('B::HV') ? { %{ $_[0] } } + : $b_obj->isa('B::AV') ? [ @{ $_[0] } ] + : undef + ; + } + + This will cause that "encode" method converts simple blessed objects + into JSON objects as non-blessed object. + + JSON -convert_blessed_universally; + $json->allow_blessed->convert_blessed->encode( $blessed_object ) + + This feature is experimental and may be removed in the future. + + filter_json_object + $json = $json->filter_json_object([$coderef]) + + When $coderef is specified, it will be called from "decode" each time it + decodes a JSON object. The only argument passed to the coderef is a + reference to the newly-created hash. If the code references returns a + single scalar (which need not be a reference), this value (i.e. a copy + of that scalar to avoid aliasing) is inserted into the deserialised data + structure. If it returns an empty list (NOTE: *not* "undef", which is a + valid scalar), the original deserialised hash will be inserted. This + setting can slow down decoding considerably. + + When $coderef is omitted or undefined, any existing callback will be + removed and "decode" will not change the deserialised hash in any way. + + Example, convert all JSON objects into the integer 5: + + my $js = JSON->new->filter_json_object (sub { 5 }); + # returns [5] + $js->decode ('[{}]'); # the given subroutine takes a hash reference. + # throw an exception because allow_nonref is not enabled + # so a lone 5 is not allowed. + $js->decode ('{"a":1, "b":2}'); + + filter_json_single_key_object + $json = $json->filter_json_single_key_object($key [=> $coderef]) + + Works remotely similar to "filter_json_object", but is only called for + JSON objects having a single key named $key. + + This $coderef is called before the one specified via + "filter_json_object", if any. It gets passed the single value in the + JSON object. If it returns a single value, it will be inserted into the + data structure. If it returns nothing (not even "undef" but the empty + list), the callback from "filter_json_object" will be called next, as if + no single-key callback were specified. + + If $coderef is omitted or undefined, the corresponding callback will be + disabled. There can only ever be one callback for a given key. + + As this callback gets called less often then the "filter_json_object" + one, decoding speed will not usually suffer as much. Therefore, + single-key objects make excellent targets to serialise Perl objects + into, especially as single-key JSON objects are as close to the + type-tagged value concept as JSON gets (it's basically an ID/VALUE + tuple). Of course, JSON does not support this in any way, so you need to + make sure your data never looks like a serialised Perl hash. + + Typical names for the single object key are "__class_whatever__", or + "$__dollars_are_rarely_used__$" or "}ugly_brace_placement", or even + things like "__class_md5sum(classname)__", to reduce the risk of + clashing with real hashes. + + Example, decode JSON objects of the form "{ "__widget__" => <id> }" into + the corresponding $WIDGET{<id>} object: + + # return whatever is in $WIDGET{5}: + JSON + ->new + ->filter_json_single_key_object (__widget__ => sub { + $WIDGET{ $_[0] } + }) + ->decode ('{"__widget__": 5') + + # this can be used with a TO_JSON method in some "widget" class + # for serialisation to json: + sub WidgetBase::TO_JSON { + my ($self) = @_; + + unless ($self->{id}) { + $self->{id} = ..get..some..id..; + $WIDGET{$self->{id}} = $self; + } + + { __widget__ => $self->{id} } + } + + shrink + $json = $json->shrink([$enable]) + + $enabled = $json->get_shrink + + With JSON::XS, this flag resizes strings generated by either "encode" or + "decode" to their minimum size possible. This can save memory when your + JSON texts are either very very long or you have many short strings. It + will also try to downgrade any strings to octet-form if possible: perl + stores strings internally either in an encoding called UTF-X or in + octet-form. The latter cannot store everything but uses less space in + general (and some buggy Perl or C code might even rely on that internal + representation being used). + + With JSON::PP, it is noop about resizing strings but tries + "utf8::downgrade" to the returned string by "encode". See to utf8. + + See to "OBJECT-ORIENTED INTERFACE" in JSON::XS and "METHODS" in + JSON::PP. + + max_depth + $json = $json->max_depth([$maximum_nesting_depth]) + + $max_depth = $json->get_max_depth + + Sets the maximum nesting level (default 512) accepted while encoding or + decoding. If a higher nesting level is detected in JSON text or a Perl + data structure, then the encoder and decoder will stop and croak at that + point. + + Nesting level is defined by number of hash- or arrayrefs that the + encoder needs to traverse to reach a given point or the number of "{" or + "[" characters without their matching closing parenthesis crossed to + reach a given character in a string. + + If no argument is given, the highest possible setting will be used, + which is rarely useful. + + Note that nesting is implemented by recursion in C. The default value + has been chosen to be as large as typical operating systems allow + without crashing. (JSON::XS) + + With JSON::PP as the backend, when a large value (100 or more) was set + and it de/encodes a deep nested object/text, it may raise a warning + 'Deep recursion on subroutine' at the perl runtime phase. + + See "SECURITY CONSIDERATIONS" in JSON::XS for more info on why this is + useful. + + max_size + $json = $json->max_size([$maximum_string_size]) + + $max_size = $json->get_max_size + + Set the maximum length a JSON text may have (in bytes) where decoding is + being attempted. The default is 0, meaning no limit. When "decode" is + called on a string that is longer then this many bytes, it will not + attempt to decode the string but throw an exception. This setting has no + effect on "encode" (yet). + + If no argument is given, the limit check will be deactivated (same as + when 0 is specified). + + See "SECURITY CONSIDERATIONS" in JSON::XS, below, for more info on why + this is useful. + + encode + $json_text = $json->encode($perl_scalar) + + Converts the given Perl data structure (a simple scalar or a reference + to a hash or array) to its JSON representation. Simple scalars will be + converted into JSON string or number sequences, while references to + arrays become JSON arrays and references to hashes become JSON objects. + Undefined Perl values (e.g. "undef") become JSON "null" values. + References to the integers 0 and 1 are converted into "true" and + "false". + + decode + $perl_scalar = $json->decode($json_text) + + The opposite of "encode": expects a JSON text and tries to parse it, + returning the resulting simple scalar or reference. Croaks on error. + + JSON numbers and strings become simple Perl scalars. JSON arrays become + Perl arrayrefs and JSON objects become Perl hashrefs. "true" becomes 1 + ("JSON::true"), "false" becomes 0 ("JSON::false") and "null" becomes + "undef". + + decode_prefix + ($perl_scalar, $characters) = $json->decode_prefix($json_text) + + This works like the "decode" method, but instead of raising an exception + when there is trailing garbage after the first JSON object, it will + silently stop parsing there and return the number of characters consumed + so far. + + JSON->new->decode_prefix ("[1] the tail") + => ([], 3) + + See to "OBJECT-ORIENTED INTERFACE" in JSON::XS + + property + $boolean = $json->property($property_name) + + Returns a boolean value about above some properties. + + The available properties are "ascii", "latin1", "utf8", + "indent","space_before", "space_after", "relaxed", "canonical", + "allow_nonref", "allow_unknown", "allow_blessed", "convert_blessed", + "shrink", "max_depth" and "max_size". + + $boolean = $json->property('utf8'); + => 0 + $json->utf8; + $boolean = $json->property('utf8'); + => 1 + + Sets the property with a given boolean value. + + $json = $json->property($property_name => $boolean); + + With no argument, it returns all the above properties as a hash + reference. + + $flag_hashref = $json->property(); + +INCREMENTAL PARSING + Most of this section are copied and modified from "INCREMENTAL PARSING" + in JSON::XS. + + In some cases, there is the need for incremental parsing of JSON texts. + This module does allow you to parse a JSON stream incrementally. It does + so by accumulating text until it has a full JSON object, which it then + can decode. This process is similar to using "decode_prefix" to see if a + full JSON object is available, but is much more efficient (and can be + implemented with a minimum of method calls). + + The backend module will only attempt to parse the JSON text once it is + sure it has enough text to get a decisive result, using a very simple + but truly incremental parser. This means that it sometimes won't stop as + early as the full parser, for example, it doesn't detect parenthesis + mismatches. The only thing it guarantees is that it starts decoding as + soon as a syntactically valid JSON text has been seen. This means you + need to set resource limits (e.g. "max_size") to ensure the parser will + stop parsing in the presence if syntax errors. + + The following methods implement this incremental parser. + + incr_parse + $json->incr_parse( [$string] ) # void context + + $obj_or_undef = $json->incr_parse( [$string] ) # scalar context + + @obj_or_empty = $json->incr_parse( [$string] ) # list context + + This is the central parsing function. It can both append new text and + extract objects from the stream accumulated so far (both of these + functions are optional). + + If $string is given, then this string is appended to the already + existing JSON fragment stored in the $json object. + + After that, if the function is called in void context, it will simply + return without doing anything further. This can be used to add more text + in as many chunks as you want. + + If the method is called in scalar context, then it will try to extract + exactly *one* JSON object. If that is successful, it will return this + object, otherwise it will return "undef". If there is a parse error, + this method will croak just as "decode" would do (one can then use + "incr_skip" to skip the erroneous part). This is the most common way of + using the method. + + And finally, in list context, it will try to extract as many objects + from the stream as it can find and return them, or the empty list + otherwise. For this to work, there must be no separators between the + JSON objects or arrays, instead they must be concatenated back-to-back. + If an error occurs, an exception will be raised as in the scalar context + case. Note that in this case, any previously-parsed JSON texts will be + lost. + + Example: Parse some JSON arrays/objects in a given string and return + them. + + my @objs = JSON->new->incr_parse ("[5][7][1,2]"); + + incr_text + $lvalue_string = $json->incr_text + + This method returns the currently stored JSON fragment as an lvalue, + that is, you can manipulate it. This *only* works when a preceding call + to "incr_parse" in *scalar context* successfully returned an object. + Under all other circumstances you must not call this function (I mean + it. although in simple tests it might actually work, it *will* fail + under real world conditions). As a special exception, you can also call + this method before having parsed anything. + + This function is useful in two cases: a) finding the trailing text after + a JSON object or b) parsing multiple JSON objects separated by non-JSON + text (such as commas). + + $json->incr_text =~ s/\s*,\s*//; + + In Perl 5.005, "lvalue" attribute is not available. You must write codes + like the below: + + $string = $json->incr_text; + $string =~ s/\s*,\s*//; + $json->incr_text( $string ); + + incr_skip + $json->incr_skip + + This will reset the state of the incremental parser and will remove the + parsed text from the input buffer. This is useful after "incr_parse" + died, in which case the input buffer and incremental parser state is + left unchanged, to skip the text parsed so far and to reset the parse + state. + + incr_reset + $json->incr_reset + + This completely resets the incremental parser, that is, after this call, + it will be as if the parser had never parsed anything. + + This is useful if you want to repeatedly parse JSON objects and want to + ignore any trailing data, which means you have to reset the parser after + each successful decode. + + See to "INCREMENTAL PARSING" in JSON::XS for examples. + +JSON::PP SUPPORT METHODS + The below methods are JSON::PP own methods, so when "JSON" works with + JSON::PP (i.e. the created object is a JSON::PP object), available. See + to "JSON::PP OWN METHODS" in JSON::PP in detail. + + If you use "JSON" with additional "-support_by_pp", some methods are + available even with JSON::XS. See to "USE PP FEATURES EVEN THOUGH XS + BACKEND". + + BEING { $ENV{PERL_JSON_BACKEND} = 'JSON::XS' } + + use JSON -support_by_pp; + + my $json = JSON->new; + $json->allow_nonref->escape_slash->encode("/"); + + # functional interfaces too. + print to_json(["/"], {escape_slash => 1}); + print from_json('["foo"]', {utf8 => 1}); + + If you do not want to all functions but "-support_by_pp", use + "-no_export". + + use JSON -support_by_pp, -no_export; + # functional interfaces are not exported. + + allow_singlequote + $json = $json->allow_singlequote([$enable]) + + If $enable is true (or missing), then "decode" will accept any JSON + strings quoted by single quotations that are invalid JSON format. + + $json->allow_singlequote->decode({"foo":'bar'}); + $json->allow_singlequote->decode({'foo':"bar"}); + $json->allow_singlequote->decode({'foo':'bar'}); + + As same as the "relaxed" option, this option may be used to parse + application-specific files written by humans. + + allow_barekey + $json = $json->allow_barekey([$enable]) + + If $enable is true (or missing), then "decode" will accept bare keys of + JSON object that are invalid JSON format. + + As same as the "relaxed" option, this option may be used to parse + application-specific files written by humans. + + $json->allow_barekey->decode('{foo:"bar"}'); + + allow_bignum + $json = $json->allow_bignum([$enable]) + + If $enable is true (or missing), then "decode" will convert the big + integer Perl cannot handle as integer into a Math::BigInt object and + convert a floating number (any) into a Math::BigFloat. + + On the contrary, "encode" converts "Math::BigInt" objects and + "Math::BigFloat" objects into JSON numbers with "allow_blessed" enable. + + $json->allow_nonref->allow_blessed->allow_bignum; + $bigfloat = $json->decode('2.000000000000000000000000001'); + print $json->encode($bigfloat); + # => 2.000000000000000000000000001 + + See to MAPPING about the conversion of JSON number. + + loose + $json = $json->loose([$enable]) + + The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON + strings and the module doesn't allow to "decode" to these (except for + \x2f). If $enable is true (or missing), then "decode" will accept these + unescaped strings. + + $json->loose->decode(qq|["abc + def"]|); + + See to "JSON::PP OWN METHODS" in JSON::PP. + + escape_slash + $json = $json->escape_slash([$enable]) + + According to JSON Grammar, *slash* (U+002F) is escaped. But by default + JSON backend modules encode strings without escaping slash. + + If $enable is true (or missing), then "encode" will escape slashes. + + indent_length + $json = $json->indent_length($length) + + With JSON::XS, The indent space length is 3 and cannot be changed. With + JSON::PP, it sets the indent space length with the given $length. The + default is 3. The acceptable range is 0 to 15. + + sort_by + $json = $json->sort_by($function_name) + $json = $json->sort_by($subroutine_ref) + + If $function_name or $subroutine_ref are set, its sort routine are used. + + $js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + $js = $pc->sort_by('own_sort')->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } + + As the sorting routine runs in the JSON::PP scope, the given subroutine + name and the special variables $a, $b will begin with 'JSON::PP::'. + + If $integer is set, then the effect is same as "canonical" on. + + See to "JSON::PP OWN METHODS" in JSON::PP. + +MAPPING + This section is copied from JSON::XS and modified to "JSON". JSON::XS + and JSON::PP mapping mechanisms are almost equivalent. + + See to "MAPPING" in JSON::XS. + + JSON -> PERL + object + A JSON object becomes a reference to a hash in Perl. No ordering of + object keys is preserved (JSON does not preserver object key + ordering itself). + + array + A JSON array becomes a reference to an array in Perl. + + string + A JSON string becomes a string scalar in Perl - Unicode codepoints + in JSON are represented by the same codepoints in the Perl string, + so no manual decoding is necessary. + + number + A JSON number becomes either an integer, numeric (floating point) or + string scalar in perl, depending on its range and any fractional + parts. On the Perl level, there is no difference between those as + Perl handles all the conversion details, but an integer may take + slightly less memory and might represent more values exactly than + floating point numbers. + + If the number consists of digits only, "JSON" will try to represent + it as an integer value. If that fails, it will try to represent it + as a numeric (floating point) value if that is possible without loss + of precision. Otherwise it will preserve the number as a string + value (in which case you lose roundtripping ability, as the JSON + number will be re-encoded to a JSON string). + + Numbers containing a fractional or exponential part will always be + represented as numeric (floating point) values, possibly at a loss + of precision (in which case you might lose perfect roundtripping + ability, but the JSON number will still be re-encoded as a JSON + number). + + Note that precision is not accuracy - binary floating point values + cannot represent most decimal fractions exactly, and when converting + from and to floating point, "JSON" only guarantees precision up to + but not including the least significant bit. + + If the backend is JSON::PP and "allow_bignum" is enable, the big + integers and the numeric can be optionally converted into + Math::BigInt and Math::BigFloat objects. + + true, false + These JSON atoms become "JSON::true" and "JSON::false", + respectively. They are overloaded to act almost exactly like the + numbers 1 and 0. You can check whether a scalar is a JSON boolean by + using the "JSON::is_bool" function. + + If "JSON::true" and "JSON::false" are used as strings or compared as + strings, they represent as "true" and "false" respectively. + + print JSON::true . "\n"; + => true + print JSON::true + 1; + => 1 + + ok(JSON::true eq 'true'); + ok(JSON::true eq '1'); + ok(JSON::true == 1); + + "JSON" will install these missing overloading features to the + backend modules. + + null + A JSON null atom becomes "undef" in Perl. + + "JSON::null" returns "undef". + + PERL -> JSON + The mapping from Perl to JSON is slightly more difficult, as Perl is a + truly typeless language, so we can only guess which JSON type is meant + by a Perl value. + + hash references + Perl hash references become JSON objects. As there is no inherent + ordering in hash keys (or JSON objects), they will usually be + encoded in a pseudo-random order that can change between runs of the + same program but stays generally the same within a single run of a + program. "JSON" optionally sort the hash keys (determined by the + *canonical* flag), so the same data structure will serialise to the + same JSON text (given same settings and version of JSON::XS), but + this incurs a runtime overhead and is only rarely useful, e.g. when + you want to compare some JSON text against another for equality. + + In future, the ordered object feature will be added to JSON::PP + using "tie" mechanism. + + array references + Perl array references become JSON arrays. + + other references + Other unblessed references are generally not allowed and will cause + an exception to be thrown, except for references to the integers 0 + and 1, which get turned into "false" and "true" atoms in JSON. You + can also use "JSON::false" and "JSON::true" to improve readability. + + to_json [\0,JSON::true] # yields [false,true] + + JSON::true, JSON::false, JSON::null + These special values become JSON true and JSON false values, + respectively. You can also use "\1" and "\0" directly if you want. + + JSON::null returns "undef". + + blessed objects + Blessed objects are not directly representable in JSON. See the + "allow_blessed" and "convert_blessed" methods on various options on + how to deal with this: basically, you can choose between throwing an + exception, encoding the reference as if it weren't blessed, or + provide your own serialiser method. + + With "convert_blessed_universally" mode, "encode" converts blessed + hash references or blessed array references (contains other blessed + references) into JSON members and arrays. + + use JSON -convert_blessed_universally; + JSON->new->allow_blessed->convert_blessed->encode( $blessed_object ); + + See to convert_blessed. + + simple scalars + Simple Perl scalars (any scalar that is not a reference) are the + most difficult objects to encode: JSON::XS and JSON::PP will encode + undefined scalars as JSON "null" values, scalars that have last been + used in a string context before encoding as JSON strings, and + anything else as number value: + + # dump as number + encode_json [2] # yields [2] + encode_json [-3.0e17] # yields [-3e+17] + my $value = 5; encode_json [$value] # yields [5] + + # used as string, so dump as string + print $value; + encode_json [$value] # yields ["5"] + + # undef becomes null + encode_json [undef] # yields [null] + + You can force the type to be a string by stringifying it: + + my $x = 3.1; # some variable containing a number + "$x"; # stringified + $x .= ""; # another, more awkward way to stringify + print $x; # perl does it for you, too, quite often + + You can force the type to be a number by numifying it: + + my $x = "3"; # some variable containing a string + $x += 0; # numify it, ensuring it will be dumped as a number + $x *= 1; # same thing, the choice is yours. + + You can not currently force the type in other, less obscure, ways. + + Note that numerical precision has the same meaning as under Perl (so + binary to decimal conversion follows the same rules as in Perl, + which can differ to other languages). Also, your perl interpreter + might expose extensions to the floating point numbers of your + platform, such as infinities or NaN's - these cannot be represented + in JSON, and it is an error to pass those in. + + Big Number + If the backend is JSON::PP and "allow_bignum" is enable, "encode" + converts "Math::BigInt" objects and "Math::BigFloat" objects into + JSON numbers. + +JSON and ECMAscript + See to "JSON and ECMAscript" in JSON::XS. + +JSON and YAML + JSON is not a subset of YAML. See to "JSON and YAML" in JSON::XS. + +BACKEND MODULE DECISION + When you use "JSON", "JSON" tries to "use" JSON::XS. If this call + failed, it will "uses" JSON::PP. The required JSON::XS version is *2.2* + or later. + + The "JSON" constructor method returns an object inherited from the + backend module, and JSON::XS object is a blessed scalar reference while + JSON::PP is a blessed hash reference. + + So, your program should not depend on the backend module, especially + returned objects should not be modified. + + my $json = JSON->new; # XS or PP? + $json->{stash} = 'this is xs object'; # this code may raise an error! + + To check the backend module, there are some methods - "backend", "is_pp" + and "is_xs". + + JSON->backend; # 'JSON::XS' or 'JSON::PP' + + JSON->backend->is_pp: # 0 or 1 + + JSON->backend->is_xs: # 1 or 0 + + $json->is_xs; # 1 or 0 + + $json->is_pp; # 0 or 1 + + If you set an environment variable "PERL_JSON_BACKEND", the calling + action will be changed. + + PERL_JSON_BACKEND = 0 or PERL_JSON_BACKEND = 'JSON::PP' + Always use JSON::PP + + PERL_JSON_BACKEND == 1 or PERL_JSON_BACKEND = 'JSON::XS,JSON::PP' + (The default) Use compiled JSON::XS if it is properly compiled & + installed, otherwise use JSON::PP. + + PERL_JSON_BACKEND == 2 or PERL_JSON_BACKEND = 'JSON::XS' + Always use compiled JSON::XS, die if it isn't properly compiled & + installed. + + PERL_JSON_BACKEND = 'JSON::backportPP' + Always use JSON::backportPP. JSON::backportPP is JSON::PP back port + module. "JSON" includes JSON::backportPP instead of JSON::PP. + + These ideas come from DBI::PurePerl mechanism. + + example: + + BEGIN { $ENV{PERL_JSON_BACKEND} = 'JSON::PP' } + use JSON; # always uses JSON::PP + + In future, it may be able to specify another module. + +USE PP FEATURES EVEN THOUGH XS BACKEND + Many methods are available with either JSON::XS or JSON::PP and when the + backend module is JSON::XS, if any JSON::PP specific (i.e. JSON::XS + unsupported) method is called, it will "warn" and be noop. + + But If you "use" "JSON" passing the optional string "-support_by_pp", it + makes a part of those unsupported methods available. This feature is + achieved by using JSON::PP in "de/encode". + + BEGIN { $ENV{PERL_JSON_BACKEND} = 2 } # with JSON::XS + use JSON -support_by_pp; + my $json = JSON->new; + $json->allow_nonref->escape_slash->encode("/"); + + At this time, the returned object is a "JSON::Backend::XS::Supportable" + object (re-blessed XS object), and by checking JSON::XS unsupported + flags in de/encoding, can support some unsupported methods - "loose", + "allow_bignum", "allow_barekey", "allow_singlequote", "escape_slash" and + "indent_length". + + When any unsupported methods are not enable, "XS de/encode" will be used + as is. The switch is achieved by changing the symbolic tables. + + "-support_by_pp" is effective only when the backend module is JSON::XS + and it makes the de/encoding speed down a bit. + + See to "JSON::PP SUPPORT METHODS". + +INCOMPATIBLE CHANGES TO OLD VERSION + There are big incompatibility between new version (2.00) and old (1.xx). + If you use old "JSON" 1.xx in your code, please check it. + + See to "Transition ways from 1.xx to 2.xx." + + jsonToObj and objToJson are obsoleted. + Non Perl-style name "jsonToObj" and "objToJson" are obsoleted (but + not yet deleted from the source). If you use these functions in your + code, please replace them with "from_json" and "to_json". + + Global variables are no longer available. + "JSON" class variables - $JSON::AUTOCONVERT, $JSON::BareKey, etc... + - are not available any longer. Instead, various features can be + used through object methods. + + Package JSON::Converter and JSON::Parser are deleted. + Now "JSON" bundles with JSON::PP which can handle JSON more properly + than them. + + Package JSON::NotString is deleted. + There was "JSON::NotString" class which represents JSON value + "true", "false", "null" and numbers. It was deleted and replaced by + "JSON::Boolean". + + "JSON::Boolean" represents "true" and "false". + + "JSON::Boolean" does not represent "null". + + "JSON::null" returns "undef". + + "JSON" makes JSON::XS::Boolean and JSON::PP::Boolean is-a relation + to JSON::Boolean. + + function JSON::Number is obsoleted. + "JSON::Number" is now needless because JSON::XS and JSON::PP have + round-trip integrity. + + JSONRPC modules are deleted. + Perl implementation of JSON-RPC protocol - "JSONRPC ", + "JSONRPC::Transport::HTTP" and "Apache::JSONRPC " are deleted in + this distribution. Instead of them, there is JSON::RPC which + supports JSON-RPC protocol version 1.1. + + Transition ways from 1.xx to 2.xx. + You should set "suport_by_pp" mode firstly, because it is always + successful for the below codes even with JSON::XS. + + use JSON -support_by_pp; + + Exported jsonToObj (simple) + from_json($json_text); + + Exported objToJson (simple) + to_json($perl_scalar); + + Exported jsonToObj (advanced) + $flags = {allow_barekey => 1, allow_singlequote => 1}; + from_json($json_text, $flags); + + equivalent to: + + $JSON::BareKey = 1; + $JSON::QuotApos = 1; + jsonToObj($json_text); + + Exported objToJson (advanced) + $flags = {allow_blessed => 1, allow_barekey => 1}; + to_json($perl_scalar, $flags); + + equivalent to: + + $JSON::BareKey = 1; + objToJson($perl_scalar); + + jsonToObj as object method + $json->decode($json_text); + + objToJson as object method + $json->encode($perl_scalar); + + new method with parameters + The "new" method in 2.x takes any parameters no longer. You can set + parameters instead; + + $json = JSON->new->pretty; + + $JSON::Pretty, $JSON::Indent, $JSON::Delimiter + If "indent" is enable, that means $JSON::Pretty flag set. And + $JSON::Delimiter was substituted by "space_before" and + "space_after". In conclusion: + + $json->indent->space_before->space_after; + + Equivalent to: + + $json->pretty; + + To change indent length, use "indent_length". + + (Only with JSON::PP, if "-support_by_pp" is not used.) + + $json->pretty->indent_length(2)->encode($perl_scalar); + + $JSON::BareKey + (Only with JSON::PP, if "-support_by_pp" is not used.) + + $json->allow_barekey->decode($json_text) + + $JSON::ConvBlessed + use "-convert_blessed_universally". See to convert_blessed. + + $JSON::QuotApos + (Only with JSON::PP, if "-support_by_pp" is not used.) + + $json->allow_singlequote->decode($json_text) + + $JSON::SingleQuote + Disable. "JSON" does not make such a invalid JSON string any longer. + + $JSON::KeySort + $json->canonical->encode($perl_scalar) + + This is the ascii sort. + + If you want to use with your own sort routine, check the "sort_by" + method. + + (Only with JSON::PP, even if "-support_by_pp" is used currently.) + + $json->sort_by($sort_routine_ref)->encode($perl_scalar) + + $json->sort_by(sub { $JSON::PP::a <=> $JSON::PP::b })->encode($perl_scalar) + + Can't access $a and $b but $JSON::PP::a and $JSON::PP::b. + + $JSON::SkipInvalid + $json->allow_unknown + + $JSON::AUTOCONVERT + Needless. "JSON" backend modules have the round-trip integrity. + + $JSON::UTF8 + Needless because "JSON" (JSON::XS/JSON::PP) sets the UTF8 flag on + properly. + + # With UTF8-flagged strings + + $json->allow_nonref; + $str = chr(1000); # UTF8-flagged + + $json_text = $json->utf8(0)->encode($str); + utf8::is_utf8($json_text); + # true + $json_text = $json->utf8(1)->encode($str); + utf8::is_utf8($json_text); + # false + + $str = '"' . chr(1000) . '"'; # UTF8-flagged + + $perl_scalar = $json->utf8(0)->decode($str); + utf8::is_utf8($perl_scalar); + # true + $perl_scalar = $json->utf8(1)->decode($str); + # died because of 'Wide character in subroutine' + + See to "A FEW NOTES ON UNICODE AND PERL" in JSON::XS. + + $JSON::UnMapping + Disable. See to MAPPING. + + $JSON::SelfConvert + This option was deleted. Instead of it, if a given blessed object + has the "TO_JSON" method, "TO_JSON" will be executed with + "convert_blessed". + + $json->convert_blessed->encode($blessed_hashref_or_arrayref) + # if need, call allow_blessed + + Note that it was "toJson" in old version, but now not "toJson" but + "TO_JSON". + +TODO + example programs + +THREADS + No test with JSON::PP. If with JSON::XS, See to "THREADS" in JSON::XS. + +BUGS + Please report bugs relevant to "JSON" to <makamaka[at]cpan.org>. + +SEE ALSO + Most of the document is copied and modified from JSON::XS doc. + + JSON::XS, JSON::PP + + "RFC4627"(<http://www.ietf.org/rfc/rfc4627.txt>) + +AUTHOR + Makamaka Hannyaharamitu, <makamaka[at]cpan.org> + + JSON::XS was written by Marc Lehmann <schmorp[at]schmorp.de> + + The release of this new version owes to the courtesy of Marc Lehmann. + +COPYRIGHT AND LICENSE + Copyright 2005-2013 by Makamaka Hannyaharamitu + + This library is free software; you can redistribute it and/or modify it + under the same terms as Perl itself. + diff --git a/third_party/JSON/JSON-2.59/blib/arch/.exists b/third_party/JSON/JSON-2.59/blib/arch/.exists new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/arch/.exists diff --git a/third_party/JSON/JSON-2.59/blib/arch/auto/JSON/.exists b/third_party/JSON/JSON-2.59/blib/arch/auto/JSON/.exists new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/arch/auto/JSON/.exists diff --git a/third_party/JSON/JSON-2.59/blib/bin/.exists b/third_party/JSON/JSON-2.59/blib/bin/.exists new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/bin/.exists diff --git a/third_party/JSON/JSON-2.59/blib/lib/.exists b/third_party/JSON/JSON-2.59/blib/lib/.exists new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/lib/.exists diff --git a/third_party/JSON/JSON-2.59/blib/lib/JSON.pm b/third_party/JSON/JSON-2.59/blib/lib/JSON.pm new file mode 100644 index 0000000..bd39cd8 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/lib/JSON.pm @@ -0,0 +1,2292 @@ +package JSON; + + +use strict; +use Carp (); +use base qw(Exporter); +@JSON::EXPORT = qw(from_json to_json jsonToObj objToJson encode_json decode_json); + +BEGIN { + $JSON::VERSION = '2.59'; + $JSON::DEBUG = 0 unless (defined $JSON::DEBUG); + $JSON::DEBUG = $ENV{ PERL_JSON_DEBUG } if exists $ENV{ PERL_JSON_DEBUG }; +} + +my $Module_XS = 'JSON::XS'; +my $Module_PP = 'JSON::PP'; +my $Module_bp = 'JSON::backportPP'; # included in JSON distribution +my $PP_Version = '2.27200'; +my $XS_Version = '2.34'; + + +# XS and PP common methods + +my @PublicMethods = qw/ + ascii latin1 utf8 pretty indent space_before space_after relaxed canonical allow_nonref + allow_blessed convert_blessed filter_json_object filter_json_single_key_object + shrink max_depth max_size encode decode decode_prefix allow_unknown +/; + +my @Properties = qw/ + ascii latin1 utf8 indent space_before space_after relaxed canonical allow_nonref + allow_blessed convert_blessed shrink max_depth max_size allow_unknown +/; + +my @XSOnlyMethods = qw//; # Currently nothing + +my @PPOnlyMethods = qw/ + indent_length sort_by + allow_singlequote allow_bignum loose allow_barekey escape_slash as_nonblessed +/; # JSON::PP specific + + +# used in _load_xs and _load_pp ($INSTALL_ONLY is not used currently) +my $_INSTALL_DONT_DIE = 1; # When _load_xs fails to load XS, don't die. +my $_INSTALL_ONLY = 2; # Don't call _set_methods() +my $_ALLOW_UNSUPPORTED = 0; +my $_UNIV_CONV_BLESSED = 0; +my $_USSING_bpPP = 0; + + +# Check the environment variable to decide worker module. + +unless ($JSON::Backend) { + $JSON::DEBUG and Carp::carp("Check used worker module..."); + + my $backend = exists $ENV{PERL_JSON_BACKEND} ? $ENV{PERL_JSON_BACKEND} : 1; + + if ($backend eq '1' or $backend =~ /JSON::XS\s*,\s*JSON::PP/) { + _load_xs($_INSTALL_DONT_DIE) or _load_pp(); + } + elsif ($backend eq '0' or $backend eq 'JSON::PP') { + _load_pp(); + } + elsif ($backend eq '2' or $backend eq 'JSON::XS') { + _load_xs(); + } + elsif ($backend eq 'JSON::backportPP') { + $_USSING_bpPP = 1; + _load_pp(); + } + else { + Carp::croak "The value of environmental variable 'PERL_JSON_BACKEND' is invalid."; + } +} + + +sub import { + my $pkg = shift; + my @what_to_export; + my $no_export; + + for my $tag (@_) { + if ($tag eq '-support_by_pp') { + if (!$_ALLOW_UNSUPPORTED++) { + JSON::Backend::XS + ->support_by_pp(@PPOnlyMethods) if ($JSON::Backend eq $Module_XS); + } + next; + } + elsif ($tag eq '-no_export') { + $no_export++, next; + } + elsif ( $tag eq '-convert_blessed_universally' ) { + eval q| + require B; + *UNIVERSAL::TO_JSON = sub { + my $b_obj = B::svref_2object( $_[0] ); + return $b_obj->isa('B::HV') ? { %{ $_[0] } } + : $b_obj->isa('B::AV') ? [ @{ $_[0] } ] + : undef + ; + } + | if ( !$_UNIV_CONV_BLESSED++ ); + next; + } + push @what_to_export, $tag; + } + + return if ($no_export); + + __PACKAGE__->export_to_level(1, $pkg, @what_to_export); +} + + +# OBSOLETED + +sub jsonToObj { + my $alternative = 'from_json'; + if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) { + shift @_; $alternative = 'decode'; + } + Carp::carp "'jsonToObj' will be obsoleted. Please use '$alternative' instead."; + return JSON::from_json(@_); +}; + +sub objToJson { + my $alternative = 'to_json'; + if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) { + shift @_; $alternative = 'encode'; + } + Carp::carp "'objToJson' will be obsoleted. Please use '$alternative' instead."; + JSON::to_json(@_); +}; + + +# INTERFACES + +sub to_json ($@) { + if ( + ref($_[0]) eq 'JSON' + or (@_ > 2 and $_[0] eq 'JSON') + ) { + Carp::croak "to_json should not be called as a method."; + } + my $json = JSON->new; + + if (@_ == 2 and ref $_[1] eq 'HASH') { + my $opt = $_[1]; + for my $method (keys %$opt) { + $json->$method( $opt->{$method} ); + } + } + + $json->encode($_[0]); +} + + +sub from_json ($@) { + if ( ref($_[0]) eq 'JSON' or $_[0] eq 'JSON' ) { + Carp::croak "from_json should not be called as a method."; + } + my $json = JSON->new; + + if (@_ == 2 and ref $_[1] eq 'HASH') { + my $opt = $_[1]; + for my $method (keys %$opt) { + $json->$method( $opt->{$method} ); + } + } + + return $json->decode( $_[0] ); +} + + +sub true { $JSON::true } + +sub false { $JSON::false } + +sub null { undef; } + + +sub require_xs_version { $XS_Version; } + +sub backend { + my $proto = shift; + $JSON::Backend; +} + +#*module = *backend; + + +sub is_xs { + return $_[0]->module eq $Module_XS; +} + + +sub is_pp { + return not $_[0]->xs; +} + + +sub pureperl_only_methods { @PPOnlyMethods; } + + +sub property { + my ($self, $name, $value) = @_; + + if (@_ == 1) { + my %props; + for $name (@Properties) { + my $method = 'get_' . $name; + if ($name eq 'max_size') { + my $value = $self->$method(); + $props{$name} = $value == 1 ? 0 : $value; + next; + } + $props{$name} = $self->$method(); + } + return \%props; + } + elsif (@_ > 3) { + Carp::croak('property() can take only the option within 2 arguments.'); + } + elsif (@_ == 2) { + if ( my $method = $self->can('get_' . $name) ) { + if ($name eq 'max_size') { + my $value = $self->$method(); + return $value == 1 ? 0 : $value; + } + $self->$method(); + } + } + else { + $self->$name($value); + } + +} + + + +# INTERNAL + +sub _load_xs { + my $opt = shift; + + $JSON::DEBUG and Carp::carp "Load $Module_XS."; + + # if called after install module, overload is disable.... why? + JSON::Boolean::_overrride_overload($Module_XS); + JSON::Boolean::_overrride_overload($Module_PP); + + eval qq| + use $Module_XS $XS_Version (); + |; + + if ($@) { + if (defined $opt and $opt & $_INSTALL_DONT_DIE) { + $JSON::DEBUG and Carp::carp "Can't load $Module_XS...($@)"; + return 0; + } + Carp::croak $@; + } + + unless (defined $opt and $opt & $_INSTALL_ONLY) { + _set_module( $JSON::Backend = $Module_XS ); + my $data = join("", <DATA>); # this code is from Jcode 2.xx. + close(DATA); + eval $data; + JSON::Backend::XS->init; + } + + return 1; +}; + + +sub _load_pp { + my $opt = shift; + my $backend = $_USSING_bpPP ? $Module_bp : $Module_PP; + + $JSON::DEBUG and Carp::carp "Load $backend."; + + # if called after install module, overload is disable.... why? + JSON::Boolean::_overrride_overload($Module_XS); + JSON::Boolean::_overrride_overload($backend); + + if ( $_USSING_bpPP ) { + eval qq| require $backend |; + } + else { + eval qq| use $backend $PP_Version () |; + } + + if ($@) { + if ( $backend eq $Module_PP ) { + $JSON::DEBUG and Carp::carp "Can't load $Module_PP ($@), so try to load $Module_bp"; + $_USSING_bpPP++; + $backend = $Module_bp; + JSON::Boolean::_overrride_overload($backend); + local $^W; # if PP installed but invalid version, backportPP redefines methods. + eval qq| require $Module_bp |; + } + Carp::croak $@ if $@; + } + + unless (defined $opt and $opt & $_INSTALL_ONLY) { + _set_module( $JSON::Backend = $Module_PP ); # even if backportPP, set $Backend with 'JSON::PP' + JSON::Backend::PP->init; + } +}; + + +sub _set_module { + return if defined $JSON::true; + + my $module = shift; + + local $^W; + no strict qw(refs); + + $JSON::true = ${"$module\::true"}; + $JSON::false = ${"$module\::false"}; + + push @JSON::ISA, $module; + push @{"$module\::Boolean::ISA"}, qw(JSON::Boolean); + + *{"JSON::is_bool"} = \&{"$module\::is_bool"}; + + for my $method ($module eq $Module_XS ? @PPOnlyMethods : @XSOnlyMethods) { + *{"JSON::$method"} = sub { + Carp::carp("$method is not supported in $module."); + $_[0]; + }; + } + + return 1; +} + + + +# +# JSON Boolean +# + +package JSON::Boolean; + +my %Installed; + +sub _overrride_overload { + return if ($Installed{ $_[0] }++); + + my $boolean = $_[0] . '::Boolean'; + + eval sprintf(q| + package %s; + use overload ( + '""' => sub { ${$_[0]} == 1 ? 'true' : 'false' }, + 'eq' => sub { + my ($obj, $op) = ref ($_[0]) ? ($_[0], $_[1]) : ($_[1], $_[0]); + if ($op eq 'true' or $op eq 'false') { + return "$obj" eq 'true' ? 'true' eq $op : 'false' eq $op; + } + else { + return $obj ? 1 == $op : 0 == $op; + } + }, + ); + |, $boolean); + + if ($@) { Carp::croak $@; } + + if ( exists $INC{'JSON/XS.pm'} and $boolean eq 'JSON::XS::Boolean' ) { + local $^W; + my $true = do { bless \(my $dummy = 1), $boolean }; + my $false = do { bless \(my $dummy = 0), $boolean }; + *JSON::XS::true = sub () { $true }; + *JSON::XS::false = sub () { $false }; + } + elsif ( exists $INC{'JSON/PP.pm'} and $boolean eq 'JSON::PP::Boolean' ) { + local $^W; + my $true = do { bless \(my $dummy = 1), $boolean }; + my $false = do { bless \(my $dummy = 0), $boolean }; + *JSON::PP::true = sub { $true }; + *JSON::PP::false = sub { $false }; + } + + return 1; +} + + +# +# Helper classes for Backend Module (PP) +# + +package JSON::Backend::PP; + +sub init { + local $^W; + no strict qw(refs); # this routine may be called after JSON::Backend::XS init was called. + *{"JSON::decode_json"} = \&{"JSON::PP::decode_json"}; + *{"JSON::encode_json"} = \&{"JSON::PP::encode_json"}; + *{"JSON::PP::is_xs"} = sub { 0 }; + *{"JSON::PP::is_pp"} = sub { 1 }; + return 1; +} + +# +# To save memory, the below lines are read only when XS backend is used. +# + +package JSON; + +1; +__DATA__ + + +# +# Helper classes for Backend Module (XS) +# + +package JSON::Backend::XS; + +use constant INDENT_LENGTH_FLAG => 15 << 12; + +use constant UNSUPPORTED_ENCODE_FLAG => { + ESCAPE_SLASH => 0x00000010, + ALLOW_BIGNUM => 0x00000020, + AS_NONBLESSED => 0x00000040, + EXPANDED => 0x10000000, # for developer's +}; + +use constant UNSUPPORTED_DECODE_FLAG => { + LOOSE => 0x00000001, + ALLOW_BIGNUM => 0x00000002, + ALLOW_BAREKEY => 0x00000004, + ALLOW_SINGLEQUOTE => 0x00000008, + EXPANDED => 0x20000000, # for developer's +}; + + +sub init { + local $^W; + no strict qw(refs); + *{"JSON::decode_json"} = \&{"JSON::XS::decode_json"}; + *{"JSON::encode_json"} = \&{"JSON::XS::encode_json"}; + *{"JSON::XS::is_xs"} = sub { 1 }; + *{"JSON::XS::is_pp"} = sub { 0 }; + return 1; +} + + +sub support_by_pp { + my ($class, @methods) = @_; + + local $^W; + no strict qw(refs); + + my $JSON_XS_encode_orignal = \&JSON::XS::encode; + my $JSON_XS_decode_orignal = \&JSON::XS::decode; + my $JSON_XS_incr_parse_orignal = \&JSON::XS::incr_parse; + + *JSON::XS::decode = \&JSON::Backend::XS::Supportable::_decode; + *JSON::XS::encode = \&JSON::Backend::XS::Supportable::_encode; + *JSON::XS::incr_parse = \&JSON::Backend::XS::Supportable::_incr_parse; + + *{JSON::XS::_original_decode} = $JSON_XS_decode_orignal; + *{JSON::XS::_original_encode} = $JSON_XS_encode_orignal; + *{JSON::XS::_original_incr_parse} = $JSON_XS_incr_parse_orignal; + + push @JSON::Backend::XS::Supportable::ISA, 'JSON'; + + my $pkg = 'JSON::Backend::XS::Supportable'; + + *{JSON::new} = sub { + my $proto = JSON::XS->new; $$proto = 0; + bless $proto, $pkg; + }; + + + for my $method (@methods) { + my $flag = uc($method); + my $type |= (UNSUPPORTED_ENCODE_FLAG->{$flag} || 0); + $type |= (UNSUPPORTED_DECODE_FLAG->{$flag} || 0); + + next unless($type); + + $pkg->_make_unsupported_method($method => $type); + } + + push @{"JSON::XS::Boolean::ISA"}, qw(JSON::PP::Boolean); + push @{"JSON::PP::Boolean::ISA"}, qw(JSON::Boolean); + + $JSON::DEBUG and Carp::carp("set -support_by_pp mode."); + + return 1; +} + + + + +# +# Helper classes for XS +# + +package JSON::Backend::XS::Supportable; + +$Carp::Internal{'JSON::Backend::XS::Supportable'} = 1; + +sub _make_unsupported_method { + my ($pkg, $method, $type) = @_; + + local $^W; + no strict qw(refs); + + *{"$pkg\::$method"} = sub { + local $^W; + if (defined $_[1] ? $_[1] : 1) { + ${$_[0]} |= $type; + } + else { + ${$_[0]} &= ~$type; + } + $_[0]; + }; + + *{"$pkg\::get_$method"} = sub { + ${$_[0]} & $type ? 1 : ''; + }; + +} + + +sub _set_for_pp { + JSON::_load_pp( $_INSTALL_ONLY ); + + my $type = shift; + my $pp = JSON::PP->new; + my $prop = $_[0]->property; + + for my $name (keys %$prop) { + $pp->$name( $prop->{$name} ? $prop->{$name} : 0 ); + } + + my $unsupported = $type eq 'encode' ? JSON::Backend::XS::UNSUPPORTED_ENCODE_FLAG + : JSON::Backend::XS::UNSUPPORTED_DECODE_FLAG; + my $flags = ${$_[0]} || 0; + + for my $name (keys %$unsupported) { + next if ($name eq 'EXPANDED'); # for developer's + my $enable = ($flags & $unsupported->{$name}) ? 1 : 0; + my $method = lc $name; + $pp->$method($enable); + } + + $pp->indent_length( $_[0]->get_indent_length ); + + return $pp; +} + +sub _encode { # using with PP encode + if (${$_[0]}) { + _set_for_pp('encode' => @_)->encode($_[1]); + } + else { + $_[0]->_original_encode( $_[1] ); + } +} + + +sub _decode { # if unsupported-flag is set, use PP + if (${$_[0]}) { + _set_for_pp('decode' => @_)->decode($_[1]); + } + else { + $_[0]->_original_decode( $_[1] ); + } +} + + +sub decode_prefix { # if unsupported-flag is set, use PP + _set_for_pp('decode' => @_)->decode_prefix($_[1]); +} + + +sub _incr_parse { + if (${$_[0]}) { + _set_for_pp('decode' => @_)->incr_parse($_[1]); + } + else { + $_[0]->_original_incr_parse( $_[1] ); + } +} + + +sub get_indent_length { + ${$_[0]} << 4 >> 16; +} + + +sub indent_length { + my $length = $_[1]; + + if (!defined $length or $length > 15 or $length < 0) { + Carp::carp "The acceptable range of indent_length() is 0 to 15."; + } + else { + local $^W; + $length <<= 12; + ${$_[0]} &= ~ JSON::Backend::XS::INDENT_LENGTH_FLAG; + ${$_[0]} |= $length; + *JSON::XS::encode = \&JSON::Backend::XS::Supportable::_encode; + } + + $_[0]; +} + + +1; +__END__ + +=head1 NAME + +JSON - JSON (JavaScript Object Notation) encoder/decoder + +=head1 SYNOPSIS + + use JSON; # imports encode_json, decode_json, to_json and from_json. + + # simple and fast interfaces (expect/generate UTF-8) + + $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; + $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; + + # OO-interface + + $json = JSON->new->allow_nonref; + + $json_text = $json->encode( $perl_scalar ); + $perl_scalar = $json->decode( $json_text ); + + $pretty_printed = $json->pretty->encode( $perl_scalar ); # pretty-printing + + # If you want to use PP only support features, call with '-support_by_pp' + # When XS unsupported feature is enable, using PP (de|en)code instead of XS ones. + + use JSON -support_by_pp; + + # option-acceptable interfaces (expect/generate UNICODE by default) + + $json_text = to_json( $perl_scalar, { ascii => 1, pretty => 1 } ); + $perl_scalar = from_json( $json_text, { utf8 => 1 } ); + + # Between (en|de)code_json and (to|from)_json, if you want to write + # a code which communicates to an outer world (encoded in UTF-8), + # recommend to use (en|de)code_json. + +=head1 VERSION + + 2.59 + +This version is compatible with JSON::XS B<2.34> and later. + + +=head1 NOTE + +JSON::PP was earlier included in the C<JSON> distribution, but +has since Perl 5.14 been a core module. For this reason, +L<JSON::PP> was removed from the JSON distribution and can now +be found also in the Perl5 repository at + +=over + +=item * L<http://perl5.git.perl.org/perl.git> + +=back + +(The newest JSON::PP version still exists in CPAN.) + +Instead, the C<JSON> distribution will include JSON::backportPP +for backwards computability. JSON.pm should thus work as it did +before. + +=head1 DESCRIPTION + + ************************** CAUTION ******************************** + * This is 'JSON module version 2' and there are many differences * + * to version 1.xx * + * Please check your applications using old version. * + * See to 'INCOMPATIBLE CHANGES TO OLD VERSION' * + ******************************************************************* + +JSON (JavaScript Object Notation) is a simple data format. +See to L<http://www.json.org/> and C<RFC4627>(L<http://www.ietf.org/rfc/rfc4627.txt>). + +This module converts Perl data structures to JSON and vice versa using either +L<JSON::XS> or L<JSON::PP>. + +JSON::XS is the fastest and most proper JSON module on CPAN which must be +compiled and installed in your environment. +JSON::PP is a pure-Perl module which is bundled in this distribution and +has a strong compatibility to JSON::XS. + +This module try to use JSON::XS by default and fail to it, use JSON::PP instead. +So its features completely depend on JSON::XS or JSON::PP. + +See to L<BACKEND MODULE DECISION>. + +To distinguish the module name 'JSON' and the format type JSON, +the former is quoted by CE<lt>E<gt> (its results vary with your using media), +and the latter is left just as it is. + +Module name : C<JSON> + +Format type : JSON + +=head2 FEATURES + +=over + +=item * correct unicode handling + +This module (i.e. backend modules) knows how to handle Unicode, documents +how and when it does so, and even documents what "correct" means. + +Even though there are limitations, this feature is available since Perl version 5.6. + +JSON::XS requires Perl 5.8.2 (but works correctly in 5.8.8 or later), so in older versions +C<JSON> should call JSON::PP as the backend which can be used since Perl 5.005. + +With Perl 5.8.x JSON::PP works, but from 5.8.0 to 5.8.2, because of a Perl side problem, +JSON::PP works slower in the versions. And in 5.005, the Unicode handling is not available. +See to L<JSON::PP/UNICODE HANDLING ON PERLS> for more information. + +See also to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL> +and L<JSON::XS/ENCODING/CODESET_FLAG_NOTES>. + + +=item * round-trip integrity + +When you serialise a perl data structure using only data types supported +by JSON and Perl, the deserialised data structure is identical on the Perl +level. (e.g. the string "2.0" doesn't suddenly become "2" just because +it looks like a number). There I<are> minor exceptions to this, read the +L</MAPPING> section below to learn about those. + + +=item * strict checking of JSON correctness + +There is no guessing, no generating of illegal JSON texts by default, +and only JSON is accepted as input by default (the latter is a security +feature). + +See to L<JSON::XS/FEATURES> and L<JSON::PP/FEATURES>. + +=item * fast + +This module returns a JSON::XS object itself if available. +Compared to other JSON modules and other serialisers such as Storable, +JSON::XS usually compares favorably in terms of speed, too. + +If not available, C<JSON> returns a JSON::PP object instead of JSON::XS and +it is very slow as pure-Perl. + +=item * simple to use + +This module has both a simple functional interface as well as an +object oriented interface interface. + +=item * reasonably versatile output formats + +You can choose between the most compact guaranteed-single-line format possible +(nice for simple line-based protocols), a pure-ASCII format (for when your transport +is not 8-bit clean, still supports the whole Unicode range), or a pretty-printed +format (for when you want to read that stuff). Or you can combine those features +in whatever way you like. + +=back + +=head1 FUNCTIONAL INTERFACE + +Some documents are copied and modified from L<JSON::XS/FUNCTIONAL INTERFACE>. +C<to_json> and C<from_json> are additional functions. + +=head2 encode_json + + $json_text = encode_json $perl_scalar + +Converts the given Perl data structure to a UTF-8 encoded, binary string. + +This function call is functionally identical to: + + $json_text = JSON->new->utf8->encode($perl_scalar) + +=head2 decode_json + + $perl_scalar = decode_json $json_text + +The opposite of C<encode_json>: expects an UTF-8 (binary) string and tries +to parse that as an UTF-8 encoded JSON text, returning the resulting +reference. + +This function call is functionally identical to: + + $perl_scalar = JSON->new->utf8->decode($json_text) + + +=head2 to_json + + $json_text = to_json($perl_scalar) + +Converts the given Perl data structure to a json string. + +This function call is functionally identical to: + + $json_text = JSON->new->encode($perl_scalar) + +Takes a hash reference as the second. + + $json_text = to_json($perl_scalar, $flag_hashref) + +So, + + $json_text = to_json($perl_scalar, {utf8 => 1, pretty => 1}) + +equivalent to: + + $json_text = JSON->new->utf8(1)->pretty(1)->encode($perl_scalar) + +If you want to write a modern perl code which communicates to outer world, +you should use C<encode_json> (supposed that JSON data are encoded in UTF-8). + +=head2 from_json + + $perl_scalar = from_json($json_text) + +The opposite of C<to_json>: expects a json string and tries +to parse it, returning the resulting reference. + +This function call is functionally identical to: + + $perl_scalar = JSON->decode($json_text) + +Takes a hash reference as the second. + + $perl_scalar = from_json($json_text, $flag_hashref) + +So, + + $perl_scalar = from_json($json_text, {utf8 => 1}) + +equivalent to: + + $perl_scalar = JSON->new->utf8(1)->decode($json_text) + +If you want to write a modern perl code which communicates to outer world, +you should use C<decode_json> (supposed that JSON data are encoded in UTF-8). + +=head2 JSON::is_bool + + $is_boolean = JSON::is_bool($scalar) + +Returns true if the passed scalar represents either JSON::true or +JSON::false, two constants that act like C<1> and C<0> respectively +and are also used to represent JSON C<true> and C<false> in Perl strings. + +=head2 JSON::true + +Returns JSON true value which is blessed object. +It C<isa> JSON::Boolean object. + +=head2 JSON::false + +Returns JSON false value which is blessed object. +It C<isa> JSON::Boolean object. + +=head2 JSON::null + +Returns C<undef>. + +See L<MAPPING>, below, for more information on how JSON values are mapped to +Perl. + +=head1 HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER + +This section supposes that your perl version is 5.8 or later. + +If you know a JSON text from an outer world - a network, a file content, and so on, +is encoded in UTF-8, you should use C<decode_json> or C<JSON> module object +with C<utf8> enable. And the decoded result will contain UNICODE characters. + + # from network + my $json = JSON->new->utf8; + my $json_text = CGI->new->param( 'json_data' ); + my $perl_scalar = $json->decode( $json_text ); + + # from file content + local $/; + open( my $fh, '<', 'json.data' ); + $json_text = <$fh>; + $perl_scalar = decode_json( $json_text ); + +If an outer data is not encoded in UTF-8, firstly you should C<decode> it. + + use Encode; + local $/; + open( my $fh, '<', 'json.data' ); + my $encoding = 'cp932'; + my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE + + # or you can write the below code. + # + # open( my $fh, "<:encoding($encoding)", 'json.data' ); + # $unicode_json_text = <$fh>; + +In this case, C<$unicode_json_text> is of course UNICODE string. +So you B<cannot> use C<decode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable or C<from_json>. + + $perl_scalar = $json->utf8(0)->decode( $unicode_json_text ); + # or + $perl_scalar = from_json( $unicode_json_text ); + +Or C<encode 'utf8'> and C<decode_json>: + + $perl_scalar = decode_json( encode( 'utf8', $unicode_json_text ) ); + # this way is not efficient. + +And now, you want to convert your C<$perl_scalar> into JSON data and +send it to an outer world - a network or a file content, and so on. + +Your data usually contains UNICODE strings and you want the converted data to be encoded +in UTF-8, you should use C<encode_json> or C<JSON> module object with C<utf8> enable. + + print encode_json( $perl_scalar ); # to a network? file? or display? + # or + print $json->utf8->encode( $perl_scalar ); + +If C<$perl_scalar> does not contain UNICODE but C<$encoding>-encoded strings +for some reason, then its characters are regarded as B<latin1> for perl +(because it does not concern with your $encoding). +You B<cannot> use C<encode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable or C<to_json>. +Note that the resulted text is a UNICODE string but no problem to print it. + + # $perl_scalar contains $encoding encoded string values + $unicode_json_text = $json->utf8(0)->encode( $perl_scalar ); + # or + $unicode_json_text = to_json( $perl_scalar ); + # $unicode_json_text consists of characters less than 0x100 + print $unicode_json_text; + +Or C<decode $encoding> all string values and C<encode_json>: + + $perl_scalar->{ foo } = decode( $encoding, $perl_scalar->{ foo } ); + # ... do it to each string values, then encode_json + $json_text = encode_json( $perl_scalar ); + +This method is a proper way but probably not efficient. + +See to L<Encode>, L<perluniintro>. + + +=head1 COMMON OBJECT-ORIENTED INTERFACE + +=head2 new + + $json = JSON->new + +Returns a new C<JSON> object inherited from either JSON::XS or JSON::PP +that can be used to de/encode JSON strings. + +All boolean flags described below are by default I<disabled>. + +The mutators for flags all return the JSON object again and thus calls can +be chained: + + my $json = JSON->new->utf8->space_after->encode({a => [1,2]}) + => {"a": [1, 2]} + +=head2 ascii + + $json = $json->ascii([$enable]) + + $enabled = $json->get_ascii + +If $enable is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627. + +If $enable is false, then the encode method will not escape Unicode characters unless +required by the JSON syntax or other flags. This results in a faster and more compact format. + +This feature depends on the used Perl version and environment. + +See to L<JSON::PP/UNICODE HANDLING ON PERLS> if the backend is PP. + + JSON->new->ascii(1)->encode([chr 0x10401]) + => ["\ud801\udc01"] + +=head2 latin1 + + $json = $json->latin1([$enable]) + + $enabled = $json->get_latin1 + +If $enable is true (or missing), then the encode method will encode the resulting JSON +text as latin1 (or iso-8859-1), escaping any characters outside the code range 0..255. + +If $enable is false, then the encode method will not escape Unicode characters +unless required by the JSON syntax or other flags. + + JSON->new->latin1->encode (["\x{89}\x{abc}"] + => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not) + +=head2 utf8 + + $json = $json->utf8([$enable]) + + $enabled = $json->get_utf8 + +If $enable is true (or missing), then the encode method will encode the JSON result +into UTF-8, as required by many protocols, while the decode method expects to be handled +an UTF-8-encoded string. Please note that UTF-8-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. + +In future versions, enabling this option might enable autodetection of the UTF-16 and UTF-32 +encoding families, as described in RFC4627. + +If $enable is false, then the encode method will return the JSON string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to UTF-8 or UTF-16) needs to be done yourself, e.g. using the Encode module. + + +Example, output UTF-16BE-encoded JSON: + + use Encode; + $jsontext = encode "UTF-16BE", JSON::XS->new->encode ($object); + +Example, decode UTF-32LE-encoded JSON: + + use Encode; + $object = JSON::XS->new->decode (decode "UTF-32LE", $jsontext); + +See to L<JSON::PP/UNICODE HANDLING ON PERLS> if the backend is PP. + + +=head2 pretty + + $json = $json->pretty([$enable]) + +This enables (or disables) all of the C<indent>, C<space_before> and +C<space_after> (and in the future possibly more) flags in one call to +generate the most readable (or most compact) form possible. + +Equivalent to: + + $json->indent->space_before->space_after + +The indent space length is three and JSON::XS cannot change the indent +space length. + +=head2 indent + + $json = $json->indent([$enable]) + + $enabled = $json->get_indent + +If C<$enable> is true (or missing), then the C<encode> method will use a multiline +format as output, putting every array member or object/hash key-value pair +into its own line, identifying them properly. + +If C<$enable> is false, no newlines or indenting will be produced, and the +resulting JSON text is guaranteed not to contain any C<newlines>. + +This setting has no effect when decoding JSON texts. + +The indent space length is three. +With JSON::PP, you can also access C<indent_length> to change indent space length. + + +=head2 space_before + + $json = $json->space_before([$enable]) + + $enabled = $json->get_space_before + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space before the C<:> separating keys from values in JSON objects. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before enabled, space_after and indent disabled: + + {"key" :"value"} + + +=head2 space_after + + $json = $json->space_after([$enable]) + + $enabled = $json->get_space_after + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space after the C<:> separating keys from values in JSON objects +and extra whitespace after the C<,> separating key-value pairs and array +members. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before and indent disabled, space_after enabled: + + {"key": "value"} + + +=head2 relaxed + + $json = $json->relaxed([$enable]) + + $enabled = $json->get_relaxed + +If C<$enable> is true (or missing), then C<decode> will accept some +extensions to normal JSON syntax (see below). C<encode> will not be +affected in anyway. I<Be aware that this option makes you accept invalid +JSON texts as if they were valid!>. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) + +If C<$enable> is false (the default), then C<decode> will only accept +valid JSON texts. + +Currently accepted extensions are: + +=over 4 + +=item * list items can have an end-comma + +JSON I<separates> array elements and key-value pairs with commas. This +can be annoying if you write JSON texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: + + [ + 1, + 2, <- this comma not normally allowed + ] + { + "k1": "v1", + "k2": "v2", <- this comma not normally allowed + } + +=item * shell-style '#'-comments + +Whenever JSON allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. + + [ + 1, # this comment not allowed in JSON + # neither this one... + ] + +=back + + +=head2 canonical + + $json = $json->canonical([$enable]) + + $enabled = $json->get_canonical + +If C<$enable> is true (or missing), then the C<encode> method will output JSON objects +by sorting their keys. This is adding a comparatively high overhead. + +If C<$enable> is false, then the C<encode> method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). + +This option is useful if you want the same data structure to be encoded as +the same JSON text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. + +This setting has no effect when decoding JSON texts. + +=head2 allow_nonref + + $json = $json->allow_nonref([$enable]) + + $enabled = $json->get_allow_nonref + +If C<$enable> is true (or missing), then the C<encode> method can convert a +non-reference into its corresponding string, number or null JSON value, +which is an extension to RFC4627. Likewise, C<decode> will accept those JSON +values instead of croaking. + +If C<$enable> is false, then the C<encode> method will croak if it isn't +passed an arrayref or hashref, as JSON texts must either be an object +or array. Likewise, C<decode> will croak if given something that is not a +JSON object or array. + + JSON->new->allow_nonref->encode ("Hello, World!") + => "Hello, World!" + +=head2 allow_unknown + + $json = $json->allow_unknown ([$enable]) + + $enabled = $json->get_allow_unknown + +If $enable is true (or missing), then "encode" will *not* throw an +exception when it encounters values it cannot represent in JSON (for +example, filehandles) but instead will encode a JSON "null" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. + +If $enable is false (the default), then "encode" will throw an +exception when it encounters anything it cannot encode as JSON. + +This option does not affect "decode" in any way, and it is +recommended to leave it off unless you know your communications +partner. + +=head2 allow_blessed + + $json = $json->allow_blessed([$enable]) + + $enabled = $json->get_allow_blessed + +If C<$enable> is true (or missing), then the C<encode> method will not +barf when it encounters a blessed reference. Instead, the value of the +B<convert_blessed> option will decide whether C<null> (C<convert_blessed> +disabled or no C<TO_JSON> method found) or a representation of the +object (C<convert_blessed> enabled and C<TO_JSON> method found) is being +encoded. Has no effect on C<decode>. + +If C<$enable> is false (the default), then C<encode> will throw an +exception when it encounters a blessed object. + + +=head2 convert_blessed + + $json = $json->convert_blessed([$enable]) + + $enabled = $json->get_convert_blessed + +If C<$enable> is true (or missing), then C<encode>, upon encountering a +blessed object, will check for the availability of the C<TO_JSON> method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +C<TO_JSON> method is found, the value of C<allow_blessed> will decide what +to do. + +The C<TO_JSON> method may safely call die if it wants. If C<TO_JSON> +returns other blessed objects, those will be handled in the same +way. C<TO_JSON> must take care of not causing an endless recursion cycle +(== crash) in this case. The name of C<TO_JSON> was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the C<to_json> +function or method. + +This setting does not yet influence C<decode> in any way. + +If C<$enable> is false, then the C<allow_blessed> setting will decide what +to do when a blessed object is found. + +=over + +=item convert_blessed_universally mode + +If use C<JSON> with C<-convert_blessed_universally>, the C<UNIVERSAL::TO_JSON> +subroutine is defined as the below code: + + *UNIVERSAL::TO_JSON = sub { + my $b_obj = B::svref_2object( $_[0] ); + return $b_obj->isa('B::HV') ? { %{ $_[0] } } + : $b_obj->isa('B::AV') ? [ @{ $_[0] } ] + : undef + ; + } + +This will cause that C<encode> method converts simple blessed objects into +JSON objects as non-blessed object. + + JSON -convert_blessed_universally; + $json->allow_blessed->convert_blessed->encode( $blessed_object ) + +This feature is experimental and may be removed in the future. + +=back + +=head2 filter_json_object + + $json = $json->filter_json_object([$coderef]) + +When C<$coderef> is specified, it will be called from C<decode> each +time it decodes a JSON object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(NOTE: I<not> C<undef>, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. + +When C<$coderef> is omitted or undefined, any existing callback will +be removed and C<decode> will not change the deserialised hash in any +way. + +Example, convert all JSON objects into the integer 5: + + my $js = JSON->new->filter_json_object (sub { 5 }); + # returns [5] + $js->decode ('[{}]'); # the given subroutine takes a hash reference. + # throw an exception because allow_nonref is not enabled + # so a lone 5 is not allowed. + $js->decode ('{"a":1, "b":2}'); + + +=head2 filter_json_single_key_object + + $json = $json->filter_json_single_key_object($key [=> $coderef]) + +Works remotely similar to C<filter_json_object>, but is only called for +JSON objects having a single key named C<$key>. + +This C<$coderef> is called before the one specified via +C<filter_json_object>, if any. It gets passed the single value in the JSON +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even C<undef> but the empty list), +the callback from C<filter_json_object> will be called next, as if no +single-key callback were specified. + +If C<$coderef> is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. + +As this callback gets called less often then the C<filter_json_object> +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key JSON objects are as close to the type-tagged value concept +as JSON gets (it's basically an ID/VALUE tuple). Of course, JSON does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. + +Typical names for the single object key are C<__class_whatever__>, or +C<$__dollars_are_rarely_used__$> or C<}ugly_brace_placement>, or even +things like C<__class_md5sum(classname)__>, to reduce the risk of clashing +with real hashes. + +Example, decode JSON objects of the form C<< { "__widget__" => <id> } >> +into the corresponding C<< $WIDGET{<id>} >> object: + + # return whatever is in $WIDGET{5}: + JSON + ->new + ->filter_json_single_key_object (__widget__ => sub { + $WIDGET{ $_[0] } + }) + ->decode ('{"__widget__": 5') + + # this can be used with a TO_JSON method in some "widget" class + # for serialisation to json: + sub WidgetBase::TO_JSON { + my ($self) = @_; + + unless ($self->{id}) { + $self->{id} = ..get..some..id..; + $WIDGET{$self->{id}} = $self; + } + + { __widget__ => $self->{id} } + } + + +=head2 shrink + + $json = $json->shrink([$enable]) + + $enabled = $json->get_shrink + +With JSON::XS, this flag resizes strings generated by either +C<encode> or C<decode> to their minimum size possible. This can save +memory when your JSON texts are either very very long or you have many +short strings. It will also try to downgrade any strings to octet-form +if possible: perl stores strings internally either in an encoding called +UTF-X or in octet-form. The latter cannot store everything but uses less +space in general (and some buggy Perl or C code might even rely on that +internal representation being used). + +With JSON::PP, it is noop about resizing strings but tries +C<utf8::downgrade> to the returned string by C<encode>. See to L<utf8>. + +See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> and L<JSON::PP/METHODS>. + +=head2 max_depth + + $json = $json->max_depth([$maximum_nesting_depth]) + + $max_depth = $json->get_max_depth + +Sets the maximum nesting level (default C<512>) accepted while encoding +or decoding. If a higher nesting level is detected in JSON text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. + +Nesting level is defined by number of hash- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of C<{> or C<[> +characters without their matching closing parenthesis crossed to reach a +given character in a string. + +If no argument is given, the highest possible setting will be used, which +is rarely useful. + +Note that nesting is implemented by recursion in C. The default value has +been chosen to be as large as typical operating systems allow without +crashing. (JSON::XS) + +With JSON::PP as the backend, when a large value (100 or more) was set and +it de/encodes a deep nested object/text, it may raise a warning +'Deep recursion on subroutine' at the perl runtime phase. + +See L<JSON::XS/SECURITY CONSIDERATIONS> for more info on why this is useful. + +=head2 max_size + + $json = $json->max_size([$maximum_string_size]) + + $max_size = $json->get_max_size + +Set the maximum length a JSON text may have (in bytes) where decoding is +being attempted. The default is C<0>, meaning no limit. When C<decode> +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on C<encode> (yet). + +If no argument is given, the limit check will be deactivated (same as when +C<0> is specified). + +See L<JSON::XS/SECURITY CONSIDERATIONS>, below, for more info on why this is useful. + +=head2 encode + + $json_text = $json->encode($perl_scalar) + +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its JSON representation. Simple scalars will be +converted into JSON string or number sequences, while references to arrays +become JSON arrays and references to hashes become JSON objects. Undefined +Perl values (e.g. C<undef>) become JSON C<null> values. +References to the integers C<0> and C<1> are converted into C<true> and C<false>. + +=head2 decode + + $perl_scalar = $json->decode($json_text) + +The opposite of C<encode>: expects a JSON text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. + +JSON numbers and strings become simple Perl scalars. JSON arrays become +Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes +C<1> (C<JSON::true>), C<false> becomes C<0> (C<JSON::false>) and +C<null> becomes C<undef>. + +=head2 decode_prefix + + ($perl_scalar, $characters) = $json->decode_prefix($json_text) + +This works like the C<decode> method, but instead of raising an exception +when there is trailing garbage after the first JSON object, it will +silently stop parsing there and return the number of characters consumed +so far. + + JSON->new->decode_prefix ("[1] the tail") + => ([], 3) + +See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> + +=head2 property + + $boolean = $json->property($property_name) + +Returns a boolean value about above some properties. + +The available properties are C<ascii>, C<latin1>, C<utf8>, +C<indent>,C<space_before>, C<space_after>, C<relaxed>, C<canonical>, +C<allow_nonref>, C<allow_unknown>, C<allow_blessed>, C<convert_blessed>, +C<shrink>, C<max_depth> and C<max_size>. + + $boolean = $json->property('utf8'); + => 0 + $json->utf8; + $boolean = $json->property('utf8'); + => 1 + +Sets the property with a given boolean value. + + $json = $json->property($property_name => $boolean); + +With no argument, it returns all the above properties as a hash reference. + + $flag_hashref = $json->property(); + +=head1 INCREMENTAL PARSING + +Most of this section are copied and modified from L<JSON::XS/INCREMENTAL PARSING>. + +In some cases, there is the need for incremental parsing of JSON texts. +This module does allow you to parse a JSON stream incrementally. +It does so by accumulating text until it has a full JSON object, which +it then can decode. This process is similar to using C<decode_prefix> +to see if a full JSON object is available, but is much more efficient +(and can be implemented with a minimum of method calls). + +The backend module will only attempt to parse the JSON text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid JSON text has been seen. This means you need +to set resource limits (e.g. C<max_size>) to ensure the parser will stop +parsing in the presence if syntax errors. + +The following methods implement this incremental parser. + +=head2 incr_parse + + $json->incr_parse( [$string] ) # void context + + $obj_or_undef = $json->incr_parse( [$string] ) # scalar context + + @obj_or_empty = $json->incr_parse( [$string] ) # list context + +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). + +If C<$string> is given, then this string is appended to the already +existing JSON fragment stored in the C<$json> object. + +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. + +If the method is called in scalar context, then it will try to extract +exactly I<one> JSON object. If that is successful, it will return this +object, otherwise it will return C<undef>. If there is a parse error, +this method will croak just as C<decode> would do (one can then use +C<incr_skip> to skip the erroneous part). This is the most common way of +using the method. + +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the JSON +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed JSON texts will be +lost. + +Example: Parse some JSON arrays/objects in a given string and return them. + + my @objs = JSON->new->incr_parse ("[5][7][1,2]"); + +=head2 incr_text + + $lvalue_string = $json->incr_text + +This method returns the currently stored JSON fragment as an lvalue, that +is, you can manipulate it. This I<only> works when a preceding call to +C<incr_parse> in I<scalar context> successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it I<will> fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. + +This function is useful in two cases: a) finding the trailing text after a +JSON object or b) parsing multiple JSON objects separated by non-JSON text +(such as commas). + + $json->incr_text =~ s/\s*,\s*//; + +In Perl 5.005, C<lvalue> attribute is not available. +You must write codes like the below: + + $string = $json->incr_text; + $string =~ s/\s*,\s*//; + $json->incr_text( $string ); + +=head2 incr_skip + + $json->incr_skip + +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after C<incr_parse> +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. + +=head2 incr_reset + + $json->incr_reset + +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. + +This is useful if you want to repeatedly parse JSON objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. + +See to L<JSON::XS/INCREMENTAL PARSING> for examples. + + +=head1 JSON::PP SUPPORT METHODS + +The below methods are JSON::PP own methods, so when C<JSON> works +with JSON::PP (i.e. the created object is a JSON::PP object), available. +See to L<JSON::PP/JSON::PP OWN METHODS> in detail. + +If you use C<JSON> with additional C<-support_by_pp>, some methods +are available even with JSON::XS. See to L<USE PP FEATURES EVEN THOUGH XS BACKEND>. + + BEING { $ENV{PERL_JSON_BACKEND} = 'JSON::XS' } + + use JSON -support_by_pp; + + my $json = JSON->new; + $json->allow_nonref->escape_slash->encode("/"); + + # functional interfaces too. + print to_json(["/"], {escape_slash => 1}); + print from_json('["foo"]', {utf8 => 1}); + +If you do not want to all functions but C<-support_by_pp>, +use C<-no_export>. + + use JSON -support_by_pp, -no_export; + # functional interfaces are not exported. + +=head2 allow_singlequote + + $json = $json->allow_singlequote([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +any JSON strings quoted by single quotations that are invalid JSON +format. + + $json->allow_singlequote->decode({"foo":'bar'}); + $json->allow_singlequote->decode({'foo':"bar"}); + $json->allow_singlequote->decode({'foo':'bar'}); + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + +=head2 allow_barekey + + $json = $json->allow_barekey([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +bare keys of JSON object that are invalid JSON format. + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + + $json->allow_barekey->decode('{foo:"bar"}'); + +=head2 allow_bignum + + $json = $json->allow_bignum([$enable]) + +If C<$enable> is true (or missing), then C<decode> will convert +the big integer Perl cannot handle as integer into a L<Math::BigInt> +object and convert a floating number (any) into a L<Math::BigFloat>. + +On the contrary, C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers with C<allow_blessed> enable. + + $json->allow_nonref->allow_blessed->allow_bignum; + $bigfloat = $json->decode('2.000000000000000000000000001'); + print $json->encode($bigfloat); + # => 2.000000000000000000000000001 + +See to L<MAPPING> about the conversion of JSON number. + +=head2 loose + + $json = $json->loose([$enable]) + +The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON strings +and the module doesn't allow to C<decode> to these (except for \x2f). +If C<$enable> is true (or missing), then C<decode> will accept these +unescaped strings. + + $json->loose->decode(qq|["abc + def"]|); + +See to L<JSON::PP/JSON::PP OWN METHODS>. + +=head2 escape_slash + + $json = $json->escape_slash([$enable]) + +According to JSON Grammar, I<slash> (U+002F) is escaped. But by default +JSON backend modules encode strings without escaping slash. + +If C<$enable> is true (or missing), then C<encode> will escape slashes. + +=head2 indent_length + + $json = $json->indent_length($length) + +With JSON::XS, The indent space length is 3 and cannot be changed. +With JSON::PP, it sets the indent space length with the given $length. +The default is 3. The acceptable range is 0 to 15. + +=head2 sort_by + + $json = $json->sort_by($function_name) + $json = $json->sort_by($subroutine_ref) + +If $function_name or $subroutine_ref are set, its sort routine are used. + + $js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + $js = $pc->sort_by('own_sort')->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } + +As the sorting routine runs in the JSON::PP scope, the given +subroutine name and the special variables C<$a>, C<$b> will begin +with 'JSON::PP::'. + +If $integer is set, then the effect is same as C<canonical> on. + +See to L<JSON::PP/JSON::PP OWN METHODS>. + +=head1 MAPPING + +This section is copied from JSON::XS and modified to C<JSON>. +JSON::XS and JSON::PP mapping mechanisms are almost equivalent. + +See to L<JSON::XS/MAPPING>. + +=head2 JSON -> PERL + +=over 4 + +=item object + +A JSON object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (JSON does not preserver object key ordering itself). + +=item array + +A JSON array becomes a reference to an array in Perl. + +=item string + +A JSON string becomes a string scalar in Perl - Unicode codepoints in JSON +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. + +=item number + +A JSON number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. + +If the number consists of digits only, C<JSON> will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the JSON number will be +re-encoded to a JSON string). + +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the JSON number will still be re-encoded as a JSON number). + +Note that precision is not accuracy - binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, C<JSON> only guarantees precision up to but not including +the least significant bit. + +If the backend is JSON::PP and C<allow_bignum> is enable, the big integers +and the numeric can be optionally converted into L<Math::BigInt> and +L<Math::BigFloat> objects. + +=item true, false + +These JSON atoms become C<JSON::true> and C<JSON::false>, +respectively. They are overloaded to act almost exactly like the numbers +C<1> and C<0>. You can check whether a scalar is a JSON boolean by using +the C<JSON::is_bool> function. + +If C<JSON::true> and C<JSON::false> are used as strings or compared as strings, +they represent as C<true> and C<false> respectively. + + print JSON::true . "\n"; + => true + print JSON::true + 1; + => 1 + + ok(JSON::true eq 'true'); + ok(JSON::true eq '1'); + ok(JSON::true == 1); + +C<JSON> will install these missing overloading features to the backend modules. + + +=item null + +A JSON null atom becomes C<undef> in Perl. + +C<JSON::null> returns C<undef>. + +=back + + +=head2 PERL -> JSON + +The mapping from Perl to JSON is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which JSON type is meant by +a Perl value. + +=over 4 + +=item hash references + +Perl hash references become JSON objects. As there is no inherent ordering +in hash keys (or JSON objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. C<JSON> +optionally sort the hash keys (determined by the I<canonical> flag), so +the same data structure will serialise to the same JSON text (given same +settings and version of JSON::XS), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some JSON text +against another for equality. + +In future, the ordered object feature will be added to JSON::PP using C<tie> mechanism. + + +=item array references + +Perl array references become JSON arrays. + +=item other references + +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers C<0> and +C<1>, which get turned into C<false> and C<true> atoms in JSON. You can +also use C<JSON::false> and C<JSON::true> to improve readability. + + to_json [\0,JSON::true] # yields [false,true] + +=item JSON::true, JSON::false, JSON::null + +These special values become JSON true and JSON false values, +respectively. You can also use C<\1> and C<\0> directly if you want. + +JSON::null returns C<undef>. + +=item blessed objects + +Blessed objects are not directly representable in JSON. See the +C<allow_blessed> and C<convert_blessed> methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. + +With C<convert_blessed_universally> mode, C<encode> converts blessed +hash references or blessed array references (contains other blessed references) +into JSON members and arrays. + + use JSON -convert_blessed_universally; + JSON->new->allow_blessed->convert_blessed->encode( $blessed_object ); + +See to L<convert_blessed>. + +=item simple scalars + +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: JSON::XS and JSON::PP will encode undefined scalars as +JSON C<null> values, scalars that have last been used in a string context +before encoding as JSON strings, and anything else as number value: + + # dump as number + encode_json [2] # yields [2] + encode_json [-3.0e17] # yields [-3e+17] + my $value = 5; encode_json [$value] # yields [5] + + # used as string, so dump as string + print $value; + encode_json [$value] # yields ["5"] + + # undef becomes null + encode_json [undef] # yields [null] + +You can force the type to be a string by stringifying it: + + my $x = 3.1; # some variable containing a number + "$x"; # stringified + $x .= ""; # another, more awkward way to stringify + print $x; # perl does it for you, too, quite often + +You can force the type to be a number by numifying it: + + my $x = "3"; # some variable containing a string + $x += 0; # numify it, ensuring it will be dumped as a number + $x *= 1; # same thing, the choice is yours. + +You can not currently force the type in other, less obscure, ways. + +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's - these cannot be represented in JSON, and it is an +error to pass those in. + +=item Big Number + +If the backend is JSON::PP and C<allow_bignum> is enable, +C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers. + + +=back + +=head1 JSON and ECMAscript + +See to L<JSON::XS/JSON and ECMAscript>. + +=head1 JSON and YAML + +JSON is not a subset of YAML. +See to L<JSON::XS/JSON and YAML>. + + +=head1 BACKEND MODULE DECISION + +When you use C<JSON>, C<JSON> tries to C<use> JSON::XS. If this call failed, it will +C<uses> JSON::PP. The required JSON::XS version is I<2.2> or later. + +The C<JSON> constructor method returns an object inherited from the backend module, +and JSON::XS object is a blessed scalar reference while JSON::PP is a blessed hash +reference. + +So, your program should not depend on the backend module, especially +returned objects should not be modified. + + my $json = JSON->new; # XS or PP? + $json->{stash} = 'this is xs object'; # this code may raise an error! + +To check the backend module, there are some methods - C<backend>, C<is_pp> and C<is_xs>. + + JSON->backend; # 'JSON::XS' or 'JSON::PP' + + JSON->backend->is_pp: # 0 or 1 + + JSON->backend->is_xs: # 1 or 0 + + $json->is_xs; # 1 or 0 + + $json->is_pp; # 0 or 1 + + +If you set an environment variable C<PERL_JSON_BACKEND>, the calling action will be changed. + +=over + +=item PERL_JSON_BACKEND = 0 or PERL_JSON_BACKEND = 'JSON::PP' + +Always use JSON::PP + +=item PERL_JSON_BACKEND == 1 or PERL_JSON_BACKEND = 'JSON::XS,JSON::PP' + +(The default) Use compiled JSON::XS if it is properly compiled & installed, +otherwise use JSON::PP. + +=item PERL_JSON_BACKEND == 2 or PERL_JSON_BACKEND = 'JSON::XS' + +Always use compiled JSON::XS, die if it isn't properly compiled & installed. + +=item PERL_JSON_BACKEND = 'JSON::backportPP' + +Always use JSON::backportPP. +JSON::backportPP is JSON::PP back port module. +C<JSON> includes JSON::backportPP instead of JSON::PP. + +=back + +These ideas come from L<DBI::PurePerl> mechanism. + +example: + + BEGIN { $ENV{PERL_JSON_BACKEND} = 'JSON::PP' } + use JSON; # always uses JSON::PP + +In future, it may be able to specify another module. + +=head1 USE PP FEATURES EVEN THOUGH XS BACKEND + +Many methods are available with either JSON::XS or JSON::PP and +when the backend module is JSON::XS, if any JSON::PP specific (i.e. JSON::XS unsupported) +method is called, it will C<warn> and be noop. + +But If you C<use> C<JSON> passing the optional string C<-support_by_pp>, +it makes a part of those unsupported methods available. +This feature is achieved by using JSON::PP in C<de/encode>. + + BEGIN { $ENV{PERL_JSON_BACKEND} = 2 } # with JSON::XS + use JSON -support_by_pp; + my $json = JSON->new; + $json->allow_nonref->escape_slash->encode("/"); + +At this time, the returned object is a C<JSON::Backend::XS::Supportable> +object (re-blessed XS object), and by checking JSON::XS unsupported flags +in de/encoding, can support some unsupported methods - C<loose>, C<allow_bignum>, +C<allow_barekey>, C<allow_singlequote>, C<escape_slash> and C<indent_length>. + +When any unsupported methods are not enable, C<XS de/encode> will be +used as is. The switch is achieved by changing the symbolic tables. + +C<-support_by_pp> is effective only when the backend module is JSON::XS +and it makes the de/encoding speed down a bit. + +See to L<JSON::PP SUPPORT METHODS>. + +=head1 INCOMPATIBLE CHANGES TO OLD VERSION + +There are big incompatibility between new version (2.00) and old (1.xx). +If you use old C<JSON> 1.xx in your code, please check it. + +See to L<Transition ways from 1.xx to 2.xx.> + +=over + +=item jsonToObj and objToJson are obsoleted. + +Non Perl-style name C<jsonToObj> and C<objToJson> are obsoleted +(but not yet deleted from the source). +If you use these functions in your code, please replace them +with C<from_json> and C<to_json>. + + +=item Global variables are no longer available. + +C<JSON> class variables - C<$JSON::AUTOCONVERT>, C<$JSON::BareKey>, etc... +- are not available any longer. +Instead, various features can be used through object methods. + + +=item Package JSON::Converter and JSON::Parser are deleted. + +Now C<JSON> bundles with JSON::PP which can handle JSON more properly than them. + +=item Package JSON::NotString is deleted. + +There was C<JSON::NotString> class which represents JSON value C<true>, C<false>, C<null> +and numbers. It was deleted and replaced by C<JSON::Boolean>. + +C<JSON::Boolean> represents C<true> and C<false>. + +C<JSON::Boolean> does not represent C<null>. + +C<JSON::null> returns C<undef>. + +C<JSON> makes L<JSON::XS::Boolean> and L<JSON::PP::Boolean> is-a relation +to L<JSON::Boolean>. + +=item function JSON::Number is obsoleted. + +C<JSON::Number> is now needless because JSON::XS and JSON::PP have +round-trip integrity. + +=item JSONRPC modules are deleted. + +Perl implementation of JSON-RPC protocol - C<JSONRPC >, C<JSONRPC::Transport::HTTP> +and C<Apache::JSONRPC > are deleted in this distribution. +Instead of them, there is L<JSON::RPC> which supports JSON-RPC protocol version 1.1. + +=back + +=head2 Transition ways from 1.xx to 2.xx. + +You should set C<suport_by_pp> mode firstly, because +it is always successful for the below codes even with JSON::XS. + + use JSON -support_by_pp; + +=over + +=item Exported jsonToObj (simple) + + from_json($json_text); + +=item Exported objToJson (simple) + + to_json($perl_scalar); + +=item Exported jsonToObj (advanced) + + $flags = {allow_barekey => 1, allow_singlequote => 1}; + from_json($json_text, $flags); + +equivalent to: + + $JSON::BareKey = 1; + $JSON::QuotApos = 1; + jsonToObj($json_text); + +=item Exported objToJson (advanced) + + $flags = {allow_blessed => 1, allow_barekey => 1}; + to_json($perl_scalar, $flags); + +equivalent to: + + $JSON::BareKey = 1; + objToJson($perl_scalar); + +=item jsonToObj as object method + + $json->decode($json_text); + +=item objToJson as object method + + $json->encode($perl_scalar); + +=item new method with parameters + +The C<new> method in 2.x takes any parameters no longer. +You can set parameters instead; + + $json = JSON->new->pretty; + +=item $JSON::Pretty, $JSON::Indent, $JSON::Delimiter + +If C<indent> is enable, that means C<$JSON::Pretty> flag set. And +C<$JSON::Delimiter> was substituted by C<space_before> and C<space_after>. +In conclusion: + + $json->indent->space_before->space_after; + +Equivalent to: + + $json->pretty; + +To change indent length, use C<indent_length>. + +(Only with JSON::PP, if C<-support_by_pp> is not used.) + + $json->pretty->indent_length(2)->encode($perl_scalar); + +=item $JSON::BareKey + +(Only with JSON::PP, if C<-support_by_pp> is not used.) + + $json->allow_barekey->decode($json_text) + +=item $JSON::ConvBlessed + +use C<-convert_blessed_universally>. See to L<convert_blessed>. + +=item $JSON::QuotApos + +(Only with JSON::PP, if C<-support_by_pp> is not used.) + + $json->allow_singlequote->decode($json_text) + +=item $JSON::SingleQuote + +Disable. C<JSON> does not make such a invalid JSON string any longer. + +=item $JSON::KeySort + + $json->canonical->encode($perl_scalar) + +This is the ascii sort. + +If you want to use with your own sort routine, check the C<sort_by> method. + +(Only with JSON::PP, even if C<-support_by_pp> is used currently.) + + $json->sort_by($sort_routine_ref)->encode($perl_scalar) + + $json->sort_by(sub { $JSON::PP::a <=> $JSON::PP::b })->encode($perl_scalar) + +Can't access C<$a> and C<$b> but C<$JSON::PP::a> and C<$JSON::PP::b>. + +=item $JSON::SkipInvalid + + $json->allow_unknown + +=item $JSON::AUTOCONVERT + +Needless. C<JSON> backend modules have the round-trip integrity. + +=item $JSON::UTF8 + +Needless because C<JSON> (JSON::XS/JSON::PP) sets +the UTF8 flag on properly. + + # With UTF8-flagged strings + + $json->allow_nonref; + $str = chr(1000); # UTF8-flagged + + $json_text = $json->utf8(0)->encode($str); + utf8::is_utf8($json_text); + # true + $json_text = $json->utf8(1)->encode($str); + utf8::is_utf8($json_text); + # false + + $str = '"' . chr(1000) . '"'; # UTF8-flagged + + $perl_scalar = $json->utf8(0)->decode($str); + utf8::is_utf8($perl_scalar); + # true + $perl_scalar = $json->utf8(1)->decode($str); + # died because of 'Wide character in subroutine' + +See to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL>. + +=item $JSON::UnMapping + +Disable. See to L<MAPPING>. + +=item $JSON::SelfConvert + +This option was deleted. +Instead of it, if a given blessed object has the C<TO_JSON> method, +C<TO_JSON> will be executed with C<convert_blessed>. + + $json->convert_blessed->encode($blessed_hashref_or_arrayref) + # if need, call allow_blessed + +Note that it was C<toJson> in old version, but now not C<toJson> but C<TO_JSON>. + +=back + +=head1 TODO + +=over + +=item example programs + +=back + +=head1 THREADS + +No test with JSON::PP. If with JSON::XS, See to L<JSON::XS/THREADS>. + + +=head1 BUGS + +Please report bugs relevant to C<JSON> to E<lt>makamaka[at]cpan.orgE<gt>. + + +=head1 SEE ALSO + +Most of the document is copied and modified from JSON::XS doc. + +L<JSON::XS>, L<JSON::PP> + +C<RFC4627>(L<http://www.ietf.org/rfc/rfc4627.txt>) + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + +JSON::XS was written by Marc Lehmann <schmorp[at]schmorp.de> + +The release of this new version owes to the courtesy of Marc Lehmann. + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2005-2013 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP.pm b/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP.pm new file mode 100644 index 0000000..cdf0c76 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP.pm @@ -0,0 +1,2803 @@ +package # This is JSON::backportPP + JSON::PP; + +# JSON-2.0 + +use 5.005; +use strict; +use base qw(Exporter); +use overload (); + +use Carp (); +use B (); +#use Devel::Peek; + +use vars qw($VERSION); +$VERSION = '2.27202'; + +@JSON::PP::EXPORT = qw(encode_json decode_json from_json to_json); + +# instead of hash-access, i tried index-access for speed. +# but this method is not faster than what i expected. so it will be changed. + +use constant P_ASCII => 0; +use constant P_LATIN1 => 1; +use constant P_UTF8 => 2; +use constant P_INDENT => 3; +use constant P_CANONICAL => 4; +use constant P_SPACE_BEFORE => 5; +use constant P_SPACE_AFTER => 6; +use constant P_ALLOW_NONREF => 7; +use constant P_SHRINK => 8; +use constant P_ALLOW_BLESSED => 9; +use constant P_CONVERT_BLESSED => 10; +use constant P_RELAXED => 11; + +use constant P_LOOSE => 12; +use constant P_ALLOW_BIGNUM => 13; +use constant P_ALLOW_BAREKEY => 14; +use constant P_ALLOW_SINGLEQUOTE => 15; +use constant P_ESCAPE_SLASH => 16; +use constant P_AS_NONBLESSED => 17; + +use constant P_ALLOW_UNKNOWN => 18; + +use constant OLD_PERL => $] < 5.008 ? 1 : 0; + +BEGIN { + my @xs_compati_bit_properties = qw( + latin1 ascii utf8 indent canonical space_before space_after allow_nonref shrink + allow_blessed convert_blessed relaxed allow_unknown + ); + my @pp_bit_properties = qw( + allow_singlequote allow_bignum loose + allow_barekey escape_slash as_nonblessed + ); + + # Perl version check, Unicode handling is enable? + # Helper module sets @JSON::PP::_properties. + if ($] < 5.008 ) { + my $helper = $] >= 5.006 ? 'JSON::backportPP::Compat5006' : 'JSON::backportPP::Compat5005'; + eval qq| require $helper |; + if ($@) { Carp::croak $@; } + } + + for my $name (@xs_compati_bit_properties, @pp_bit_properties) { + my $flag_name = 'P_' . uc($name); + + eval qq/ + sub $name { + my \$enable = defined \$_[1] ? \$_[1] : 1; + + if (\$enable) { + \$_[0]->{PROPS}->[$flag_name] = 1; + } + else { + \$_[0]->{PROPS}->[$flag_name] = 0; + } + + \$_[0]; + } + + sub get_$name { + \$_[0]->{PROPS}->[$flag_name] ? 1 : ''; + } + /; + } + +} + + + +# Functions + +my %encode_allow_method + = map {($_ => 1)} qw/utf8 pretty allow_nonref latin1 self_encode escape_slash + allow_blessed convert_blessed indent indent_length allow_bignum + as_nonblessed + /; +my %decode_allow_method + = map {($_ => 1)} qw/utf8 allow_nonref loose allow_singlequote allow_bignum + allow_barekey max_size relaxed/; + + +my $JSON; # cache + +sub encode_json ($) { # encode + ($JSON ||= __PACKAGE__->new->utf8)->encode(@_); +} + + +sub decode_json { # decode + ($JSON ||= __PACKAGE__->new->utf8)->decode(@_); +} + +# Obsoleted + +sub to_json($) { + Carp::croak ("JSON::PP::to_json has been renamed to encode_json."); +} + + +sub from_json($) { + Carp::croak ("JSON::PP::from_json has been renamed to decode_json."); +} + + +# Methods + +sub new { + my $class = shift; + my $self = { + max_depth => 512, + max_size => 0, + indent => 0, + FLAGS => 0, + fallback => sub { encode_error('Invalid value. JSON can only reference.') }, + indent_length => 3, + }; + + bless $self, $class; +} + + +sub encode { + return $_[0]->PP_encode_json($_[1]); +} + + +sub decode { + return $_[0]->PP_decode_json($_[1], 0x00000000); +} + + +sub decode_prefix { + return $_[0]->PP_decode_json($_[1], 0x00000001); +} + + +# accessor + + +# pretty printing + +sub pretty { + my ($self, $v) = @_; + my $enable = defined $v ? $v : 1; + + if ($enable) { # indent_length(3) for JSON::XS compatibility + $self->indent(1)->indent_length(3)->space_before(1)->space_after(1); + } + else { + $self->indent(0)->space_before(0)->space_after(0); + } + + $self; +} + +# etc + +sub max_depth { + my $max = defined $_[1] ? $_[1] : 0x80000000; + $_[0]->{max_depth} = $max; + $_[0]; +} + + +sub get_max_depth { $_[0]->{max_depth}; } + + +sub max_size { + my $max = defined $_[1] ? $_[1] : 0; + $_[0]->{max_size} = $max; + $_[0]; +} + + +sub get_max_size { $_[0]->{max_size}; } + + +sub filter_json_object { + $_[0]->{cb_object} = defined $_[1] ? $_[1] : 0; + $_[0]->{F_HOOK} = ($_[0]->{cb_object} or $_[0]->{cb_sk_object}) ? 1 : 0; + $_[0]; +} + +sub filter_json_single_key_object { + if (@_ > 1) { + $_[0]->{cb_sk_object}->{$_[1]} = $_[2]; + } + $_[0]->{F_HOOK} = ($_[0]->{cb_object} or $_[0]->{cb_sk_object}) ? 1 : 0; + $_[0]; +} + +sub indent_length { + if (!defined $_[1] or $_[1] > 15 or $_[1] < 0) { + Carp::carp "The acceptable range of indent_length() is 0 to 15."; + } + else { + $_[0]->{indent_length} = $_[1]; + } + $_[0]; +} + +sub get_indent_length { + $_[0]->{indent_length}; +} + +sub sort_by { + $_[0]->{sort_by} = defined $_[1] ? $_[1] : 1; + $_[0]; +} + +sub allow_bigint { + Carp::carp("allow_bigint() is obsoleted. use allow_bignum() insted."); +} + +############################### + +### +### Perl => JSON +### + + +{ # Convert + + my $max_depth; + my $indent; + my $ascii; + my $latin1; + my $utf8; + my $space_before; + my $space_after; + my $canonical; + my $allow_blessed; + my $convert_blessed; + + my $indent_length; + my $escape_slash; + my $bignum; + my $as_nonblessed; + + my $depth; + my $indent_count; + my $keysort; + + + sub PP_encode_json { + my $self = shift; + my $obj = shift; + + $indent_count = 0; + $depth = 0; + + my $idx = $self->{PROPS}; + + ($ascii, $latin1, $utf8, $indent, $canonical, $space_before, $space_after, $allow_blessed, + $convert_blessed, $escape_slash, $bignum, $as_nonblessed) + = @{$idx}[P_ASCII .. P_SPACE_AFTER, P_ALLOW_BLESSED, P_CONVERT_BLESSED, + P_ESCAPE_SLASH, P_ALLOW_BIGNUM, P_AS_NONBLESSED]; + + ($max_depth, $indent_length) = @{$self}{qw/max_depth indent_length/}; + + $keysort = $canonical ? sub { $a cmp $b } : undef; + + if ($self->{sort_by}) { + $keysort = ref($self->{sort_by}) eq 'CODE' ? $self->{sort_by} + : $self->{sort_by} =~ /\D+/ ? $self->{sort_by} + : sub { $a cmp $b }; + } + + encode_error("hash- or arrayref expected (not a simple scalar, use allow_nonref to allow this)") + if(!ref $obj and !$idx->[ P_ALLOW_NONREF ]); + + my $str = $self->object_to_json($obj); + + $str .= "\n" if ( $indent ); # JSON::XS 2.26 compatible + + unless ($ascii or $latin1 or $utf8) { + utf8::upgrade($str); + } + + if ($idx->[ P_SHRINK ]) { + utf8::downgrade($str, 1); + } + + return $str; + } + + + sub object_to_json { + my ($self, $obj) = @_; + my $type = ref($obj); + + if($type eq 'HASH'){ + return $self->hash_to_json($obj); + } + elsif($type eq 'ARRAY'){ + return $self->array_to_json($obj); + } + elsif ($type) { # blessed object? + if (blessed($obj)) { + + return $self->value_to_json($obj) if ( $obj->isa('JSON::PP::Boolean') ); + + if ( $convert_blessed and $obj->can('TO_JSON') ) { + my $result = $obj->TO_JSON(); + if ( defined $result and ref( $result ) ) { + if ( refaddr( $obj ) eq refaddr( $result ) ) { + encode_error( sprintf( + "%s::TO_JSON method returned same object as was passed instead of a new one", + ref $obj + ) ); + } + } + + return $self->object_to_json( $result ); + } + + return "$obj" if ( $bignum and _is_bignum($obj) ); + return $self->blessed_to_json($obj) if ($allow_blessed and $as_nonblessed); # will be removed. + + encode_error( sprintf("encountered object '%s', but neither allow_blessed " + . "nor convert_blessed settings are enabled", $obj) + ) unless ($allow_blessed); + + return 'null'; + } + else { + return $self->value_to_json($obj); + } + } + else{ + return $self->value_to_json($obj); + } + } + + + sub hash_to_json { + my ($self, $obj) = @_; + my @res; + + encode_error("json text or perl structure exceeds maximum nesting level (max_depth set too low?)") + if (++$depth > $max_depth); + + my ($pre, $post) = $indent ? $self->_up_indent() : ('', ''); + my $del = ($space_before ? ' ' : '') . ':' . ($space_after ? ' ' : ''); + + for my $k ( _sort( $obj ) ) { + if ( OLD_PERL ) { utf8::decode($k) } # key for Perl 5.6 / be optimized + push @res, string_to_json( $self, $k ) + . $del + . ( $self->object_to_json( $obj->{$k} ) || $self->value_to_json( $obj->{$k} ) ); + } + + --$depth; + $self->_down_indent() if ($indent); + + return '{' . ( @res ? $pre : '' ) . ( @res ? join( ",$pre", @res ) . $post : '' ) . '}'; + } + + + sub array_to_json { + my ($self, $obj) = @_; + my @res; + + encode_error("json text or perl structure exceeds maximum nesting level (max_depth set too low?)") + if (++$depth > $max_depth); + + my ($pre, $post) = $indent ? $self->_up_indent() : ('', ''); + + for my $v (@$obj){ + push @res, $self->object_to_json($v) || $self->value_to_json($v); + } + + --$depth; + $self->_down_indent() if ($indent); + + return '[' . ( @res ? $pre : '' ) . ( @res ? join( ",$pre", @res ) . $post : '' ) . ']'; + } + + + sub value_to_json { + my ($self, $value) = @_; + + return 'null' if(!defined $value); + + my $b_obj = B::svref_2object(\$value); # for round trip problem + my $flags = $b_obj->FLAGS; + + return $value # as is + if $flags & ( B::SVp_IOK | B::SVp_NOK ) and !( $flags & B::SVp_POK ); # SvTYPE is IV or NV? + + my $type = ref($value); + + if(!$type){ + return string_to_json($self, $value); + } + elsif( blessed($value) and $value->isa('JSON::PP::Boolean') ){ + return $$value == 1 ? 'true' : 'false'; + } + elsif ($type) { + if ((overload::StrVal($value) =~ /=(\w+)/)[0]) { + return $self->value_to_json("$value"); + } + + if ($type eq 'SCALAR' and defined $$value) { + return $$value eq '1' ? 'true' + : $$value eq '0' ? 'false' + : $self->{PROPS}->[ P_ALLOW_UNKNOWN ] ? 'null' + : encode_error("cannot encode reference to scalar"); + } + + if ( $self->{PROPS}->[ P_ALLOW_UNKNOWN ] ) { + return 'null'; + } + else { + if ( $type eq 'SCALAR' or $type eq 'REF' ) { + encode_error("cannot encode reference to scalar"); + } + else { + encode_error("encountered $value, but JSON can only represent references to arrays or hashes"); + } + } + + } + else { + return $self->{fallback}->($value) + if ($self->{fallback} and ref($self->{fallback}) eq 'CODE'); + return 'null'; + } + + } + + + my %esc = ( + "\n" => '\n', + "\r" => '\r', + "\t" => '\t', + "\f" => '\f', + "\b" => '\b', + "\"" => '\"', + "\\" => '\\\\', + "\'" => '\\\'', + ); + + + sub string_to_json { + my ($self, $arg) = @_; + + $arg =~ s/([\x22\x5c\n\r\t\f\b])/$esc{$1}/g; + $arg =~ s/\//\\\//g if ($escape_slash); + $arg =~ s/([\x00-\x08\x0b\x0e-\x1f])/'\\u00' . unpack('H2', $1)/eg; + + if ($ascii) { + $arg = JSON_PP_encode_ascii($arg); + } + + if ($latin1) { + $arg = JSON_PP_encode_latin1($arg); + } + + if ($utf8) { + utf8::encode($arg); + } + + return '"' . $arg . '"'; + } + + + sub blessed_to_json { + my $reftype = reftype($_[1]) || ''; + if ($reftype eq 'HASH') { + return $_[0]->hash_to_json($_[1]); + } + elsif ($reftype eq 'ARRAY') { + return $_[0]->array_to_json($_[1]); + } + else { + return 'null'; + } + } + + + sub encode_error { + my $error = shift; + Carp::croak "$error"; + } + + + sub _sort { + defined $keysort ? (sort $keysort (keys %{$_[0]})) : keys %{$_[0]}; + } + + + sub _up_indent { + my $self = shift; + my $space = ' ' x $indent_length; + + my ($pre,$post) = ('',''); + + $post = "\n" . $space x $indent_count; + + $indent_count++; + + $pre = "\n" . $space x $indent_count; + + return ($pre,$post); + } + + + sub _down_indent { $indent_count--; } + + + sub PP_encode_box { + { + depth => $depth, + indent_count => $indent_count, + }; + } + +} # Convert + + +sub _encode_ascii { + join('', + map { + $_ <= 127 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', _encode_surrogates($_)); + } unpack('U*', $_[0]) + ); +} + + +sub _encode_latin1 { + join('', + map { + $_ <= 255 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', _encode_surrogates($_)); + } unpack('U*', $_[0]) + ); +} + + +sub _encode_surrogates { # from perlunicode + my $uni = $_[0] - 0x10000; + return ($uni / 0x400 + 0xD800, $uni % 0x400 + 0xDC00); +} + + +sub _is_bignum { + $_[0]->isa('Math::BigInt') or $_[0]->isa('Math::BigFloat'); +} + + + +# +# JSON => Perl +# + +my $max_intsize; + +BEGIN { + my $checkint = 1111; + for my $d (5..64) { + $checkint .= 1; + my $int = eval qq| $checkint |; + if ($int =~ /[eE]/) { + $max_intsize = $d - 1; + last; + } + } +} + +{ # PARSE + + my %escapes = ( # by Jeremy Muhlich <jmuhlich [at] bitflood.org> + b => "\x8", + t => "\x9", + n => "\xA", + f => "\xC", + r => "\xD", + '\\' => '\\', + '"' => '"', + '/' => '/', + ); + + my $text; # json data + my $at; # offset + my $ch; # 1chracter + my $len; # text length (changed according to UTF8 or NON UTF8) + # INTERNAL + my $depth; # nest counter + my $encoding; # json text encoding + my $is_valid_utf8; # temp variable + my $utf8_len; # utf8 byte length + # FLAGS + my $utf8; # must be utf8 + my $max_depth; # max nest number of objects and arrays + my $max_size; + my $relaxed; + my $cb_object; + my $cb_sk_object; + + my $F_HOOK; + + my $allow_bigint; # using Math::BigInt + my $singlequote; # loosely quoting + my $loose; # + my $allow_barekey; # bareKey + + # $opt flag + # 0x00000001 .... decode_prefix + # 0x10000000 .... incr_parse + + sub PP_decode_json { + my ($self, $opt); # $opt is an effective flag during this decode_json. + + ($self, $text, $opt) = @_; + + ($at, $ch, $depth) = (0, '', 0); + + if ( !defined $text or ref $text ) { + decode_error("malformed JSON string, neither array, object, number, string or atom"); + } + + my $idx = $self->{PROPS}; + + ($utf8, $relaxed, $loose, $allow_bigint, $allow_barekey, $singlequote) + = @{$idx}[P_UTF8, P_RELAXED, P_LOOSE .. P_ALLOW_SINGLEQUOTE]; + + if ( $utf8 ) { + utf8::downgrade( $text, 1 ) or Carp::croak("Wide character in subroutine entry"); + } + else { + utf8::upgrade( $text ); + } + + $len = length $text; + + ($max_depth, $max_size, $cb_object, $cb_sk_object, $F_HOOK) + = @{$self}{qw/max_depth max_size cb_object cb_sk_object F_HOOK/}; + + if ($max_size > 1) { + use bytes; + my $bytes = length $text; + decode_error( + sprintf("attempted decode of JSON text of %s bytes size, but max_size is set to %s" + , $bytes, $max_size), 1 + ) if ($bytes > $max_size); + } + + # Currently no effect + # should use regexp + my @octets = unpack('C4', $text); + $encoding = ( $octets[0] and $octets[1]) ? 'UTF-8' + : (!$octets[0] and $octets[1]) ? 'UTF-16BE' + : (!$octets[0] and !$octets[1]) ? 'UTF-32BE' + : ( $octets[2] ) ? 'UTF-16LE' + : (!$octets[2] ) ? 'UTF-32LE' + : 'unknown'; + + white(); # remove head white space + + my $valid_start = defined $ch; # Is there a first character for JSON structure? + + my $result = value(); + + return undef if ( !$result && ( $opt & 0x10000000 ) ); # for incr_parse + + decode_error("malformed JSON string, neither array, object, number, string or atom") unless $valid_start; + + if ( !$idx->[ P_ALLOW_NONREF ] and !ref $result ) { + decode_error( + 'JSON text must be an object or array (but found number, string, true, false or null,' + . ' use allow_nonref to allow this)', 1); + } + + Carp::croak('something wrong.') if $len < $at; # we won't arrive here. + + my $consumed = defined $ch ? $at - 1 : $at; # consumed JSON text length + + white(); # remove tail white space + + if ( $ch ) { + return ( $result, $consumed ) if ($opt & 0x00000001); # all right if decode_prefix + decode_error("garbage after JSON object"); + } + + ( $opt & 0x00000001 ) ? ( $result, $consumed ) : $result; + } + + + sub next_chr { + return $ch = undef if($at >= $len); + $ch = substr($text, $at++, 1); + } + + + sub value { + white(); + return if(!defined $ch); + return object() if($ch eq '{'); + return array() if($ch eq '['); + return string() if($ch eq '"' or ($singlequote and $ch eq "'")); + return number() if($ch =~ /[0-9]/ or $ch eq '-'); + return word(); + } + + sub string { + my ($i, $s, $t, $u); + my $utf16; + my $is_utf8; + + ($is_valid_utf8, $utf8_len) = ('', 0); + + $s = ''; # basically UTF8 flag on + + if($ch eq '"' or ($singlequote and $ch eq "'")){ + my $boundChar = $ch; + + OUTER: while( defined(next_chr()) ){ + + if($ch eq $boundChar){ + next_chr(); + + if ($utf16) { + decode_error("missing low surrogate character in surrogate pair"); + } + + utf8::decode($s) if($is_utf8); + + return $s; + } + elsif($ch eq '\\'){ + next_chr(); + if(exists $escapes{$ch}){ + $s .= $escapes{$ch}; + } + elsif($ch eq 'u'){ # UNICODE handling + my $u = ''; + + for(1..4){ + $ch = next_chr(); + last OUTER if($ch !~ /[0-9a-fA-F]/); + $u .= $ch; + } + + # U+D800 - U+DBFF + if ($u =~ /^[dD][89abAB][0-9a-fA-F]{2}/) { # UTF-16 high surrogate? + $utf16 = $u; + } + # U+DC00 - U+DFFF + elsif ($u =~ /^[dD][c-fC-F][0-9a-fA-F]{2}/) { # UTF-16 low surrogate? + unless (defined $utf16) { + decode_error("missing high surrogate character in surrogate pair"); + } + $is_utf8 = 1; + $s .= JSON_PP_decode_surrogates($utf16, $u) || next; + $utf16 = undef; + } + else { + if (defined $utf16) { + decode_error("surrogate pair expected"); + } + + if ( ( my $hex = hex( $u ) ) > 127 ) { + $is_utf8 = 1; + $s .= JSON_PP_decode_unicode($u) || next; + } + else { + $s .= chr $hex; + } + } + + } + else{ + unless ($loose) { + $at -= 2; + decode_error('illegal backslash escape sequence in string'); + } + $s .= $ch; + } + } + else{ + + if ( ord $ch > 127 ) { + if ( $utf8 ) { + unless( $ch = is_valid_utf8($ch) ) { + $at -= 1; + decode_error("malformed UTF-8 character in JSON string"); + } + else { + $at += $utf8_len - 1; + } + } + else { + utf8::encode( $ch ); + } + + $is_utf8 = 1; + } + + if (!$loose) { + if ($ch =~ /[\x00-\x1f\x22\x5c]/) { # '/' ok + $at--; + decode_error('invalid character encountered while parsing JSON string'); + } + } + + $s .= $ch; + } + } + } + + decode_error("unexpected end of string while parsing JSON string"); + } + + + sub white { + while( defined $ch ){ + if($ch le ' '){ + next_chr(); + } + elsif($ch eq '/'){ + next_chr(); + if(defined $ch and $ch eq '/'){ + 1 while(defined(next_chr()) and $ch ne "\n" and $ch ne "\r"); + } + elsif(defined $ch and $ch eq '*'){ + next_chr(); + while(1){ + if(defined $ch){ + if($ch eq '*'){ + if(defined(next_chr()) and $ch eq '/'){ + next_chr(); + last; + } + } + else{ + next_chr(); + } + } + else{ + decode_error("Unterminated comment"); + } + } + next; + } + else{ + $at--; + decode_error("malformed JSON string, neither array, object, number, string or atom"); + } + } + else{ + if ($relaxed and $ch eq '#') { # correctly? + pos($text) = $at; + $text =~ /\G([^\n]*(?:\r\n|\r|\n|$))/g; + $at = pos($text); + next_chr; + next; + } + + last; + } + } + } + + + sub array { + my $a = $_[0] || []; # you can use this code to use another array ref object. + + decode_error('json text or perl structure exceeds maximum nesting level (max_depth set too low?)') + if (++$depth > $max_depth); + + next_chr(); + white(); + + if(defined $ch and $ch eq ']'){ + --$depth; + next_chr(); + return $a; + } + else { + while(defined($ch)){ + push @$a, value(); + + white(); + + if (!defined $ch) { + last; + } + + if($ch eq ']'){ + --$depth; + next_chr(); + return $a; + } + + if($ch ne ','){ + last; + } + + next_chr(); + white(); + + if ($relaxed and $ch eq ']') { + --$depth; + next_chr(); + return $a; + } + + } + } + + decode_error(", or ] expected while parsing array"); + } + + + sub object { + my $o = $_[0] || {}; # you can use this code to use another hash ref object. + my $k; + + decode_error('json text or perl structure exceeds maximum nesting level (max_depth set too low?)') + if (++$depth > $max_depth); + next_chr(); + white(); + + if(defined $ch and $ch eq '}'){ + --$depth; + next_chr(); + if ($F_HOOK) { + return _json_object_hook($o); + } + return $o; + } + else { + while (defined $ch) { + $k = ($allow_barekey and $ch ne '"' and $ch ne "'") ? bareKey() : string(); + white(); + + if(!defined $ch or $ch ne ':'){ + $at--; + decode_error("':' expected"); + } + + next_chr(); + $o->{$k} = value(); + white(); + + last if (!defined $ch); + + if($ch eq '}'){ + --$depth; + next_chr(); + if ($F_HOOK) { + return _json_object_hook($o); + } + return $o; + } + + if($ch ne ','){ + last; + } + + next_chr(); + white(); + + if ($relaxed and $ch eq '}') { + --$depth; + next_chr(); + if ($F_HOOK) { + return _json_object_hook($o); + } + return $o; + } + + } + + } + + $at--; + decode_error(", or } expected while parsing object/hash"); + } + + + sub bareKey { # doesn't strictly follow Standard ECMA-262 3rd Edition + my $key; + while($ch =~ /[^\x00-\x23\x25-\x2F\x3A-\x40\x5B-\x5E\x60\x7B-\x7F]/){ + $key .= $ch; + next_chr(); + } + return $key; + } + + + sub word { + my $word = substr($text,$at-1,4); + + if($word eq 'true'){ + $at += 3; + next_chr; + return $JSON::PP::true; + } + elsif($word eq 'null'){ + $at += 3; + next_chr; + return undef; + } + elsif($word eq 'fals'){ + $at += 3; + if(substr($text,$at,1) eq 'e'){ + $at++; + next_chr; + return $JSON::PP::false; + } + } + + $at--; # for decode_error report + + decode_error("'null' expected") if ($word =~ /^n/); + decode_error("'true' expected") if ($word =~ /^t/); + decode_error("'false' expected") if ($word =~ /^f/); + decode_error("malformed JSON string, neither array, object, number, string or atom"); + } + + + sub number { + my $n = ''; + my $v; + + # According to RFC4627, hex or oct digits are invalid. + if($ch eq '0'){ + my $peek = substr($text,$at,1); + my $hex = $peek =~ /[xX]/; # 0 or 1 + + if($hex){ + decode_error("malformed number (leading zero must not be followed by another digit)"); + ($n) = ( substr($text, $at+1) =~ /^([0-9a-fA-F]+)/); + } + else{ # oct + ($n) = ( substr($text, $at) =~ /^([0-7]+)/); + if (defined $n and length $n > 1) { + decode_error("malformed number (leading zero must not be followed by another digit)"); + } + } + + if(defined $n and length($n)){ + if (!$hex and length($n) == 1) { + decode_error("malformed number (leading zero must not be followed by another digit)"); + } + $at += length($n) + $hex; + next_chr; + return $hex ? hex($n) : oct($n); + } + } + + if($ch eq '-'){ + $n = '-'; + next_chr; + if (!defined $ch or $ch !~ /\d/) { + decode_error("malformed number (no digits after initial minus)"); + } + } + + while(defined $ch and $ch =~ /\d/){ + $n .= $ch; + next_chr; + } + + if(defined $ch and $ch eq '.'){ + $n .= '.'; + + next_chr; + if (!defined $ch or $ch !~ /\d/) { + decode_error("malformed number (no digits after decimal point)"); + } + else { + $n .= $ch; + } + + while(defined(next_chr) and $ch =~ /\d/){ + $n .= $ch; + } + } + + if(defined $ch and ($ch eq 'e' or $ch eq 'E')){ + $n .= $ch; + next_chr; + + if(defined($ch) and ($ch eq '+' or $ch eq '-')){ + $n .= $ch; + next_chr; + if (!defined $ch or $ch =~ /\D/) { + decode_error("malformed number (no digits after exp sign)"); + } + $n .= $ch; + } + elsif(defined($ch) and $ch =~ /\d/){ + $n .= $ch; + } + else { + decode_error("malformed number (no digits after exp sign)"); + } + + while(defined(next_chr) and $ch =~ /\d/){ + $n .= $ch; + } + + } + + $v .= $n; + + if ($v !~ /[.eE]/ and length $v > $max_intsize) { + if ($allow_bigint) { # from Adam Sussman + require Math::BigInt; + return Math::BigInt->new($v); + } + else { + return "$v"; + } + } + elsif ($allow_bigint) { + require Math::BigFloat; + return Math::BigFloat->new($v); + } + + return 0+$v; + } + + + sub is_valid_utf8 { + + $utf8_len = $_[0] =~ /[\x00-\x7F]/ ? 1 + : $_[0] =~ /[\xC2-\xDF]/ ? 2 + : $_[0] =~ /[\xE0-\xEF]/ ? 3 + : $_[0] =~ /[\xF0-\xF4]/ ? 4 + : 0 + ; + + return unless $utf8_len; + + my $is_valid_utf8 = substr($text, $at - 1, $utf8_len); + + return ( $is_valid_utf8 =~ /^(?: + [\x00-\x7F] + |[\xC2-\xDF][\x80-\xBF] + |[\xE0][\xA0-\xBF][\x80-\xBF] + |[\xE1-\xEC][\x80-\xBF][\x80-\xBF] + |[\xED][\x80-\x9F][\x80-\xBF] + |[\xEE-\xEF][\x80-\xBF][\x80-\xBF] + |[\xF0][\x90-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF4][\x80-\x8F][\x80-\xBF][\x80-\xBF] + )$/x ) ? $is_valid_utf8 : ''; + } + + + sub decode_error { + my $error = shift; + my $no_rep = shift; + my $str = defined $text ? substr($text, $at) : ''; + my $mess = ''; + my $type = $] >= 5.008 ? 'U*' + : $] < 5.006 ? 'C*' + : utf8::is_utf8( $str ) ? 'U*' # 5.6 + : 'C*' + ; + + for my $c ( unpack( $type, $str ) ) { # emulate pv_uni_display() ? + $mess .= $c == 0x07 ? '\a' + : $c == 0x09 ? '\t' + : $c == 0x0a ? '\n' + : $c == 0x0d ? '\r' + : $c == 0x0c ? '\f' + : $c < 0x20 ? sprintf('\x{%x}', $c) + : $c == 0x5c ? '\\\\' + : $c < 0x80 ? chr($c) + : sprintf('\x{%x}', $c) + ; + if ( length $mess >= 20 ) { + $mess .= '...'; + last; + } + } + + unless ( length $mess ) { + $mess = '(end of string)'; + } + + Carp::croak ( + $no_rep ? "$error" : "$error, at character offset $at (before \"$mess\")" + ); + + } + + + sub _json_object_hook { + my $o = $_[0]; + my @ks = keys %{$o}; + + if ( $cb_sk_object and @ks == 1 and exists $cb_sk_object->{ $ks[0] } and ref $cb_sk_object->{ $ks[0] } ) { + my @val = $cb_sk_object->{ $ks[0] }->( $o->{$ks[0]} ); + if (@val == 1) { + return $val[0]; + } + } + + my @val = $cb_object->($o) if ($cb_object); + if (@val == 0 or @val > 1) { + return $o; + } + else { + return $val[0]; + } + } + + + sub PP_decode_box { + { + text => $text, + at => $at, + ch => $ch, + len => $len, + depth => $depth, + encoding => $encoding, + is_valid_utf8 => $is_valid_utf8, + }; + } + +} # PARSE + + +sub _decode_surrogates { # from perlunicode + my $uni = 0x10000 + (hex($_[0]) - 0xD800) * 0x400 + (hex($_[1]) - 0xDC00); + my $un = pack('U*', $uni); + utf8::encode( $un ); + return $un; +} + + +sub _decode_unicode { + my $un = pack('U', hex shift); + utf8::encode( $un ); + return $un; +} + +# +# Setup for various Perl versions (the code from JSON::PP58) +# + +BEGIN { + + unless ( defined &utf8::is_utf8 ) { + require Encode; + *utf8::is_utf8 = *Encode::is_utf8; + } + + if ( $] >= 5.008 ) { + *JSON::PP::JSON_PP_encode_ascii = \&_encode_ascii; + *JSON::PP::JSON_PP_encode_latin1 = \&_encode_latin1; + *JSON::PP::JSON_PP_decode_surrogates = \&_decode_surrogates; + *JSON::PP::JSON_PP_decode_unicode = \&_decode_unicode; + } + + if ($] >= 5.008 and $] < 5.008003) { # join() in 5.8.0 - 5.8.2 is broken. + package # hide from PAUSE + JSON::PP; + require subs; + subs->import('join'); + eval q| + sub join { + return '' if (@_ < 2); + my $j = shift; + my $str = shift; + for (@_) { $str .= $j . $_; } + return $str; + } + |; + } + + + sub JSON::PP::incr_parse { + local $Carp::CarpLevel = 1; + ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_parse( @_ ); + } + + + sub JSON::PP::incr_skip { + ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_skip; + } + + + sub JSON::PP::incr_reset { + ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_reset; + } + + eval q{ + sub JSON::PP::incr_text : lvalue { + $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new; + + if ( $_[0]->{_incr_parser}->{incr_parsing} ) { + Carp::croak("incr_text can not be called when the incremental parser already started parsing"); + } + $_[0]->{_incr_parser}->{incr_text}; + } + } if ( $] >= 5.006 ); + +} # Setup for various Perl versions (the code from JSON::PP58) + + +############################### +# Utilities +# + +BEGIN { + eval 'require Scalar::Util'; + unless($@){ + *JSON::PP::blessed = \&Scalar::Util::blessed; + *JSON::PP::reftype = \&Scalar::Util::reftype; + *JSON::PP::refaddr = \&Scalar::Util::refaddr; + } + else{ # This code is from Scalar::Util. + # warn $@; + eval 'sub UNIVERSAL::a_sub_not_likely_to_be_here { ref($_[0]) }'; + *JSON::PP::blessed = sub { + local($@, $SIG{__DIE__}, $SIG{__WARN__}); + ref($_[0]) ? eval { $_[0]->a_sub_not_likely_to_be_here } : undef; + }; + my %tmap = qw( + B::NULL SCALAR + B::HV HASH + B::AV ARRAY + B::CV CODE + B::IO IO + B::GV GLOB + B::REGEXP REGEXP + ); + *JSON::PP::reftype = sub { + my $r = shift; + + return undef unless length(ref($r)); + + my $t = ref(B::svref_2object($r)); + + return + exists $tmap{$t} ? $tmap{$t} + : length(ref($$r)) ? 'REF' + : 'SCALAR'; + }; + *JSON::PP::refaddr = sub { + return undef unless length(ref($_[0])); + + my $addr; + if(defined(my $pkg = blessed($_[0]))) { + $addr .= bless $_[0], 'Scalar::Util::Fake'; + bless $_[0], $pkg; + } + else { + $addr .= $_[0] + } + + $addr =~ /0x(\w+)/; + local $^W; + #no warnings 'portable'; + hex($1); + } + } +} + + +# shamelessly copied and modified from JSON::XS code. + +$JSON::PP::true = do { bless \(my $dummy = 1), "JSON::backportPP::Boolean" }; +$JSON::PP::false = do { bless \(my $dummy = 0), "JSON::backportPP::Boolean" }; + +sub is_bool { defined $_[0] and UNIVERSAL::isa($_[0], "JSON::PP::Boolean"); } + +sub true { $JSON::PP::true } +sub false { $JSON::PP::false } +sub null { undef; } + +############################### + +package JSON::backportPP::Boolean; + +@JSON::backportPP::Boolean::ISA = ('JSON::PP::Boolean'); +use overload ( + "0+" => sub { ${$_[0]} }, + "++" => sub { $_[0] = ${$_[0]} + 1 }, + "--" => sub { $_[0] = ${$_[0]} - 1 }, + fallback => 1, +); + + +############################### + +package # hide from PAUSE + JSON::PP::IncrParser; + +use strict; + +use constant INCR_M_WS => 0; # initial whitespace skipping +use constant INCR_M_STR => 1; # inside string +use constant INCR_M_BS => 2; # inside backslash +use constant INCR_M_JSON => 3; # outside anything, count nesting +use constant INCR_M_C0 => 4; +use constant INCR_M_C1 => 5; + +use vars qw($VERSION); +$VERSION = '1.01'; + +my $unpack_format = $] < 5.006 ? 'C*' : 'U*'; + +sub new { + my ( $class ) = @_; + + bless { + incr_nest => 0, + incr_text => undef, + incr_parsing => 0, + incr_p => 0, + }, $class; +} + + +sub incr_parse { + my ( $self, $coder, $text ) = @_; + + $self->{incr_text} = '' unless ( defined $self->{incr_text} ); + + if ( defined $text ) { + if ( utf8::is_utf8( $text ) and !utf8::is_utf8( $self->{incr_text} ) ) { + utf8::upgrade( $self->{incr_text} ) ; + utf8::decode( $self->{incr_text} ) ; + } + $self->{incr_text} .= $text; + } + + + my $max_size = $coder->get_max_size; + + if ( defined wantarray ) { + + $self->{incr_mode} = INCR_M_WS unless defined $self->{incr_mode}; + + if ( wantarray ) { + my @ret; + + $self->{incr_parsing} = 1; + + do { + push @ret, $self->_incr_parse( $coder, $self->{incr_text} ); + + unless ( !$self->{incr_nest} and $self->{incr_mode} == INCR_M_JSON ) { + $self->{incr_mode} = INCR_M_WS if $self->{incr_mode} != INCR_M_STR; + } + + } until ( length $self->{incr_text} >= $self->{incr_p} ); + + $self->{incr_parsing} = 0; + + return @ret; + } + else { # in scalar context + $self->{incr_parsing} = 1; + my $obj = $self->_incr_parse( $coder, $self->{incr_text} ); + $self->{incr_parsing} = 0 if defined $obj; # pointed by Martin J. Evans + return $obj ? $obj : undef; # $obj is an empty string, parsing was completed. + } + + } + +} + + +sub _incr_parse { + my ( $self, $coder, $text, $skip ) = @_; + my $p = $self->{incr_p}; + my $restore = $p; + + my @obj; + my $len = length $text; + + if ( $self->{incr_mode} == INCR_M_WS ) { + while ( $len > $p ) { + my $s = substr( $text, $p, 1 ); + $p++ and next if ( 0x20 >= unpack($unpack_format, $s) ); + $self->{incr_mode} = INCR_M_JSON; + last; + } + } + + while ( $len > $p ) { + my $s = substr( $text, $p++, 1 ); + + if ( $s eq '"' ) { + if (substr( $text, $p - 2, 1 ) eq '\\' ) { + next; + } + + if ( $self->{incr_mode} != INCR_M_STR ) { + $self->{incr_mode} = INCR_M_STR; + } + else { + $self->{incr_mode} = INCR_M_JSON; + unless ( $self->{incr_nest} ) { + last; + } + } + } + + if ( $self->{incr_mode} == INCR_M_JSON ) { + + if ( $s eq '[' or $s eq '{' ) { + if ( ++$self->{incr_nest} > $coder->get_max_depth ) { + Carp::croak('json text or perl structure exceeds maximum nesting level (max_depth set too low?)'); + } + } + elsif ( $s eq ']' or $s eq '}' ) { + last if ( --$self->{incr_nest} <= 0 ); + } + elsif ( $s eq '#' ) { + while ( $len > $p ) { + last if substr( $text, $p++, 1 ) eq "\n"; + } + } + + } + + } + + $self->{incr_p} = $p; + + return if ( $self->{incr_mode} == INCR_M_STR and not $self->{incr_nest} ); + return if ( $self->{incr_mode} == INCR_M_JSON and $self->{incr_nest} > 0 ); + + return '' unless ( length substr( $self->{incr_text}, 0, $p ) ); + + local $Carp::CarpLevel = 2; + + $self->{incr_p} = $restore; + $self->{incr_c} = $p; + + my ( $obj, $tail ) = $coder->PP_decode_json( substr( $self->{incr_text}, 0, $p ), 0x10000001 ); + + $self->{incr_text} = substr( $self->{incr_text}, $p ); + $self->{incr_p} = 0; + + return $obj or ''; +} + + +sub incr_text { + if ( $_[0]->{incr_parsing} ) { + Carp::croak("incr_text can not be called when the incremental parser already started parsing"); + } + $_[0]->{incr_text}; +} + + +sub incr_skip { + my $self = shift; + $self->{incr_text} = substr( $self->{incr_text}, $self->{incr_c} ); + $self->{incr_p} = 0; +} + + +sub incr_reset { + my $self = shift; + $self->{incr_text} = undef; + $self->{incr_p} = 0; + $self->{incr_mode} = 0; + $self->{incr_nest} = 0; + $self->{incr_parsing} = 0; +} + +############################### + + +1; +__END__ +=pod + +=head1 NAME + +JSON::PP - JSON::XS compatible pure-Perl module. + +=head1 SYNOPSIS + + use JSON::PP; + + # exported functions, they croak on error + # and expect/generate UTF-8 + + $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; + $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; + + # OO-interface + + $coder = JSON::PP->new->ascii->pretty->allow_nonref; + + $json_text = $json->encode( $perl_scalar ); + $perl_scalar = $json->decode( $json_text ); + + $pretty_printed = $json->pretty->encode( $perl_scalar ); # pretty-printing + + # Note that JSON version 2.0 and above will automatically use + # JSON::XS or JSON::PP, so you should be able to just: + + use JSON; + + +=head1 VERSION + + 2.27200 + +L<JSON::XS> 2.27 (~2.30) compatible. + +=head1 DESCRIPTION + +This module is L<JSON::XS> compatible pure Perl module. +(Perl 5.8 or later is recommended) + +JSON::XS is the fastest and most proper JSON module on CPAN. +It is written by Marc Lehmann in C, so must be compiled and +installed in the used environment. + +JSON::PP is a pure-Perl module and has compatibility to JSON::XS. + + +=head2 FEATURES + +=over + +=item * correct unicode handling + +This module knows how to handle Unicode (depending on Perl version). + +See to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL> and +L<UNICODE HANDLING ON PERLS>. + + +=item * round-trip integrity + +When you serialise a perl data structure using only data types +supported by JSON and Perl, the deserialised data structure is +identical on the Perl level. (e.g. the string "2.0" doesn't suddenly +become "2" just because it looks like a number). There I<are> minor +exceptions to this, read the MAPPING section below to learn about +those. + + +=item * strict checking of JSON correctness + +There is no guessing, no generating of illegal JSON texts by default, +and only JSON is accepted as input by default (the latter is a +security feature). But when some options are set, loose checking +features are available. + +=back + +=head1 FUNCTIONAL INTERFACE + +Some documents are copied and modified from L<JSON::XS/FUNCTIONAL INTERFACE>. + +=head2 encode_json + + $json_text = encode_json $perl_scalar + +Converts the given Perl data structure to a UTF-8 encoded, binary string. + +This function call is functionally identical to: + + $json_text = JSON::PP->new->utf8->encode($perl_scalar) + +=head2 decode_json + + $perl_scalar = decode_json $json_text + +The opposite of C<encode_json>: expects an UTF-8 (binary) string and tries +to parse that as an UTF-8 encoded JSON text, returning the resulting +reference. + +This function call is functionally identical to: + + $perl_scalar = JSON::PP->new->utf8->decode($json_text) + +=head2 JSON::PP::is_bool + + $is_boolean = JSON::PP::is_bool($scalar) + +Returns true if the passed scalar represents either JSON::PP::true or +JSON::PP::false, two constants that act like C<1> and C<0> respectively +and are also used to represent JSON C<true> and C<false> in Perl strings. + +=head2 JSON::PP::true + +Returns JSON true value which is blessed object. +It C<isa> JSON::PP::Boolean object. + +=head2 JSON::PP::false + +Returns JSON false value which is blessed object. +It C<isa> JSON::PP::Boolean object. + +=head2 JSON::PP::null + +Returns C<undef>. + +See L<MAPPING>, below, for more information on how JSON values are mapped to +Perl. + + +=head1 HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER + +This section supposes that your perl version is 5.8 or later. + +If you know a JSON text from an outer world - a network, a file content, and so on, +is encoded in UTF-8, you should use C<decode_json> or C<JSON> module object +with C<utf8> enable. And the decoded result will contain UNICODE characters. + + # from network + my $json = JSON::PP->new->utf8; + my $json_text = CGI->new->param( 'json_data' ); + my $perl_scalar = $json->decode( $json_text ); + + # from file content + local $/; + open( my $fh, '<', 'json.data' ); + $json_text = <$fh>; + $perl_scalar = decode_json( $json_text ); + +If an outer data is not encoded in UTF-8, firstly you should C<decode> it. + + use Encode; + local $/; + open( my $fh, '<', 'json.data' ); + my $encoding = 'cp932'; + my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE + + # or you can write the below code. + # + # open( my $fh, "<:encoding($encoding)", 'json.data' ); + # $unicode_json_text = <$fh>; + +In this case, C<$unicode_json_text> is of course UNICODE string. +So you B<cannot> use C<decode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable. + + $perl_scalar = $json->utf8(0)->decode( $unicode_json_text ); + +Or C<encode 'utf8'> and C<decode_json>: + + $perl_scalar = decode_json( encode( 'utf8', $unicode_json_text ) ); + # this way is not efficient. + +And now, you want to convert your C<$perl_scalar> into JSON data and +send it to an outer world - a network or a file content, and so on. + +Your data usually contains UNICODE strings and you want the converted data to be encoded +in UTF-8, you should use C<encode_json> or C<JSON> module object with C<utf8> enable. + + print encode_json( $perl_scalar ); # to a network? file? or display? + # or + print $json->utf8->encode( $perl_scalar ); + +If C<$perl_scalar> does not contain UNICODE but C<$encoding>-encoded strings +for some reason, then its characters are regarded as B<latin1> for perl +(because it does not concern with your $encoding). +You B<cannot> use C<encode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable. +Note that the resulted text is a UNICODE string but no problem to print it. + + # $perl_scalar contains $encoding encoded string values + $unicode_json_text = $json->utf8(0)->encode( $perl_scalar ); + # $unicode_json_text consists of characters less than 0x100 + print $unicode_json_text; + +Or C<decode $encoding> all string values and C<encode_json>: + + $perl_scalar->{ foo } = decode( $encoding, $perl_scalar->{ foo } ); + # ... do it to each string values, then encode_json + $json_text = encode_json( $perl_scalar ); + +This method is a proper way but probably not efficient. + +See to L<Encode>, L<perluniintro>. + + +=head1 METHODS + +Basically, check to L<JSON> or L<JSON::XS>. + +=head2 new + + $json = JSON::PP->new + +Returns a new JSON::PP object that can be used to de/encode JSON +strings. + +All boolean flags described below are by default I<disabled>. + +The mutators for flags all return the JSON object again and thus calls can +be chained: + + my $json = JSON::PP->new->utf8->space_after->encode({a => [1,2]}) + => {"a": [1, 2]} + +=head2 ascii + + $json = $json->ascii([$enable]) + + $enabled = $json->get_ascii + +If $enable is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627. +(See to L<JSON::XS/OBJECT-ORIENTED INTERFACE>). + +In Perl 5.005, there is no character having high value (more than 255). +See to L<UNICODE HANDLING ON PERLS>. + +If $enable is false, then the encode method will not escape Unicode characters unless +required by the JSON syntax or other flags. This results in a faster and more compact format. + + JSON::PP->new->ascii(1)->encode([chr 0x10401]) + => ["\ud801\udc01"] + +=head2 latin1 + + $json = $json->latin1([$enable]) + + $enabled = $json->get_latin1 + +If $enable is true (or missing), then the encode method will encode the resulting JSON +text as latin1 (or iso-8859-1), escaping any characters outside the code range 0..255. + +If $enable is false, then the encode method will not escape Unicode characters +unless required by the JSON syntax or other flags. + + JSON::XS->new->latin1->encode (["\x{89}\x{abc}"] + => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not) + +See to L<UNICODE HANDLING ON PERLS>. + +=head2 utf8 + + $json = $json->utf8([$enable]) + + $enabled = $json->get_utf8 + +If $enable is true (or missing), then the encode method will encode the JSON result +into UTF-8, as required by many protocols, while the decode method expects to be handled +an UTF-8-encoded string. Please note that UTF-8-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. + +(In Perl 5.005, any character outside the range 0..255 does not exist. +See to L<UNICODE HANDLING ON PERLS>.) + +In future versions, enabling this option might enable autodetection of the UTF-16 and UTF-32 +encoding families, as described in RFC4627. + +If $enable is false, then the encode method will return the JSON string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to UTF-8 or UTF-16) needs to be done yourself, e.g. using the Encode module. + +Example, output UTF-16BE-encoded JSON: + + use Encode; + $jsontext = encode "UTF-16BE", JSON::PP->new->encode ($object); + +Example, decode UTF-32LE-encoded JSON: + + use Encode; + $object = JSON::PP->new->decode (decode "UTF-32LE", $jsontext); + + +=head2 pretty + + $json = $json->pretty([$enable]) + +This enables (or disables) all of the C<indent>, C<space_before> and +C<space_after> flags in one call to generate the most readable +(or most compact) form possible. + +Equivalent to: + + $json->indent->space_before->space_after + +=head2 indent + + $json = $json->indent([$enable]) + + $enabled = $json->get_indent + +The default indent space length is three. +You can use C<indent_length> to change the length. + +=head2 space_before + + $json = $json->space_before([$enable]) + + $enabled = $json->get_space_before + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space before the C<:> separating keys from values in JSON objects. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before enabled, space_after and indent disabled: + + {"key" :"value"} + +=head2 space_after + + $json = $json->space_after([$enable]) + + $enabled = $json->get_space_after + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space after the C<:> separating keys from values in JSON objects +and extra whitespace after the C<,> separating key-value pairs and array +members. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before and indent disabled, space_after enabled: + + {"key": "value"} + +=head2 relaxed + + $json = $json->relaxed([$enable]) + + $enabled = $json->get_relaxed + +If C<$enable> is true (or missing), then C<decode> will accept some +extensions to normal JSON syntax (see below). C<encode> will not be +affected in anyway. I<Be aware that this option makes you accept invalid +JSON texts as if they were valid!>. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) + +If C<$enable> is false (the default), then C<decode> will only accept +valid JSON texts. + +Currently accepted extensions are: + +=over 4 + +=item * list items can have an end-comma + +JSON I<separates> array elements and key-value pairs with commas. This +can be annoying if you write JSON texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: + + [ + 1, + 2, <- this comma not normally allowed + ] + { + "k1": "v1", + "k2": "v2", <- this comma not normally allowed + } + +=item * shell-style '#'-comments + +Whenever JSON allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. + + [ + 1, # this comment not allowed in JSON + # neither this one... + ] + +=back + +=head2 canonical + + $json = $json->canonical([$enable]) + + $enabled = $json->get_canonical + +If C<$enable> is true (or missing), then the C<encode> method will output JSON objects +by sorting their keys. This is adding a comparatively high overhead. + +If C<$enable> is false, then the C<encode> method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). + +This option is useful if you want the same data structure to be encoded as +the same JSON text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. + +This setting has no effect when decoding JSON texts. + +If you want your own sorting routine, you can give a code reference +or a subroutine name to C<sort_by>. See to C<JSON::PP OWN METHODS>. + +=head2 allow_nonref + + $json = $json->allow_nonref([$enable]) + + $enabled = $json->get_allow_nonref + +If C<$enable> is true (or missing), then the C<encode> method can convert a +non-reference into its corresponding string, number or null JSON value, +which is an extension to RFC4627. Likewise, C<decode> will accept those JSON +values instead of croaking. + +If C<$enable> is false, then the C<encode> method will croak if it isn't +passed an arrayref or hashref, as JSON texts must either be an object +or array. Likewise, C<decode> will croak if given something that is not a +JSON object or array. + + JSON::PP->new->allow_nonref->encode ("Hello, World!") + => "Hello, World!" + +=head2 allow_unknown + + $json = $json->allow_unknown ([$enable]) + + $enabled = $json->get_allow_unknown + +If $enable is true (or missing), then "encode" will *not* throw an +exception when it encounters values it cannot represent in JSON (for +example, filehandles) but instead will encode a JSON "null" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. + +If $enable is false (the default), then "encode" will throw an +exception when it encounters anything it cannot encode as JSON. + +This option does not affect "decode" in any way, and it is +recommended to leave it off unless you know your communications +partner. + +=head2 allow_blessed + + $json = $json->allow_blessed([$enable]) + + $enabled = $json->get_allow_blessed + +If C<$enable> is true (or missing), then the C<encode> method will not +barf when it encounters a blessed reference. Instead, the value of the +B<convert_blessed> option will decide whether C<null> (C<convert_blessed> +disabled or no C<TO_JSON> method found) or a representation of the +object (C<convert_blessed> enabled and C<TO_JSON> method found) is being +encoded. Has no effect on C<decode>. + +If C<$enable> is false (the default), then C<encode> will throw an +exception when it encounters a blessed object. + +=head2 convert_blessed + + $json = $json->convert_blessed([$enable]) + + $enabled = $json->get_convert_blessed + +If C<$enable> is true (or missing), then C<encode>, upon encountering a +blessed object, will check for the availability of the C<TO_JSON> method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +C<TO_JSON> method is found, the value of C<allow_blessed> will decide what +to do. + +The C<TO_JSON> method may safely call die if it wants. If C<TO_JSON> +returns other blessed objects, those will be handled in the same +way. C<TO_JSON> must take care of not causing an endless recursion cycle +(== crash) in this case. The name of C<TO_JSON> was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the C<to_json> +function or method. + +This setting does not yet influence C<decode> in any way. + +If C<$enable> is false, then the C<allow_blessed> setting will decide what +to do when a blessed object is found. + +=head2 filter_json_object + + $json = $json->filter_json_object([$coderef]) + +When C<$coderef> is specified, it will be called from C<decode> each +time it decodes a JSON object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(NOTE: I<not> C<undef>, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. + +When C<$coderef> is omitted or undefined, any existing callback will +be removed and C<decode> will not change the deserialised hash in any +way. + +Example, convert all JSON objects into the integer 5: + + my $js = JSON::PP->new->filter_json_object (sub { 5 }); + # returns [5] + $js->decode ('[{}]'); # the given subroutine takes a hash reference. + # throw an exception because allow_nonref is not enabled + # so a lone 5 is not allowed. + $js->decode ('{"a":1, "b":2}'); + +=head2 filter_json_single_key_object + + $json = $json->filter_json_single_key_object($key [=> $coderef]) + +Works remotely similar to C<filter_json_object>, but is only called for +JSON objects having a single key named C<$key>. + +This C<$coderef> is called before the one specified via +C<filter_json_object>, if any. It gets passed the single value in the JSON +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even C<undef> but the empty list), +the callback from C<filter_json_object> will be called next, as if no +single-key callback were specified. + +If C<$coderef> is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. + +As this callback gets called less often then the C<filter_json_object> +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key JSON objects are as close to the type-tagged value concept +as JSON gets (it's basically an ID/VALUE tuple). Of course, JSON does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. + +Typical names for the single object key are C<__class_whatever__>, or +C<$__dollars_are_rarely_used__$> or C<}ugly_brace_placement>, or even +things like C<__class_md5sum(classname)__>, to reduce the risk of clashing +with real hashes. + +Example, decode JSON objects of the form C<< { "__widget__" => <id> } >> +into the corresponding C<< $WIDGET{<id>} >> object: + + # return whatever is in $WIDGET{5}: + JSON::PP + ->new + ->filter_json_single_key_object (__widget__ => sub { + $WIDGET{ $_[0] } + }) + ->decode ('{"__widget__": 5') + + # this can be used with a TO_JSON method in some "widget" class + # for serialisation to json: + sub WidgetBase::TO_JSON { + my ($self) = @_; + + unless ($self->{id}) { + $self->{id} = ..get..some..id..; + $WIDGET{$self->{id}} = $self; + } + + { __widget__ => $self->{id} } + } + +=head2 shrink + + $json = $json->shrink([$enable]) + + $enabled = $json->get_shrink + +In JSON::XS, this flag resizes strings generated by either +C<encode> or C<decode> to their minimum size possible. +It will also try to downgrade any strings to octet-form if possible. + +In JSON::PP, it is noop about resizing strings but tries +C<utf8::downgrade> to the returned string by C<encode>. +See to L<utf8>. + +See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> + +=head2 max_depth + + $json = $json->max_depth([$maximum_nesting_depth]) + + $max_depth = $json->get_max_depth + +Sets the maximum nesting level (default C<512>) accepted while encoding +or decoding. If a higher nesting level is detected in JSON text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. + +Nesting level is defined by number of hash- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of C<{> or C<[> +characters without their matching closing parenthesis crossed to reach a +given character in a string. + +If no argument is given, the highest possible setting will be used, which +is rarely useful. + +See L<JSON::XS/SSECURITY CONSIDERATIONS> for more info on why this is useful. + +When a large value (100 or more) was set and it de/encodes a deep nested object/text, +it may raise a warning 'Deep recursion on subroutine' at the perl runtime phase. + +=head2 max_size + + $json = $json->max_size([$maximum_string_size]) + + $max_size = $json->get_max_size + +Set the maximum length a JSON text may have (in bytes) where decoding is +being attempted. The default is C<0>, meaning no limit. When C<decode> +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on C<encode> (yet). + +If no argument is given, the limit check will be deactivated (same as when +C<0> is specified). + +See L<JSON::XS/SECURITY CONSIDERATIONS> for more info on why this is useful. + +=head2 encode + + $json_text = $json->encode($perl_scalar) + +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its JSON representation. Simple scalars will be +converted into JSON string or number sequences, while references to arrays +become JSON arrays and references to hashes become JSON objects. Undefined +Perl values (e.g. C<undef>) become JSON C<null> values. +References to the integers C<0> and C<1> are converted into C<true> and C<false>. + +=head2 decode + + $perl_scalar = $json->decode($json_text) + +The opposite of C<encode>: expects a JSON text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. + +JSON numbers and strings become simple Perl scalars. JSON arrays become +Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes +C<1> (C<JSON::true>), C<false> becomes C<0> (C<JSON::false>) and +C<null> becomes C<undef>. + +=head2 decode_prefix + + ($perl_scalar, $characters) = $json->decode_prefix($json_text) + +This works like the C<decode> method, but instead of raising an exception +when there is trailing garbage after the first JSON object, it will +silently stop parsing there and return the number of characters consumed +so far. + + JSON->new->decode_prefix ("[1] the tail") + => ([], 3) + +=head1 INCREMENTAL PARSING + +Most of this section are copied and modified from L<JSON::XS/INCREMENTAL PARSING>. + +In some cases, there is the need for incremental parsing of JSON texts. +This module does allow you to parse a JSON stream incrementally. +It does so by accumulating text until it has a full JSON object, which +it then can decode. This process is similar to using C<decode_prefix> +to see if a full JSON object is available, but is much more efficient +(and can be implemented with a minimum of method calls). + +This module will only attempt to parse the JSON text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid JSON text has been seen. This means you need +to set resource limits (e.g. C<max_size>) to ensure the parser will stop +parsing in the presence if syntax errors. + +The following methods implement this incremental parser. + +=head2 incr_parse + + $json->incr_parse( [$string] ) # void context + + $obj_or_undef = $json->incr_parse( [$string] ) # scalar context + + @obj_or_empty = $json->incr_parse( [$string] ) # list context + +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). + +If C<$string> is given, then this string is appended to the already +existing JSON fragment stored in the C<$json> object. + +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. + +If the method is called in scalar context, then it will try to extract +exactly I<one> JSON object. If that is successful, it will return this +object, otherwise it will return C<undef>. If there is a parse error, +this method will croak just as C<decode> would do (one can then use +C<incr_skip> to skip the erroneous part). This is the most common way of +using the method. + +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the JSON +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed JSON texts will be +lost. + +Example: Parse some JSON arrays/objects in a given string and return them. + + my @objs = JSON->new->incr_parse ("[5][7][1,2]"); + +=head2 incr_text + + $lvalue_string = $json->incr_text + +This method returns the currently stored JSON fragment as an lvalue, that +is, you can manipulate it. This I<only> works when a preceding call to +C<incr_parse> in I<scalar context> successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it I<will> fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. + +This function is useful in two cases: a) finding the trailing text after a +JSON object or b) parsing multiple JSON objects separated by non-JSON text +(such as commas). + + $json->incr_text =~ s/\s*,\s*//; + +In Perl 5.005, C<lvalue> attribute is not available. +You must write codes like the below: + + $string = $json->incr_text; + $string =~ s/\s*,\s*//; + $json->incr_text( $string ); + +=head2 incr_skip + + $json->incr_skip + +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after C<incr_parse> +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. + +=head2 incr_reset + + $json->incr_reset + +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. + +This is useful if you want to repeatedly parse JSON objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. + +See to L<JSON::XS/INCREMENTAL PARSING> for examples. + + +=head1 JSON::PP OWN METHODS + +=head2 allow_singlequote + + $json = $json->allow_singlequote([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +JSON strings quoted by single quotations that are invalid JSON +format. + + $json->allow_singlequote->decode({"foo":'bar'}); + $json->allow_singlequote->decode({'foo':"bar"}); + $json->allow_singlequote->decode({'foo':'bar'}); + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + + +=head2 allow_barekey + + $json = $json->allow_barekey([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +bare keys of JSON object that are invalid JSON format. + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + + $json->allow_barekey->decode('{foo:"bar"}'); + +=head2 allow_bignum + + $json = $json->allow_bignum([$enable]) + +If C<$enable> is true (or missing), then C<decode> will convert +the big integer Perl cannot handle as integer into a L<Math::BigInt> +object and convert a floating number (any) into a L<Math::BigFloat>. + +On the contrary, C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers with C<allow_blessed> enable. + + $json->allow_nonref->allow_blessed->allow_bignum; + $bigfloat = $json->decode('2.000000000000000000000000001'); + print $json->encode($bigfloat); + # => 2.000000000000000000000000001 + +See to L<JSON::XS/MAPPING> about the normal conversion of JSON number. + +=head2 loose + + $json = $json->loose([$enable]) + +The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON strings +and the module doesn't allow to C<decode> to these (except for \x2f). +If C<$enable> is true (or missing), then C<decode> will accept these +unescaped strings. + + $json->loose->decode(qq|["abc + def"]|); + +See L<JSON::XS/SSECURITY CONSIDERATIONS>. + +=head2 escape_slash + + $json = $json->escape_slash([$enable]) + +According to JSON Grammar, I<slash> (U+002F) is escaped. But default +JSON::PP (as same as JSON::XS) encodes strings without escaping slash. + +If C<$enable> is true (or missing), then C<encode> will escape slashes. + +=head2 indent_length + + $json = $json->indent_length($length) + +JSON::XS indent space length is 3 and cannot be changed. +JSON::PP set the indent space length with the given $length. +The default is 3. The acceptable range is 0 to 15. + +=head2 sort_by + + $json = $json->sort_by($function_name) + $json = $json->sort_by($subroutine_ref) + +If $function_name or $subroutine_ref are set, its sort routine are used +in encoding JSON objects. + + $js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + $js = $pc->sort_by('own_sort')->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } + +As the sorting routine runs in the JSON::PP scope, the given +subroutine name and the special variables C<$a>, C<$b> will begin +'JSON::PP::'. + +If $integer is set, then the effect is same as C<canonical> on. + +=head1 INTERNAL + +For developers. + +=over + +=item PP_encode_box + +Returns + + { + depth => $depth, + indent_count => $indent_count, + } + + +=item PP_decode_box + +Returns + + { + text => $text, + at => $at, + ch => $ch, + len => $len, + depth => $depth, + encoding => $encoding, + is_valid_utf8 => $is_valid_utf8, + }; + +=back + +=head1 MAPPING + +This section is copied from JSON::XS and modified to C<JSON::PP>. +JSON::XS and JSON::PP mapping mechanisms are almost equivalent. + +See to L<JSON::XS/MAPPING>. + +=head2 JSON -> PERL + +=over 4 + +=item object + +A JSON object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (JSON does not preserver object key ordering itself). + +=item array + +A JSON array becomes a reference to an array in Perl. + +=item string + +A JSON string becomes a string scalar in Perl - Unicode codepoints in JSON +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. + +=item number + +A JSON number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. + +If the number consists of digits only, C<JSON> will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the JSON number will be +re-encoded to a JSON string). + +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the JSON number will still be re-encoded as a JSON number). + +Note that precision is not accuracy - binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, C<JSON> only guarantees precision up to but not including +the least significant bit. + +When C<allow_bignum> is enable, the big integers +and the numeric can be optionally converted into L<Math::BigInt> and +L<Math::BigFloat> objects. + +=item true, false + +These JSON atoms become C<JSON::PP::true> and C<JSON::PP::false>, +respectively. They are overloaded to act almost exactly like the numbers +C<1> and C<0>. You can check whether a scalar is a JSON boolean by using +the C<JSON::is_bool> function. + + print JSON::PP::true . "\n"; + => true + print JSON::PP::true + 1; + => 1 + + ok(JSON::true eq '1'); + ok(JSON::true == 1); + +C<JSON> will install these missing overloading features to the backend modules. + + +=item null + +A JSON null atom becomes C<undef> in Perl. + +C<JSON::PP::null> returns C<undef>. + +=back + + +=head2 PERL -> JSON + +The mapping from Perl to JSON is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which JSON type is meant by +a Perl value. + +=over 4 + +=item hash references + +Perl hash references become JSON objects. As there is no inherent ordering +in hash keys (or JSON objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. C<JSON> +optionally sort the hash keys (determined by the I<canonical> flag), so +the same data structure will serialise to the same JSON text (given same +settings and version of JSON::XS), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some JSON text +against another for equality. + + +=item array references + +Perl array references become JSON arrays. + +=item other references + +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers C<0> and +C<1>, which get turned into C<false> and C<true> atoms in JSON. You can +also use C<JSON::false> and C<JSON::true> to improve readability. + + to_json [\0,JSON::PP::true] # yields [false,true] + +=item JSON::PP::true, JSON::PP::false, JSON::PP::null + +These special values become JSON true and JSON false values, +respectively. You can also use C<\1> and C<\0> directly if you want. + +JSON::PP::null returns C<undef>. + +=item blessed objects + +Blessed objects are not directly representable in JSON. See the +C<allow_blessed> and C<convert_blessed> methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. + +See to L<convert_blessed>. + +=item simple scalars + +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: JSON::XS and JSON::PP will encode undefined scalars as +JSON C<null> values, scalars that have last been used in a string context +before encoding as JSON strings, and anything else as number value: + + # dump as number + encode_json [2] # yields [2] + encode_json [-3.0e17] # yields [-3e+17] + my $value = 5; encode_json [$value] # yields [5] + + # used as string, so dump as string + print $value; + encode_json [$value] # yields ["5"] + + # undef becomes null + encode_json [undef] # yields [null] + +You can force the type to be a string by stringifying it: + + my $x = 3.1; # some variable containing a number + "$x"; # stringified + $x .= ""; # another, more awkward way to stringify + print $x; # perl does it for you, too, quite often + +You can force the type to be a number by numifying it: + + my $x = "3"; # some variable containing a string + $x += 0; # numify it, ensuring it will be dumped as a number + $x *= 1; # same thing, the choice is yours. + +You can not currently force the type in other, less obscure, ways. + +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's - these cannot be represented in JSON, and it is an +error to pass those in. + +=item Big Number + +When C<allow_bignum> is enable, +C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers. + + +=back + +=head1 UNICODE HANDLING ON PERLS + +If you do not know about Unicode on Perl well, +please check L<JSON::XS/A FEW NOTES ON UNICODE AND PERL>. + +=head2 Perl 5.8 and later + +Perl can handle Unicode and the JSON::PP de/encode methods also work properly. + + $json->allow_nonref->encode(chr hex 3042); + $json->allow_nonref->encode(chr hex 12345); + +Returns C<"\u3042"> and C<"\ud808\udf45"> respectively. + + $json->allow_nonref->decode('"\u3042"'); + $json->allow_nonref->decode('"\ud808\udf45"'); + +Returns UTF-8 encoded strings with UTF8 flag, regarded as C<U+3042> and C<U+12345>. + +Note that the versions from Perl 5.8.0 to 5.8.2, Perl built-in C<join> was broken, +so JSON::PP wraps the C<join> with a subroutine. Thus JSON::PP works slow in the versions. + + +=head2 Perl 5.6 + +Perl can handle Unicode and the JSON::PP de/encode methods also work. + +=head2 Perl 5.005 + +Perl 5.005 is a byte semantics world -- all strings are sequences of bytes. +That means the unicode handling is not available. + +In encoding, + + $json->allow_nonref->encode(chr hex 3042); # hex 3042 is 12354. + $json->allow_nonref->encode(chr hex 12345); # hex 12345 is 74565. + +Returns C<B> and C<E>, as C<chr> takes a value more than 255, it treats +as C<$value % 256>, so the above codes are equivalent to : + + $json->allow_nonref->encode(chr 66); + $json->allow_nonref->encode(chr 69); + +In decoding, + + $json->decode('"\u00e3\u0081\u0082"'); + +The returned is a byte sequence C<0xE3 0x81 0x82> for UTF-8 encoded +japanese character (C<HIRAGANA LETTER A>). +And if it is represented in Unicode code point, C<U+3042>. + +Next, + + $json->decode('"\u3042"'); + +We ordinary expect the returned value is a Unicode character C<U+3042>. +But here is 5.005 world. This is C<0xE3 0x81 0x82>. + + $json->decode('"\ud808\udf45"'); + +This is not a character C<U+12345> but bytes - C<0xf0 0x92 0x8d 0x85>. + + +=head1 TODO + +=over + +=item speed + +=item memory saving + +=back + + +=head1 SEE ALSO + +Most of the document are copied and modified from JSON::XS doc. + +L<JSON::XS> + +RFC4627 (L<http://www.ietf.org/rfc/rfc4627.txt>) + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2007-2012 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut diff --git a/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Boolean.pm b/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Boolean.pm new file mode 100644 index 0000000..38be6a3 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Boolean.pm @@ -0,0 +1,27 @@ +=head1 NAME + +JSON::PP::Boolean - dummy module providing JSON::PP::Boolean + +=head1 SYNOPSIS + + # do not "use" yourself + +=head1 DESCRIPTION + +This module exists only to provide overload resolution for Storable +and similar modules. See L<JSON::PP> for more info about this class. + +=cut + +use JSON::backportPP (); +use strict; + +1; + +=head1 AUTHOR + +This idea is from L<JSON::XS::Boolean> written by +Marc Lehmann <schmorp[at]schmorp.de> + +=cut + diff --git a/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5005.pm b/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5005.pm new file mode 100644 index 0000000..139990e --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5005.pm @@ -0,0 +1,131 @@ +package # This is JSON::backportPP + JSON::backportPP5005; + +use 5.005; +use strict; + +my @properties; + +$JSON::PP5005::VERSION = '1.10'; + +BEGIN { + + sub utf8::is_utf8 { + 0; # It is considered that UTF8 flag off for Perl 5.005. + } + + sub utf8::upgrade { + } + + sub utf8::downgrade { + 1; # must always return true. + } + + sub utf8::encode { + } + + sub utf8::decode { + } + + *JSON::PP::JSON_PP_encode_ascii = \&_encode_ascii; + *JSON::PP::JSON_PP_encode_latin1 = \&_encode_latin1; + *JSON::PP::JSON_PP_decode_surrogates = \&_decode_surrogates; + *JSON::PP::JSON_PP_decode_unicode = \&_decode_unicode; + + # missing in B module. + sub B::SVp_IOK () { 0x01000000; } + sub B::SVp_NOK () { 0x02000000; } + sub B::SVp_POK () { 0x04000000; } + + $INC{'bytes.pm'} = 1; # dummy +} + + + +sub _encode_ascii { + join('', map { $_ <= 127 ? chr($_) : sprintf('\u%04x', $_) } unpack('C*', $_[0]) ); +} + + +sub _encode_latin1 { + join('', map { chr($_) } unpack('C*', $_[0]) ); +} + + +sub _decode_surrogates { # from http://homepage1.nifty.com/nomenclator/unicode/ucs_utf.htm + my $uni = 0x10000 + (hex($_[0]) - 0xD800) * 0x400 + (hex($_[1]) - 0xDC00); # from perlunicode + my $bit = unpack('B32', pack('N', $uni)); + + if ( $bit =~ /^00000000000(...)(......)(......)(......)$/ ) { + my ($w, $x, $y, $z) = ($1, $2, $3, $4); + return pack('B*', sprintf('11110%s10%s10%s10%s', $w, $x, $y, $z)); + } + else { + Carp::croak("Invalid surrogate pair"); + } +} + + +sub _decode_unicode { + my ($u) = @_; + my ($utf8bit); + + if ( $u =~ /^00([89a-f][0-9a-f])$/i ) { # 0x80-0xff + return pack( 'H2', $1 ); + } + + my $bit = unpack("B*", pack("H*", $u)); + + if ( $bit =~ /^00000(.....)(......)$/ ) { + $utf8bit = sprintf('110%s10%s', $1, $2); + } + elsif ( $bit =~ /^(....)(......)(......)$/ ) { + $utf8bit = sprintf('1110%s10%s10%s', $1, $2, $3); + } + else { + Carp::croak("Invalid escaped unicode"); + } + + return pack('B*', $utf8bit); +} + + +sub JSON::PP::incr_text { + $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new; + + if ( $_[0]->{_incr_parser}->{incr_parsing} ) { + Carp::croak("incr_text can not be called when the incremental parser already started parsing"); + } + + $_[0]->{_incr_parser}->{incr_text} = $_[1] if ( @_ > 1 ); + $_[0]->{_incr_parser}->{incr_text}; +} + + +1; +__END__ + +=pod + +=head1 NAME + +JSON::PP5005 - Helper module in using JSON::PP in Perl 5.005 + +=head1 DESCRIPTION + +JSON::PP calls internally. + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2007-2012 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5006.pm b/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5006.pm new file mode 100644 index 0000000..7736fd8 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5006.pm @@ -0,0 +1,173 @@ +package # This is JSON::backportPP + JSON::backportPP56; + +use 5.006; +use strict; + +my @properties; + +$JSON::PP56::VERSION = '1.08'; + +BEGIN { + + sub utf8::is_utf8 { + my $len = length $_[0]; # char length + { + use bytes; # byte length; + return $len != length $_[0]; # if !=, UTF8-flagged on. + } + } + + + sub utf8::upgrade { + ; # noop; + } + + + sub utf8::downgrade ($;$) { + return 1 unless ( utf8::is_utf8( $_[0] ) ); + + if ( _is_valid_utf8( $_[0] ) ) { + my $downgrade; + for my $c ( unpack( "U*", $_[0] ) ) { + if ( $c < 256 ) { + $downgrade .= pack("C", $c); + } + else { + $downgrade .= pack("U", $c); + } + } + $_[0] = $downgrade; + return 1; + } + else { + Carp::croak("Wide character in subroutine entry") unless ( $_[1] ); + 0; + } + } + + + sub utf8::encode ($) { # UTF8 flag off + if ( utf8::is_utf8( $_[0] ) ) { + $_[0] = pack( "C*", unpack( "C*", $_[0] ) ); + } + else { + $_[0] = pack( "U*", unpack( "C*", $_[0] ) ); + $_[0] = pack( "C*", unpack( "C*", $_[0] ) ); + } + } + + + sub utf8::decode ($) { # UTF8 flag on + if ( _is_valid_utf8( $_[0] ) ) { + utf8::downgrade( $_[0] ); + $_[0] = pack( "U*", unpack( "U*", $_[0] ) ); + } + } + + + *JSON::PP::JSON_PP_encode_ascii = \&_encode_ascii; + *JSON::PP::JSON_PP_encode_latin1 = \&_encode_latin1; + *JSON::PP::JSON_PP_decode_surrogates = \&JSON::PP::_decode_surrogates; + *JSON::PP::JSON_PP_decode_unicode = \&JSON::PP::_decode_unicode; + + unless ( defined &B::SVp_NOK ) { # missing in B module. + eval q{ sub B::SVp_NOK () { 0x02000000; } }; + } + +} + + + +sub _encode_ascii { + join('', + map { + $_ <= 127 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', JSON::PP::_encode_surrogates($_)); + } _unpack_emu($_[0]) + ); +} + + +sub _encode_latin1 { + join('', + map { + $_ <= 255 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', JSON::PP::_encode_surrogates($_)); + } _unpack_emu($_[0]) + ); +} + + +sub _unpack_emu { # for Perl 5.6 unpack warnings + return !utf8::is_utf8($_[0]) ? unpack('C*', $_[0]) + : _is_valid_utf8($_[0]) ? unpack('U*', $_[0]) + : unpack('C*', $_[0]); +} + + +sub _is_valid_utf8 { + my $str = $_[0]; + my $is_utf8; + + while ($str =~ /(?: + ( + [\x00-\x7F] + |[\xC2-\xDF][\x80-\xBF] + |[\xE0][\xA0-\xBF][\x80-\xBF] + |[\xE1-\xEC][\x80-\xBF][\x80-\xBF] + |[\xED][\x80-\x9F][\x80-\xBF] + |[\xEE-\xEF][\x80-\xBF][\x80-\xBF] + |[\xF0][\x90-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF4][\x80-\x8F][\x80-\xBF][\x80-\xBF] + ) + | (.) + )/xg) + { + if (defined $1) { + $is_utf8 = 1 if (!defined $is_utf8); + } + else { + $is_utf8 = 0 if (!defined $is_utf8); + if ($is_utf8) { # eventually, not utf8 + return; + } + } + } + + return $is_utf8; +} + + +1; +__END__ + +=pod + +=head1 NAME + +JSON::PP56 - Helper module in using JSON::PP in Perl 5.6 + +=head1 DESCRIPTION + +JSON::PP calls internally. + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2007-2012 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/JSON-2.59/blib/lib/auto/JSON/.exists b/third_party/JSON/JSON-2.59/blib/lib/auto/JSON/.exists new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/lib/auto/JSON/.exists diff --git a/third_party/JSON/JSON-2.59/blib/man1/.exists b/third_party/JSON/JSON-2.59/blib/man1/.exists new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/man1/.exists diff --git a/third_party/JSON/JSON-2.59/blib/man3/.exists b/third_party/JSON/JSON-2.59/blib/man3/.exists new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/man3/.exists diff --git a/third_party/JSON/JSON-2.59/blib/man3/JSON.3pm b/third_party/JSON/JSON-2.59/blib/man3/JSON.3pm new file mode 100644 index 0000000..4a73a04 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/man3/JSON.3pm @@ -0,0 +1,1876 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON 3pm" +.TH JSON 3pm "2013-06-05" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON \- JSON (JavaScript Object Notation) encoder/decoder +.SH "SYNOPSIS" +.IX Header "SYNOPSIS" +.Vb 1 +\& use JSON; # imports encode_json, decode_json, to_json and from_json. +\& +\& # simple and fast interfaces (expect/generate UTF\-8) +\& +\& $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; +\& $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; +\& +\& # OO\-interface +\& +\& $json = JSON\->new\->allow_nonref; +\& +\& $json_text = $json\->encode( $perl_scalar ); +\& $perl_scalar = $json\->decode( $json_text ); +\& +\& $pretty_printed = $json\->pretty\->encode( $perl_scalar ); # pretty\-printing +\& +\& # If you want to use PP only support features, call with \*(Aq\-support_by_pp\*(Aq +\& # When XS unsupported feature is enable, using PP (de|en)code instead of XS ones. +\& +\& use JSON \-support_by_pp; +\& +\& # option\-acceptable interfaces (expect/generate UNICODE by default) +\& +\& $json_text = to_json( $perl_scalar, { ascii => 1, pretty => 1 } ); +\& $perl_scalar = from_json( $json_text, { utf8 => 1 } ); +\& +\& # Between (en|de)code_json and (to|from)_json, if you want to write +\& # a code which communicates to an outer world (encoded in UTF\-8), +\& # recommend to use (en|de)code_json. +.Ve +.SH "VERSION" +.IX Header "VERSION" +.Vb 1 +\& 2.59 +.Ve +.PP +This version is compatible with \s-1JSON::XS\s0 \fB2.34\fR and later. +.SH "NOTE" +.IX Header "NOTE" +\&\s-1JSON::PP\s0 was earlier included in the \f(CW\*(C`JSON\*(C'\fR distribution, but +has since Perl 5.14 been a core module. For this reason, +\&\s-1JSON::PP\s0 was removed from the \s-1JSON\s0 distribution and can now +be found also in the Perl5 repository at +.IP "\(bu" 4 +<http://perl5.git.perl.org/perl.git> +.PP +(The newest \s-1JSON::PP\s0 version still exists in \s-1CPAN\s0.) +.PP +Instead, the \f(CW\*(C`JSON\*(C'\fR distribution will include JSON::backportPP +for backwards computability. \s-1JSON\s0.pm should thus work as it did +before. +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +.Vb 6 +\& ************************** CAUTION ******************************** +\& * This is \*(AqJSON module version 2\*(Aq and there are many differences * +\& * to version 1.xx * +\& * Please check your applications using old version. * +\& * See to \*(AqINCOMPATIBLE CHANGES TO OLD VERSION\*(Aq * +\& ******************************************************************* +.Ve +.PP +\&\s-1JSON\s0 (JavaScript Object Notation) is a simple data format. +See to <http://www.json.org/> and \f(CW\*(C`RFC4627\*(C'\fR(<http://www.ietf.org/rfc/rfc4627.txt>). +.PP +This module converts Perl data structures to \s-1JSON\s0 and vice versa using either +\&\s-1JSON::XS\s0 or \s-1JSON::PP\s0. +.PP +\&\s-1JSON::XS\s0 is the fastest and most proper \s-1JSON\s0 module on \s-1CPAN\s0 which must be +compiled and installed in your environment. +\&\s-1JSON::PP\s0 is a pure-Perl module which is bundled in this distribution and +has a strong compatibility to \s-1JSON::XS\s0. +.PP +This module try to use \s-1JSON::XS\s0 by default and fail to it, use \s-1JSON::PP\s0 instead. +So its features completely depend on \s-1JSON::XS\s0 or \s-1JSON::PP\s0. +.PP +See to \*(L"\s-1BACKEND\s0 \s-1MODULE\s0 \s-1DECISION\s0\*(R". +.PP +To distinguish the module name '\s-1JSON\s0' and the format type \s-1JSON\s0, +the former is quoted by C<> (its results vary with your using media), +and the latter is left just as it is. +.PP +Module name : \f(CW\*(C`JSON\*(C'\fR +.PP +Format type : \s-1JSON\s0 +.SS "\s-1FEATURES\s0" +.IX Subsection "FEATURES" +.IP "\(bu" 4 +correct unicode handling +.Sp +This module (i.e. backend modules) knows how to handle Unicode, documents +how and when it does so, and even documents what \*(L"correct\*(R" means. +.Sp +Even though there are limitations, this feature is available since Perl version 5.6. +.Sp +\&\s-1JSON::XS\s0 requires Perl 5.8.2 (but works correctly in 5.8.8 or later), so in older versions +\&\f(CW\*(C`JSON\*(C'\fR should call \s-1JSON::PP\s0 as the backend which can be used since Perl 5.005. +.Sp +With Perl 5.8.x \s-1JSON::PP\s0 works, but from 5.8.0 to 5.8.2, because of a Perl side problem, +\&\s-1JSON::PP\s0 works slower in the versions. And in 5.005, the Unicode handling is not available. +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R" in \s-1JSON::PP\s0 for more information. +.Sp +See also to \*(L"A \s-1FEW\s0 \s-1NOTES\s0 \s-1ON\s0 \s-1UNICODE\s0 \s-1AND\s0 \s-1PERL\s0\*(R" in \s-1JSON::XS\s0 +and \*(L"\s-1ENCODING/CODESET_FLAG_NOTES\s0\*(R" in \s-1JSON::XS\s0. +.IP "\(bu" 4 +round-trip integrity +.Sp +When you serialise a perl data structure using only data types supported +by \s-1JSON\s0 and Perl, the deserialised data structure is identical on the Perl +level. (e.g. the string \*(L"2.0\*(R" doesn't suddenly become \*(L"2\*(R" just because +it looks like a number). There \fIare\fR minor exceptions to this, read the +\&\*(L"\s-1MAPPING\s0\*(R" section below to learn about those. +.IP "\(bu" 4 +strict checking of \s-1JSON\s0 correctness +.Sp +There is no guessing, no generating of illegal \s-1JSON\s0 texts by default, +and only \s-1JSON\s0 is accepted as input by default (the latter is a security +feature). +.Sp +See to \*(L"\s-1FEATURES\s0\*(R" in \s-1JSON::XS\s0 and \*(L"\s-1FEATURES\s0\*(R" in \s-1JSON::PP\s0. +.IP "\(bu" 4 +fast +.Sp +This module returns a \s-1JSON::XS\s0 object itself if available. +Compared to other \s-1JSON\s0 modules and other serialisers such as Storable, +\&\s-1JSON::XS\s0 usually compares favorably in terms of speed, too. +.Sp +If not available, \f(CW\*(C`JSON\*(C'\fR returns a \s-1JSON::PP\s0 object instead of \s-1JSON::XS\s0 and +it is very slow as pure-Perl. +.IP "\(bu" 4 +simple to use +.Sp +This module has both a simple functional interface as well as an +object oriented interface interface. +.IP "\(bu" 4 +reasonably versatile output formats +.Sp +You can choose between the most compact guaranteed-single-line format possible +(nice for simple line-based protocols), a pure-ASCII format (for when your transport +is not 8\-bit clean, still supports the whole Unicode range), or a pretty-printed +format (for when you want to read that stuff). Or you can combine those features +in whatever way you like. +.SH "FUNCTIONAL INTERFACE" +.IX Header "FUNCTIONAL INTERFACE" +Some documents are copied and modified from \*(L"\s-1FUNCTIONAL\s0 \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0. +\&\f(CW\*(C`to_json\*(C'\fR and \f(CW\*(C`from_json\*(C'\fR are additional functions. +.SS "encode_json" +.IX Subsection "encode_json" +.Vb 1 +\& $json_text = encode_json $perl_scalar +.Ve +.PP +Converts the given Perl data structure to a \s-1UTF\-8\s0 encoded, binary string. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $json_text = JSON\->new\->utf8\->encode($perl_scalar) +.Ve +.SS "decode_json" +.IX Subsection "decode_json" +.Vb 1 +\& $perl_scalar = decode_json $json_text +.Ve +.PP +The opposite of \f(CW\*(C`encode_json\*(C'\fR: expects an \s-1UTF\-8\s0 (binary) string and tries +to parse that as an \s-1UTF\-8\s0 encoded \s-1JSON\s0 text, returning the resulting +reference. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $perl_scalar = JSON\->new\->utf8\->decode($json_text) +.Ve +.SS "to_json" +.IX Subsection "to_json" +.Vb 1 +\& $json_text = to_json($perl_scalar) +.Ve +.PP +Converts the given Perl data structure to a json string. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $json_text = JSON\->new\->encode($perl_scalar) +.Ve +.PP +Takes a hash reference as the second. +.PP +.Vb 1 +\& $json_text = to_json($perl_scalar, $flag_hashref) +.Ve +.PP +So, +.PP +.Vb 1 +\& $json_text = to_json($perl_scalar, {utf8 => 1, pretty => 1}) +.Ve +.PP +equivalent to: +.PP +.Vb 1 +\& $json_text = JSON\->new\->utf8(1)\->pretty(1)\->encode($perl_scalar) +.Ve +.PP +If you want to write a modern perl code which communicates to outer world, +you should use \f(CW\*(C`encode_json\*(C'\fR (supposed that \s-1JSON\s0 data are encoded in \s-1UTF\-8\s0). +.SS "from_json" +.IX Subsection "from_json" +.Vb 1 +\& $perl_scalar = from_json($json_text) +.Ve +.PP +The opposite of \f(CW\*(C`to_json\*(C'\fR: expects a json string and tries +to parse it, returning the resulting reference. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $perl_scalar = JSON\->decode($json_text) +.Ve +.PP +Takes a hash reference as the second. +.PP +.Vb 1 +\& $perl_scalar = from_json($json_text, $flag_hashref) +.Ve +.PP +So, +.PP +.Vb 1 +\& $perl_scalar = from_json($json_text, {utf8 => 1}) +.Ve +.PP +equivalent to: +.PP +.Vb 1 +\& $perl_scalar = JSON\->new\->utf8(1)\->decode($json_text) +.Ve +.PP +If you want to write a modern perl code which communicates to outer world, +you should use \f(CW\*(C`decode_json\*(C'\fR (supposed that \s-1JSON\s0 data are encoded in \s-1UTF\-8\s0). +.SS "JSON::is_bool" +.IX Subsection "JSON::is_bool" +.Vb 1 +\& $is_boolean = JSON::is_bool($scalar) +.Ve +.PP +Returns true if the passed scalar represents either JSON::true or +JSON::false, two constants that act like \f(CW1\fR and \f(CW0\fR respectively +and are also used to represent \s-1JSON\s0 \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR in Perl strings. +.SS "JSON::true" +.IX Subsection "JSON::true" +Returns \s-1JSON\s0 true value which is blessed object. +It \f(CW\*(C`isa\*(C'\fR JSON::Boolean object. +.SS "JSON::false" +.IX Subsection "JSON::false" +Returns \s-1JSON\s0 false value which is blessed object. +It \f(CW\*(C`isa\*(C'\fR JSON::Boolean object. +.SS "JSON::null" +.IX Subsection "JSON::null" +Returns \f(CW\*(C`undef\*(C'\fR. +.PP +See \s-1MAPPING\s0, below, for more information on how \s-1JSON\s0 values are mapped to +Perl. +.SH "HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER" +.IX Header "HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER" +This section supposes that your perl version is 5.8 or later. +.PP +If you know a \s-1JSON\s0 text from an outer world \- a network, a file content, and so on, +is encoded in \s-1UTF\-8\s0, you should use \f(CW\*(C`decode_json\*(C'\fR or \f(CW\*(C`JSON\*(C'\fR module object +with \f(CW\*(C`utf8\*(C'\fR enable. And the decoded result will contain \s-1UNICODE\s0 characters. +.PP +.Vb 4 +\& # from network +\& my $json = JSON\->new\->utf8; +\& my $json_text = CGI\->new\->param( \*(Aqjson_data\*(Aq ); +\& my $perl_scalar = $json\->decode( $json_text ); +\& +\& # from file content +\& local $/; +\& open( my $fh, \*(Aq<\*(Aq, \*(Aqjson.data\*(Aq ); +\& $json_text = <$fh>; +\& $perl_scalar = decode_json( $json_text ); +.Ve +.PP +If an outer data is not encoded in \s-1UTF\-8\s0, firstly you should \f(CW\*(C`decode\*(C'\fR it. +.PP +.Vb 5 +\& use Encode; +\& local $/; +\& open( my $fh, \*(Aq<\*(Aq, \*(Aqjson.data\*(Aq ); +\& my $encoding = \*(Aqcp932\*(Aq; +\& my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE +\& +\& # or you can write the below code. +\& # +\& # open( my $fh, "<:encoding($encoding)", \*(Aqjson.data\*(Aq ); +\& # $unicode_json_text = <$fh>; +.Ve +.PP +In this case, \f(CW$unicode_json_text\fR is of course \s-1UNICODE\s0 string. +So you \fBcannot\fR use \f(CW\*(C`decode_json\*(C'\fR nor \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +Instead of them, you use \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR disable or \f(CW\*(C`from_json\*(C'\fR. +.PP +.Vb 3 +\& $perl_scalar = $json\->utf8(0)\->decode( $unicode_json_text ); +\& # or +\& $perl_scalar = from_json( $unicode_json_text ); +.Ve +.PP +Or \f(CW\*(C`encode \*(Aqutf8\*(Aq\*(C'\fR and \f(CW\*(C`decode_json\*(C'\fR: +.PP +.Vb 2 +\& $perl_scalar = decode_json( encode( \*(Aqutf8\*(Aq, $unicode_json_text ) ); +\& # this way is not efficient. +.Ve +.PP +And now, you want to convert your \f(CW$perl_scalar\fR into \s-1JSON\s0 data and +send it to an outer world \- a network or a file content, and so on. +.PP +Your data usually contains \s-1UNICODE\s0 strings and you want the converted data to be encoded +in \s-1UTF\-8\s0, you should use \f(CW\*(C`encode_json\*(C'\fR or \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +.PP +.Vb 3 +\& print encode_json( $perl_scalar ); # to a network? file? or display? +\& # or +\& print $json\->utf8\->encode( $perl_scalar ); +.Ve +.PP +If \f(CW$perl_scalar\fR does not contain \s-1UNICODE\s0 but \f(CW$encoding\fR\-encoded strings +for some reason, then its characters are regarded as \fBlatin1\fR for perl +(because it does not concern with your \f(CW$encoding\fR). +You \fBcannot\fR use \f(CW\*(C`encode_json\*(C'\fR nor \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +Instead of them, you use \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR disable or \f(CW\*(C`to_json\*(C'\fR. +Note that the resulted text is a \s-1UNICODE\s0 string but no problem to print it. +.PP +.Vb 6 +\& # $perl_scalar contains $encoding encoded string values +\& $unicode_json_text = $json\->utf8(0)\->encode( $perl_scalar ); +\& # or +\& $unicode_json_text = to_json( $perl_scalar ); +\& # $unicode_json_text consists of characters less than 0x100 +\& print $unicode_json_text; +.Ve +.PP +Or \f(CW\*(C`decode $encoding\*(C'\fR all string values and \f(CW\*(C`encode_json\*(C'\fR: +.PP +.Vb 3 +\& $perl_scalar\->{ foo } = decode( $encoding, $perl_scalar\->{ foo } ); +\& # ... do it to each string values, then encode_json +\& $json_text = encode_json( $perl_scalar ); +.Ve +.PP +This method is a proper way but probably not efficient. +.PP +See to Encode, perluniintro. +.SH "COMMON OBJECT-ORIENTED INTERFACE" +.IX Header "COMMON OBJECT-ORIENTED INTERFACE" +.SS "new" +.IX Subsection "new" +.Vb 1 +\& $json = JSON\->new +.Ve +.PP +Returns a new \f(CW\*(C`JSON\*(C'\fR object inherited from either \s-1JSON::XS\s0 or \s-1JSON::PP\s0 +that can be used to de/encode \s-1JSON\s0 strings. +.PP +All boolean flags described below are by default \fIdisabled\fR. +.PP +The mutators for flags all return the \s-1JSON\s0 object again and thus calls can +be chained: +.PP +.Vb 2 +\& my $json = JSON\->new\->utf8\->space_after\->encode({a => [1,2]}) +\& => {"a": [1, 2]} +.Ve +.SS "ascii" +.IX Subsection "ascii" +.Vb 1 +\& $json = $json\->ascii([$enable]) +\& +\& $enabled = $json\->get_ascii +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \euXXXX or a double \euHHHH\euLLLLL escape sequence, as per \s-1RFC4627\s0. +.PP +If \f(CW$enable\fR is false, then the encode method will not escape Unicode characters unless +required by the \s-1JSON\s0 syntax or other flags. This results in a faster and more compact format. +.PP +This feature depends on the used Perl version and environment. +.PP +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R" in \s-1JSON::PP\s0 if the backend is \s-1PP\s0. +.PP +.Vb 2 +\& JSON\->new\->ascii(1)\->encode([chr 0x10401]) +\& => ["\eud801\eudc01"] +.Ve +.SS "latin1" +.IX Subsection "latin1" +.Vb 1 +\& $json = $json\->latin1([$enable]) +\& +\& $enabled = $json\->get_latin1 +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will encode the resulting \s-1JSON\s0 +text as latin1 (or iso\-8859\-1), escaping any characters outside the code range 0..255. +.PP +If \f(CW$enable\fR is false, then the encode method will not escape Unicode characters +unless required by the \s-1JSON\s0 syntax or other flags. +.PP +.Vb 2 +\& JSON\->new\->latin1\->encode (["\ex{89}\ex{abc}"] +\& => ["\ex{89}\e\eu0abc"] # (perl syntax, U+abc escaped, U+89 not) +.Ve +.SS "utf8" +.IX Subsection "utf8" +.Vb 1 +\& $json = $json\->utf8([$enable]) +\& +\& $enabled = $json\->get_utf8 +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will encode the \s-1JSON\s0 result +into \s-1UTF\-8\s0, as required by many protocols, while the decode method expects to be handled +an UTF\-8\-encoded string. Please note that UTF\-8\-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. +.PP +In future versions, enabling this option might enable autodetection of the \s-1UTF\-16\s0 and \s-1UTF\-32\s0 +encoding families, as described in \s-1RFC4627\s0. +.PP +If \f(CW$enable\fR is false, then the encode method will return the \s-1JSON\s0 string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to \s-1UTF\-8\s0 or \s-1UTF\-16\s0) needs to be done yourself, e.g. using the Encode module. +.PP +Example, output UTF\-16BE\-encoded \s-1JSON:\s0 +.PP +.Vb 2 +\& use Encode; +\& $jsontext = encode "UTF\-16BE", JSON::XS\->new\->encode ($object); +.Ve +.PP +Example, decode UTF\-32LE\-encoded \s-1JSON:\s0 +.PP +.Vb 2 +\& use Encode; +\& $object = JSON::XS\->new\->decode (decode "UTF\-32LE", $jsontext); +.Ve +.PP +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R" in \s-1JSON::PP\s0 if the backend is \s-1PP\s0. +.SS "pretty" +.IX Subsection "pretty" +.Vb 1 +\& $json = $json\->pretty([$enable]) +.Ve +.PP +This enables (or disables) all of the \f(CW\*(C`indent\*(C'\fR, \f(CW\*(C`space_before\*(C'\fR and +\&\f(CW\*(C`space_after\*(C'\fR (and in the future possibly more) flags in one call to +generate the most readable (or most compact) form possible. +.PP +Equivalent to: +.PP +.Vb 1 +\& $json\->indent\->space_before\->space_after +.Ve +.PP +The indent space length is three and \s-1JSON::XS\s0 cannot change the indent +space length. +.SS "indent" +.IX Subsection "indent" +.Vb 1 +\& $json = $json\->indent([$enable]) +\& +\& $enabled = $json\->get_indent +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will use a multiline +format as output, putting every array member or object/hash key-value pair +into its own line, identifying them properly. +.PP +If \f(CW$enable\fR is false, no newlines or indenting will be produced, and the +resulting \s-1JSON\s0 text is guaranteed not to contain any \f(CW\*(C`newlines\*(C'\fR. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +The indent space length is three. +With \s-1JSON::PP\s0, you can also access \f(CW\*(C`indent_length\*(C'\fR to change indent space length. +.SS "space_before" +.IX Subsection "space_before" +.Vb 1 +\& $json = $json\->space_before([$enable]) +\& +\& $enabled = $json\->get_space_before +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will add an extra +optional space before the \f(CW\*(C`:\*(C'\fR separating keys from values in \s-1JSON\s0 objects. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will not add any extra +space at those places. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +Example, space_before enabled, space_after and indent disabled: +.PP +.Vb 1 +\& {"key" :"value"} +.Ve +.SS "space_after" +.IX Subsection "space_after" +.Vb 1 +\& $json = $json\->space_after([$enable]) +\& +\& $enabled = $json\->get_space_after +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will add an extra +optional space after the \f(CW\*(C`:\*(C'\fR separating keys from values in \s-1JSON\s0 objects +and extra whitespace after the \f(CW\*(C`,\*(C'\fR separating key-value pairs and array +members. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will not add any extra +space at those places. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +Example, space_before and indent disabled, space_after enabled: +.PP +.Vb 1 +\& {"key": "value"} +.Ve +.SS "relaxed" +.IX Subsection "relaxed" +.Vb 1 +\& $json = $json\->relaxed([$enable]) +\& +\& $enabled = $json\->get_relaxed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept some +extensions to normal \s-1JSON\s0 syntax (see below). \f(CW\*(C`encode\*(C'\fR will not be +affected in anyway. \fIBe aware that this option makes you accept invalid +\&\s-1JSON\s0 texts as if they were valid!\fR. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) +.PP +If \f(CW$enable\fR is false (the default), then \f(CW\*(C`decode\*(C'\fR will only accept +valid \s-1JSON\s0 texts. +.PP +Currently accepted extensions are: +.IP "\(bu" 4 +list items can have an end-comma +.Sp +\&\s-1JSON\s0 \fIseparates\fR array elements and key-value pairs with commas. This +can be annoying if you write \s-1JSON\s0 texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: +.Sp +.Vb 8 +\& [ +\& 1, +\& 2, <\- this comma not normally allowed +\& ] +\& { +\& "k1": "v1", +\& "k2": "v2", <\- this comma not normally allowed +\& } +.Ve +.IP "\(bu" 4 +shell-style '#'\-comments +.Sp +Whenever \s-1JSON\s0 allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. +.Sp +.Vb 4 +\& [ +\& 1, # this comment not allowed in JSON +\& # neither this one... +\& ] +.Ve +.SS "canonical" +.IX Subsection "canonical" +.Vb 1 +\& $json = $json\->canonical([$enable]) +\& +\& $enabled = $json\->get_canonical +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will output \s-1JSON\s0 objects +by sorting their keys. This is adding a comparatively high overhead. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). +.PP +This option is useful if you want the same data structure to be encoded as +the same \s-1JSON\s0 text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.SS "allow_nonref" +.IX Subsection "allow_nonref" +.Vb 1 +\& $json = $json\->allow_nonref([$enable]) +\& +\& $enabled = $json\->get_allow_nonref +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method can convert a +non-reference into its corresponding string, number or null \s-1JSON\s0 value, +which is an extension to \s-1RFC4627\s0. Likewise, \f(CW\*(C`decode\*(C'\fR will accept those \s-1JSON\s0 +values instead of croaking. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will croak if it isn't +passed an arrayref or hashref, as \s-1JSON\s0 texts must either be an object +or array. Likewise, \f(CW\*(C`decode\*(C'\fR will croak if given something that is not a +\&\s-1JSON\s0 object or array. +.PP +.Vb 2 +\& JSON\->new\->allow_nonref\->encode ("Hello, World!") +\& => "Hello, World!" +.Ve +.SS "allow_unknown" +.IX Subsection "allow_unknown" +.Vb 1 +\& $json = $json\->allow_unknown ([$enable]) +\& +\& $enabled = $json\->get_allow_unknown +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \*(L"encode\*(R" will *not* throw an +exception when it encounters values it cannot represent in \s-1JSON\s0 (for +example, filehandles) but instead will encode a \s-1JSON\s0 \*(L"null\*(R" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. +.PP +If \f(CW$enable\fR is false (the default), then \*(L"encode\*(R" will throw an +exception when it encounters anything it cannot encode as \s-1JSON\s0. +.PP +This option does not affect \*(L"decode\*(R" in any way, and it is +recommended to leave it off unless you know your communications +partner. +.SS "allow_blessed" +.IX Subsection "allow_blessed" +.Vb 1 +\& $json = $json\->allow_blessed([$enable]) +\& +\& $enabled = $json\->get_allow_blessed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will not +barf when it encounters a blessed reference. Instead, the value of the +\&\fBconvert_blessed\fR option will decide whether \f(CW\*(C`null\*(C'\fR (\f(CW\*(C`convert_blessed\*(C'\fR +disabled or no \f(CW\*(C`TO_JSON\*(C'\fR method found) or a representation of the +object (\f(CW\*(C`convert_blessed\*(C'\fR enabled and \f(CW\*(C`TO_JSON\*(C'\fR method found) is being +encoded. Has no effect on \f(CW\*(C`decode\*(C'\fR. +.PP +If \f(CW$enable\fR is false (the default), then \f(CW\*(C`encode\*(C'\fR will throw an +exception when it encounters a blessed object. +.SS "convert_blessed" +.IX Subsection "convert_blessed" +.Vb 1 +\& $json = $json\->convert_blessed([$enable]) +\& +\& $enabled = $json\->get_convert_blessed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`encode\*(C'\fR, upon encountering a +blessed object, will check for the availability of the \f(CW\*(C`TO_JSON\*(C'\fR method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +\&\f(CW\*(C`TO_JSON\*(C'\fR method is found, the value of \f(CW\*(C`allow_blessed\*(C'\fR will decide what +to do. +.PP +The \f(CW\*(C`TO_JSON\*(C'\fR method may safely call die if it wants. If \f(CW\*(C`TO_JSON\*(C'\fR +returns other blessed objects, those will be handled in the same +way. \f(CW\*(C`TO_JSON\*(C'\fR must take care of not causing an endless recursion cycle +(== crash) in this case. The name of \f(CW\*(C`TO_JSON\*(C'\fR was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the \f(CW\*(C`to_json\*(C'\fR +function or method. +.PP +This setting does not yet influence \f(CW\*(C`decode\*(C'\fR in any way. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`allow_blessed\*(C'\fR setting will decide what +to do when a blessed object is found. +.IP "convert_blessed_universally mode" 4 +.IX Item "convert_blessed_universally mode" +If use \f(CW\*(C`JSON\*(C'\fR with \f(CW\*(C`\-convert_blessed_universally\*(C'\fR, the \f(CW\*(C`UNIVERSAL::TO_JSON\*(C'\fR +subroutine is defined as the below code: +.Sp +.Vb 7 +\& *UNIVERSAL::TO_JSON = sub { +\& my $b_obj = B::svref_2object( $_[0] ); +\& return $b_obj\->isa(\*(AqB::HV\*(Aq) ? { %{ $_[0] } } +\& : $b_obj\->isa(\*(AqB::AV\*(Aq) ? [ @{ $_[0] } ] +\& : undef +\& ; +\& } +.Ve +.Sp +This will cause that \f(CW\*(C`encode\*(C'\fR method converts simple blessed objects into +\&\s-1JSON\s0 objects as non-blessed object. +.Sp +.Vb 2 +\& JSON \-convert_blessed_universally; +\& $json\->allow_blessed\->convert_blessed\->encode( $blessed_object ) +.Ve +.Sp +This feature is experimental and may be removed in the future. +.SS "filter_json_object" +.IX Subsection "filter_json_object" +.Vb 1 +\& $json = $json\->filter_json_object([$coderef]) +.Ve +.PP +When \f(CW$coderef\fR is specified, it will be called from \f(CW\*(C`decode\*(C'\fR each +time it decodes a \s-1JSON\s0 object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(\s-1NOTE:\s0 \fInot\fR \f(CW\*(C`undef\*(C'\fR, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. +.PP +When \f(CW$coderef\fR is omitted or undefined, any existing callback will +be removed and \f(CW\*(C`decode\*(C'\fR will not change the deserialised hash in any +way. +.PP +Example, convert all \s-1JSON\s0 objects into the integer 5: +.PP +.Vb 6 +\& my $js = JSON\->new\->filter_json_object (sub { 5 }); +\& # returns [5] +\& $js\->decode (\*(Aq[{}]\*(Aq); # the given subroutine takes a hash reference. +\& # throw an exception because allow_nonref is not enabled +\& # so a lone 5 is not allowed. +\& $js\->decode (\*(Aq{"a":1, "b":2}\*(Aq); +.Ve +.SS "filter_json_single_key_object" +.IX Subsection "filter_json_single_key_object" +.Vb 1 +\& $json = $json\->filter_json_single_key_object($key [=> $coderef]) +.Ve +.PP +Works remotely similar to \f(CW\*(C`filter_json_object\*(C'\fR, but is only called for +\&\s-1JSON\s0 objects having a single key named \f(CW$key\fR. +.PP +This \f(CW$coderef\fR is called before the one specified via +\&\f(CW\*(C`filter_json_object\*(C'\fR, if any. It gets passed the single value in the \s-1JSON\s0 +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even \f(CW\*(C`undef\*(C'\fR but the empty list), +the callback from \f(CW\*(C`filter_json_object\*(C'\fR will be called next, as if no +single-key callback were specified. +.PP +If \f(CW$coderef\fR is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. +.PP +As this callback gets called less often then the \f(CW\*(C`filter_json_object\*(C'\fR +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key \s-1JSON\s0 objects are as close to the type-tagged value concept +as \s-1JSON\s0 gets (it's basically an \s-1ID/VALUE\s0 tuple). Of course, \s-1JSON\s0 does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. +.PP +Typical names for the single object key are \f(CW\*(C`_\|_class_whatever_\|_\*(C'\fR, or +\&\f(CW\*(C`$_\|_dollars_are_rarely_used_\|_$\*(C'\fR or \f(CW\*(C`}ugly_brace_placement\*(C'\fR, or even +things like \f(CW\*(C`_\|_class_md5sum(classname)_\|_\*(C'\fR, to reduce the risk of clashing +with real hashes. +.PP +Example, decode \s-1JSON\s0 objects of the form \f(CW\*(C`{ "_\|_widget_\|_" => <id> }\*(C'\fR +into the corresponding \f(CW$WIDGET{<id>}\fR object: +.PP +.Vb 7 +\& # return whatever is in $WIDGET{5}: +\& JSON +\& \->new +\& \->filter_json_single_key_object (_\|_widget_\|_ => sub { +\& $WIDGET{ $_[0] } +\& }) +\& \->decode (\*(Aq{"_\|_widget_\|_": 5\*(Aq) +\& +\& # this can be used with a TO_JSON method in some "widget" class +\& # for serialisation to json: +\& sub WidgetBase::TO_JSON { +\& my ($self) = @_; +\& +\& unless ($self\->{id}) { +\& $self\->{id} = ..get..some..id..; +\& $WIDGET{$self\->{id}} = $self; +\& } +\& +\& { _\|_widget_\|_ => $self\->{id} } +\& } +.Ve +.SS "shrink" +.IX Subsection "shrink" +.Vb 1 +\& $json = $json\->shrink([$enable]) +\& +\& $enabled = $json\->get_shrink +.Ve +.PP +With \s-1JSON::XS\s0, this flag resizes strings generated by either +\&\f(CW\*(C`encode\*(C'\fR or \f(CW\*(C`decode\*(C'\fR to their minimum size possible. This can save +memory when your \s-1JSON\s0 texts are either very very long or you have many +short strings. It will also try to downgrade any strings to octet-form +if possible: perl stores strings internally either in an encoding called +UTF-X or in octet-form. The latter cannot store everything but uses less +space in general (and some buggy Perl or C code might even rely on that +internal representation being used). +.PP +With \s-1JSON::PP\s0, it is noop about resizing strings but tries +\&\f(CW\*(C`utf8::downgrade\*(C'\fR to the returned string by \f(CW\*(C`encode\*(C'\fR. See to utf8. +.PP +See to \*(L"OBJECT-ORIENTED \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0 and \*(L"\s-1METHODS\s0\*(R" in \s-1JSON::PP\s0. +.SS "max_depth" +.IX Subsection "max_depth" +.Vb 1 +\& $json = $json\->max_depth([$maximum_nesting_depth]) +\& +\& $max_depth = $json\->get_max_depth +.Ve +.PP +Sets the maximum nesting level (default \f(CW512\fR) accepted while encoding +or decoding. If a higher nesting level is detected in \s-1JSON\s0 text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. +.PP +Nesting level is defined by number of hash\- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of \f(CW\*(C`{\*(C'\fR or \f(CW\*(C`[\*(C'\fR +characters without their matching closing parenthesis crossed to reach a +given character in a string. +.PP +If no argument is given, the highest possible setting will be used, which +is rarely useful. +.PP +Note that nesting is implemented by recursion in C. The default value has +been chosen to be as large as typical operating systems allow without +crashing. (\s-1JSON::XS\s0) +.PP +With \s-1JSON::PP\s0 as the backend, when a large value (100 or more) was set and +it de/encodes a deep nested object/text, it may raise a warning +\&'Deep recursion on subroutine' at the perl runtime phase. +.PP +See \*(L"\s-1SECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0 for more info on why this is useful. +.SS "max_size" +.IX Subsection "max_size" +.Vb 1 +\& $json = $json\->max_size([$maximum_string_size]) +\& +\& $max_size = $json\->get_max_size +.Ve +.PP +Set the maximum length a \s-1JSON\s0 text may have (in bytes) where decoding is +being attempted. The default is \f(CW0\fR, meaning no limit. When \f(CW\*(C`decode\*(C'\fR +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on \f(CW\*(C`encode\*(C'\fR (yet). +.PP +If no argument is given, the limit check will be deactivated (same as when +\&\f(CW0\fR is specified). +.PP +See \*(L"\s-1SECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0, below, for more info on why this is useful. +.SS "encode" +.IX Subsection "encode" +.Vb 1 +\& $json_text = $json\->encode($perl_scalar) +.Ve +.PP +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its \s-1JSON\s0 representation. Simple scalars will be +converted into \s-1JSON\s0 string or number sequences, while references to arrays +become \s-1JSON\s0 arrays and references to hashes become \s-1JSON\s0 objects. Undefined +Perl values (e.g. \f(CW\*(C`undef\*(C'\fR) become \s-1JSON\s0 \f(CW\*(C`null\*(C'\fR values. +References to the integers \f(CW0\fR and \f(CW1\fR are converted into \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR. +.SS "decode" +.IX Subsection "decode" +.Vb 1 +\& $perl_scalar = $json\->decode($json_text) +.Ve +.PP +The opposite of \f(CW\*(C`encode\*(C'\fR: expects a \s-1JSON\s0 text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. +.PP +\&\s-1JSON\s0 numbers and strings become simple Perl scalars. \s-1JSON\s0 arrays become +Perl arrayrefs and \s-1JSON\s0 objects become Perl hashrefs. \f(CW\*(C`true\*(C'\fR becomes +\&\f(CW1\fR (\f(CW\*(C`JSON::true\*(C'\fR), \f(CW\*(C`false\*(C'\fR becomes \f(CW0\fR (\f(CW\*(C`JSON::false\*(C'\fR) and +\&\f(CW\*(C`null\*(C'\fR becomes \f(CW\*(C`undef\*(C'\fR. +.SS "decode_prefix" +.IX Subsection "decode_prefix" +.Vb 1 +\& ($perl_scalar, $characters) = $json\->decode_prefix($json_text) +.Ve +.PP +This works like the \f(CW\*(C`decode\*(C'\fR method, but instead of raising an exception +when there is trailing garbage after the first \s-1JSON\s0 object, it will +silently stop parsing there and return the number of characters consumed +so far. +.PP +.Vb 2 +\& JSON\->new\->decode_prefix ("[1] the tail") +\& => ([], 3) +.Ve +.PP +See to \*(L"OBJECT-ORIENTED \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0 +.SS "property" +.IX Subsection "property" +.Vb 1 +\& $boolean = $json\->property($property_name) +.Ve +.PP +Returns a boolean value about above some properties. +.PP +The available properties are \f(CW\*(C`ascii\*(C'\fR, \f(CW\*(C`latin1\*(C'\fR, \f(CW\*(C`utf8\*(C'\fR, +\&\f(CW\*(C`indent\*(C'\fR,\f(CW\*(C`space_before\*(C'\fR, \f(CW\*(C`space_after\*(C'\fR, \f(CW\*(C`relaxed\*(C'\fR, \f(CW\*(C`canonical\*(C'\fR, +\&\f(CW\*(C`allow_nonref\*(C'\fR, \f(CW\*(C`allow_unknown\*(C'\fR, \f(CW\*(C`allow_blessed\*(C'\fR, \f(CW\*(C`convert_blessed\*(C'\fR, +\&\f(CW\*(C`shrink\*(C'\fR, \f(CW\*(C`max_depth\*(C'\fR and \f(CW\*(C`max_size\*(C'\fR. +.PP +.Vb 5 +\& $boolean = $json\->property(\*(Aqutf8\*(Aq); +\& => 0 +\& $json\->utf8; +\& $boolean = $json\->property(\*(Aqutf8\*(Aq); +\& => 1 +.Ve +.PP +Sets the property with a given boolean value. +.PP +.Vb 1 +\& $json = $json\->property($property_name => $boolean); +.Ve +.PP +With no argument, it returns all the above properties as a hash reference. +.PP +.Vb 1 +\& $flag_hashref = $json\->property(); +.Ve +.SH "INCREMENTAL PARSING" +.IX Header "INCREMENTAL PARSING" +Most of this section are copied and modified from \*(L"\s-1INCREMENTAL\s0 \s-1PARSING\s0\*(R" in \s-1JSON::XS\s0. +.PP +In some cases, there is the need for incremental parsing of \s-1JSON\s0 texts. +This module does allow you to parse a \s-1JSON\s0 stream incrementally. +It does so by accumulating text until it has a full \s-1JSON\s0 object, which +it then can decode. This process is similar to using \f(CW\*(C`decode_prefix\*(C'\fR +to see if a full \s-1JSON\s0 object is available, but is much more efficient +(and can be implemented with a minimum of method calls). +.PP +The backend module will only attempt to parse the \s-1JSON\s0 text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid \s-1JSON\s0 text has been seen. This means you need +to set resource limits (e.g. \f(CW\*(C`max_size\*(C'\fR) to ensure the parser will stop +parsing in the presence if syntax errors. +.PP +The following methods implement this incremental parser. +.SS "incr_parse" +.IX Subsection "incr_parse" +.Vb 1 +\& $json\->incr_parse( [$string] ) # void context +\& +\& $obj_or_undef = $json\->incr_parse( [$string] ) # scalar context +\& +\& @obj_or_empty = $json\->incr_parse( [$string] ) # list context +.Ve +.PP +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). +.PP +If \f(CW$string\fR is given, then this string is appended to the already +existing \s-1JSON\s0 fragment stored in the \f(CW$json\fR object. +.PP +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. +.PP +If the method is called in scalar context, then it will try to extract +exactly \fIone\fR \s-1JSON\s0 object. If that is successful, it will return this +object, otherwise it will return \f(CW\*(C`undef\*(C'\fR. If there is a parse error, +this method will croak just as \f(CW\*(C`decode\*(C'\fR would do (one can then use +\&\f(CW\*(C`incr_skip\*(C'\fR to skip the erroneous part). This is the most common way of +using the method. +.PP +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the \s-1JSON\s0 +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed \s-1JSON\s0 texts will be +lost. +.PP +Example: Parse some \s-1JSON\s0 arrays/objects in a given string and return them. +.PP +.Vb 1 +\& my @objs = JSON\->new\->incr_parse ("[5][7][1,2]"); +.Ve +.SS "incr_text" +.IX Subsection "incr_text" +.Vb 1 +\& $lvalue_string = $json\->incr_text +.Ve +.PP +This method returns the currently stored \s-1JSON\s0 fragment as an lvalue, that +is, you can manipulate it. This \fIonly\fR works when a preceding call to +\&\f(CW\*(C`incr_parse\*(C'\fR in \fIscalar context\fR successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it \fIwill\fR fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. +.PP +This function is useful in two cases: a) finding the trailing text after a +\&\s-1JSON\s0 object or b) parsing multiple \s-1JSON\s0 objects separated by non-JSON text +(such as commas). +.PP +.Vb 1 +\& $json\->incr_text =~ s/\es*,\es*//; +.Ve +.PP +In Perl 5.005, \f(CW\*(C`lvalue\*(C'\fR attribute is not available. +You must write codes like the below: +.PP +.Vb 3 +\& $string = $json\->incr_text; +\& $string =~ s/\es*,\es*//; +\& $json\->incr_text( $string ); +.Ve +.SS "incr_skip" +.IX Subsection "incr_skip" +.Vb 1 +\& $json\->incr_skip +.Ve +.PP +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after \f(CW\*(C`incr_parse\*(C'\fR +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. +.SS "incr_reset" +.IX Subsection "incr_reset" +.Vb 1 +\& $json\->incr_reset +.Ve +.PP +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. +.PP +This is useful if you want to repeatedly parse \s-1JSON\s0 objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. +.PP +See to \*(L"\s-1INCREMENTAL\s0 \s-1PARSING\s0\*(R" in \s-1JSON::XS\s0 for examples. +.SH "JSON::PP SUPPORT METHODS" +.IX Header "JSON::PP SUPPORT METHODS" +The below methods are \s-1JSON::PP\s0 own methods, so when \f(CW\*(C`JSON\*(C'\fR works +with \s-1JSON::PP\s0 (i.e. the created object is a \s-1JSON::PP\s0 object), available. +See to \*(L"\s-1JSON::PP\s0 \s-1OWN\s0 \s-1METHODS\s0\*(R" in \s-1JSON::PP\s0 in detail. +.PP +If you use \f(CW\*(C`JSON\*(C'\fR with additional \f(CW\*(C`\-support_by_pp\*(C'\fR, some methods +are available even with \s-1JSON::XS\s0. See to \*(L"\s-1USE\s0 \s-1PP\s0 \s-1FEATURES\s0 \s-1EVEN\s0 \s-1THOUGH\s0 \s-1XS\s0 \s-1BACKEND\s0\*(R". +.PP +.Vb 1 +\& BEING { $ENV{PERL_JSON_BACKEND} = \*(AqJSON::XS\*(Aq } +\& +\& use JSON \-support_by_pp; +\& +\& my $json = JSON\->new; +\& $json\->allow_nonref\->escape_slash\->encode("/"); +\& +\& # functional interfaces too. +\& print to_json(["/"], {escape_slash => 1}); +\& print from_json(\*(Aq["foo"]\*(Aq, {utf8 => 1}); +.Ve +.PP +If you do not want to all functions but \f(CW\*(C`\-support_by_pp\*(C'\fR, +use \f(CW\*(C`\-no_export\*(C'\fR. +.PP +.Vb 2 +\& use JSON \-support_by_pp, \-no_export; +\& # functional interfaces are not exported. +.Ve +.SS "allow_singlequote" +.IX Subsection "allow_singlequote" +.Vb 1 +\& $json = $json\->allow_singlequote([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept +any \s-1JSON\s0 strings quoted by single quotations that are invalid \s-1JSON\s0 +format. +.PP +.Vb 3 +\& $json\->allow_singlequote\->decode({"foo":\*(Aqbar\*(Aq}); +\& $json\->allow_singlequote\->decode({\*(Aqfoo\*(Aq:"bar"}); +\& $json\->allow_singlequote\->decode({\*(Aqfoo\*(Aq:\*(Aqbar\*(Aq}); +.Ve +.PP +As same as the \f(CW\*(C`relaxed\*(C'\fR option, this option may be used to parse +application-specific files written by humans. +.SS "allow_barekey" +.IX Subsection "allow_barekey" +.Vb 1 +\& $json = $json\->allow_barekey([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept +bare keys of \s-1JSON\s0 object that are invalid \s-1JSON\s0 format. +.PP +As same as the \f(CW\*(C`relaxed\*(C'\fR option, this option may be used to parse +application-specific files written by humans. +.PP +.Vb 1 +\& $json\->allow_barekey\->decode(\*(Aq{foo:"bar"}\*(Aq); +.Ve +.SS "allow_bignum" +.IX Subsection "allow_bignum" +.Vb 1 +\& $json = $json\->allow_bignum([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will convert +the big integer Perl cannot handle as integer into a Math::BigInt +object and convert a floating number (any) into a Math::BigFloat. +.PP +On the contrary, \f(CW\*(C`encode\*(C'\fR converts \f(CW\*(C`Math::BigInt\*(C'\fR objects and \f(CW\*(C`Math::BigFloat\*(C'\fR +objects into \s-1JSON\s0 numbers with \f(CW\*(C`allow_blessed\*(C'\fR enable. +.PP +.Vb 4 +\& $json\->allow_nonref\->allow_blessed\->allow_bignum; +\& $bigfloat = $json\->decode(\*(Aq2.000000000000000000000000001\*(Aq); +\& print $json\->encode($bigfloat); +\& # => 2.000000000000000000000000001 +.Ve +.PP +See to \s-1MAPPING\s0 about the conversion of \s-1JSON\s0 number. +.SS "loose" +.IX Subsection "loose" +.Vb 1 +\& $json = $json\->loose([$enable]) +.Ve +.PP +The unescaped [\ex00\-\ex1f\ex22\ex2f\ex5c] strings are invalid in \s-1JSON\s0 strings +and the module doesn't allow to \f(CW\*(C`decode\*(C'\fR to these (except for \ex2f). +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept these +unescaped strings. +.PP +.Vb 2 +\& $json\->loose\->decode(qq|["abc +\& def"]|); +.Ve +.PP +See to \*(L"\s-1JSON::PP\s0 \s-1OWN\s0 \s-1METHODS\s0\*(R" in \s-1JSON::PP\s0. +.SS "escape_slash" +.IX Subsection "escape_slash" +.Vb 1 +\& $json = $json\->escape_slash([$enable]) +.Ve +.PP +According to \s-1JSON\s0 Grammar, \fIslash\fR (U+002F) is escaped. But by default +\&\s-1JSON\s0 backend modules encode strings without escaping slash. +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`encode\*(C'\fR will escape slashes. +.SS "indent_length" +.IX Subsection "indent_length" +.Vb 1 +\& $json = $json\->indent_length($length) +.Ve +.PP +With \s-1JSON::XS\s0, The indent space length is 3 and cannot be changed. +With \s-1JSON::PP\s0, it sets the indent space length with the given \f(CW$length\fR. +The default is 3. The acceptable range is 0 to 15. +.SS "sort_by" +.IX Subsection "sort_by" +.Vb 2 +\& $json = $json\->sort_by($function_name) +\& $json = $json\->sort_by($subroutine_ref) +.Ve +.PP +If \f(CW$function_name\fR or \f(CW$subroutine_ref\fR are set, its sort routine are used. +.PP +.Vb 2 +\& $js = $pc\->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })\->encode($obj); +\& # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); +\& +\& $js = $pc\->sort_by(\*(Aqown_sort\*(Aq)\->encode($obj); +\& # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); +\& +\& sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } +.Ve +.PP +As the sorting routine runs in the \s-1JSON::PP\s0 scope, the given +subroutine name and the special variables \f(CW$a\fR, \f(CW$b\fR will begin +with '\s-1JSON::PP::\s0'. +.PP +If \f(CW$integer\fR is set, then the effect is same as \f(CW\*(C`canonical\*(C'\fR on. +.PP +See to \*(L"\s-1JSON::PP\s0 \s-1OWN\s0 \s-1METHODS\s0\*(R" in \s-1JSON::PP\s0. +.SH "MAPPING" +.IX Header "MAPPING" +This section is copied from \s-1JSON::XS\s0 and modified to \f(CW\*(C`JSON\*(C'\fR. +\&\s-1JSON::XS\s0 and \s-1JSON::PP\s0 mapping mechanisms are almost equivalent. +.PP +See to \*(L"\s-1MAPPING\s0\*(R" in \s-1JSON::XS\s0. +.SS "\s-1JSON\s0 \-> \s-1PERL\s0" +.IX Subsection "JSON -> PERL" +.IP "object" 4 +.IX Item "object" +A \s-1JSON\s0 object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (\s-1JSON\s0 does not preserver object key ordering itself). +.IP "array" 4 +.IX Item "array" +A \s-1JSON\s0 array becomes a reference to an array in Perl. +.IP "string" 4 +.IX Item "string" +A \s-1JSON\s0 string becomes a string scalar in Perl \- Unicode codepoints in \s-1JSON\s0 +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. +.IP "number" 4 +.IX Item "number" +A \s-1JSON\s0 number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. +.Sp +If the number consists of digits only, \f(CW\*(C`JSON\*(C'\fR will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the \s-1JSON\s0 number will be +re-encoded to a \s-1JSON\s0 string). +.Sp +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the \s-1JSON\s0 number will still be re-encoded as a \s-1JSON\s0 number). +.Sp +Note that precision is not accuracy \- binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, \f(CW\*(C`JSON\*(C'\fR only guarantees precision up to but not including +the least significant bit. +.Sp +If the backend is \s-1JSON::PP\s0 and \f(CW\*(C`allow_bignum\*(C'\fR is enable, the big integers +and the numeric can be optionally converted into Math::BigInt and +Math::BigFloat objects. +.IP "true, false" 4 +.IX Item "true, false" +These \s-1JSON\s0 atoms become \f(CW\*(C`JSON::true\*(C'\fR and \f(CW\*(C`JSON::false\*(C'\fR, +respectively. They are overloaded to act almost exactly like the numbers +\&\f(CW1\fR and \f(CW0\fR. You can check whether a scalar is a \s-1JSON\s0 boolean by using +the \f(CW\*(C`JSON::is_bool\*(C'\fR function. +.Sp +If \f(CW\*(C`JSON::true\*(C'\fR and \f(CW\*(C`JSON::false\*(C'\fR are used as strings or compared as strings, +they represent as \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR respectively. +.Sp +.Vb 4 +\& print JSON::true . "\en"; +\& => true +\& print JSON::true + 1; +\& => 1 +\& +\& ok(JSON::true eq \*(Aqtrue\*(Aq); +\& ok(JSON::true eq \*(Aq1\*(Aq); +\& ok(JSON::true == 1); +.Ve +.Sp +\&\f(CW\*(C`JSON\*(C'\fR will install these missing overloading features to the backend modules. +.IP "null" 4 +.IX Item "null" +A \s-1JSON\s0 null atom becomes \f(CW\*(C`undef\*(C'\fR in Perl. +.Sp +\&\f(CW\*(C`JSON::null\*(C'\fR returns \f(CW\*(C`undef\*(C'\fR. +.SS "\s-1PERL\s0 \-> \s-1JSON\s0" +.IX Subsection "PERL -> JSON" +The mapping from Perl to \s-1JSON\s0 is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which \s-1JSON\s0 type is meant by +a Perl value. +.IP "hash references" 4 +.IX Item "hash references" +Perl hash references become \s-1JSON\s0 objects. As there is no inherent ordering +in hash keys (or \s-1JSON\s0 objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. \f(CW\*(C`JSON\*(C'\fR +optionally sort the hash keys (determined by the \fIcanonical\fR flag), so +the same data structure will serialise to the same \s-1JSON\s0 text (given same +settings and version of \s-1JSON::XS\s0), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some \s-1JSON\s0 text +against another for equality. +.Sp +In future, the ordered object feature will be added to \s-1JSON::PP\s0 using \f(CW\*(C`tie\*(C'\fR mechanism. +.IP "array references" 4 +.IX Item "array references" +Perl array references become \s-1JSON\s0 arrays. +.IP "other references" 4 +.IX Item "other references" +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers \f(CW0\fR and +\&\f(CW1\fR, which get turned into \f(CW\*(C`false\*(C'\fR and \f(CW\*(C`true\*(C'\fR atoms in \s-1JSON\s0. You can +also use \f(CW\*(C`JSON::false\*(C'\fR and \f(CW\*(C`JSON::true\*(C'\fR to improve readability. +.Sp +.Vb 1 +\& to_json [\e0,JSON::true] # yields [false,true] +.Ve +.IP "JSON::true, JSON::false, JSON::null" 4 +.IX Item "JSON::true, JSON::false, JSON::null" +These special values become \s-1JSON\s0 true and \s-1JSON\s0 false values, +respectively. You can also use \f(CW\*(C`\e1\*(C'\fR and \f(CW\*(C`\e0\*(C'\fR directly if you want. +.Sp +JSON::null returns \f(CW\*(C`undef\*(C'\fR. +.IP "blessed objects" 4 +.IX Item "blessed objects" +Blessed objects are not directly representable in \s-1JSON\s0. See the +\&\f(CW\*(C`allow_blessed\*(C'\fR and \f(CW\*(C`convert_blessed\*(C'\fR methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. +.Sp +With \f(CW\*(C`convert_blessed_universally\*(C'\fR mode, \f(CW\*(C`encode\*(C'\fR converts blessed +hash references or blessed array references (contains other blessed references) +into \s-1JSON\s0 members and arrays. +.Sp +.Vb 2 +\& use JSON \-convert_blessed_universally; +\& JSON\->new\->allow_blessed\->convert_blessed\->encode( $blessed_object ); +.Ve +.Sp +See to convert_blessed. +.IP "simple scalars" 4 +.IX Item "simple scalars" +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: \s-1JSON::XS\s0 and \s-1JSON::PP\s0 will encode undefined scalars as +\&\s-1JSON\s0 \f(CW\*(C`null\*(C'\fR values, scalars that have last been used in a string context +before encoding as \s-1JSON\s0 strings, and anything else as number value: +.Sp +.Vb 4 +\& # dump as number +\& encode_json [2] # yields [2] +\& encode_json [\-3.0e17] # yields [\-3e+17] +\& my $value = 5; encode_json [$value] # yields [5] +\& +\& # used as string, so dump as string +\& print $value; +\& encode_json [$value] # yields ["5"] +\& +\& # undef becomes null +\& encode_json [undef] # yields [null] +.Ve +.Sp +You can force the type to be a string by stringifying it: +.Sp +.Vb 4 +\& my $x = 3.1; # some variable containing a number +\& "$x"; # stringified +\& $x .= ""; # another, more awkward way to stringify +\& print $x; # perl does it for you, too, quite often +.Ve +.Sp +You can force the type to be a number by numifying it: +.Sp +.Vb 3 +\& my $x = "3"; # some variable containing a string +\& $x += 0; # numify it, ensuring it will be dumped as a number +\& $x *= 1; # same thing, the choice is yours. +.Ve +.Sp +You can not currently force the type in other, less obscure, ways. +.Sp +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's \- these cannot be represented in \s-1JSON\s0, and it is an +error to pass those in. +.IP "Big Number" 4 +.IX Item "Big Number" +If the backend is \s-1JSON::PP\s0 and \f(CW\*(C`allow_bignum\*(C'\fR is enable, +\&\f(CW\*(C`encode\*(C'\fR converts \f(CW\*(C`Math::BigInt\*(C'\fR objects and \f(CW\*(C`Math::BigFloat\*(C'\fR +objects into \s-1JSON\s0 numbers. +.SH "JSON and ECMAscript" +.IX Header "JSON and ECMAscript" +See to \*(L"\s-1JSON\s0 and ECMAscript\*(R" in \s-1JSON::XS\s0. +.SH "JSON and YAML" +.IX Header "JSON and YAML" +\&\s-1JSON\s0 is not a subset of \s-1YAML\s0. +See to \*(L"\s-1JSON\s0 and \s-1YAML\s0\*(R" in \s-1JSON::XS\s0. +.SH "BACKEND MODULE DECISION" +.IX Header "BACKEND MODULE DECISION" +When you use \f(CW\*(C`JSON\*(C'\fR, \f(CW\*(C`JSON\*(C'\fR tries to \f(CW\*(C`use\*(C'\fR \s-1JSON::XS\s0. If this call failed, it will +\&\f(CW\*(C`uses\*(C'\fR \s-1JSON::PP\s0. The required \s-1JSON::XS\s0 version is \fI2.2\fR or later. +.PP +The \f(CW\*(C`JSON\*(C'\fR constructor method returns an object inherited from the backend module, +and \s-1JSON::XS\s0 object is a blessed scalar reference while \s-1JSON::PP\s0 is a blessed hash +reference. +.PP +So, your program should not depend on the backend module, especially +returned objects should not be modified. +.PP +.Vb 2 +\& my $json = JSON\->new; # XS or PP? +\& $json\->{stash} = \*(Aqthis is xs object\*(Aq; # this code may raise an error! +.Ve +.PP +To check the backend module, there are some methods \- \f(CW\*(C`backend\*(C'\fR, \f(CW\*(C`is_pp\*(C'\fR and \f(CW\*(C`is_xs\*(C'\fR. +.PP +.Vb 1 +\& JSON\->backend; # \*(AqJSON::XS\*(Aq or \*(AqJSON::PP\*(Aq +\& +\& JSON\->backend\->is_pp: # 0 or 1 +\& +\& JSON\->backend\->is_xs: # 1 or 0 +\& +\& $json\->is_xs; # 1 or 0 +\& +\& $json\->is_pp; # 0 or 1 +.Ve +.PP +If you set an environment variable \f(CW\*(C`PERL_JSON_BACKEND\*(C'\fR, the calling action will be changed. +.IP "\s-1PERL_JSON_BACKEND\s0 = 0 or \s-1PERL_JSON_BACKEND\s0 = '\s-1JSON::PP\s0'" 4 +.IX Item "PERL_JSON_BACKEND = 0 or PERL_JSON_BACKEND = 'JSON::PP'" +Always use \s-1JSON::PP\s0 +.IP "\s-1PERL_JSON_BACKEND\s0 == 1 or \s-1PERL_JSON_BACKEND\s0 = '\s-1JSON::XS\s0,JSON::PP'" 4 +.IX Item "PERL_JSON_BACKEND == 1 or PERL_JSON_BACKEND = 'JSON::XS,JSON::PP'" +(The default) Use compiled \s-1JSON::XS\s0 if it is properly compiled & installed, +otherwise use \s-1JSON::PP\s0. +.IP "\s-1PERL_JSON_BACKEND\s0 == 2 or \s-1PERL_JSON_BACKEND\s0 = '\s-1JSON::XS\s0'" 4 +.IX Item "PERL_JSON_BACKEND == 2 or PERL_JSON_BACKEND = 'JSON::XS'" +Always use compiled \s-1JSON::XS\s0, die if it isn't properly compiled & installed. +.IP "\s-1PERL_JSON_BACKEND\s0 = 'JSON::backportPP'" 4 +.IX Item "PERL_JSON_BACKEND = 'JSON::backportPP'" +Always use JSON::backportPP. +JSON::backportPP is \s-1JSON::PP\s0 back port module. +\&\f(CW\*(C`JSON\*(C'\fR includes JSON::backportPP instead of \s-1JSON::PP\s0. +.PP +These ideas come from DBI::PurePerl mechanism. +.PP +example: +.PP +.Vb 2 +\& BEGIN { $ENV{PERL_JSON_BACKEND} = \*(AqJSON::PP\*(Aq } +\& use JSON; # always uses JSON::PP +.Ve +.PP +In future, it may be able to specify another module. +.SH "USE PP FEATURES EVEN THOUGH XS BACKEND" +.IX Header "USE PP FEATURES EVEN THOUGH XS BACKEND" +Many methods are available with either \s-1JSON::XS\s0 or \s-1JSON::PP\s0 and +when the backend module is \s-1JSON::XS\s0, if any \s-1JSON::PP\s0 specific (i.e. \s-1JSON::XS\s0 unsupported) +method is called, it will \f(CW\*(C`warn\*(C'\fR and be noop. +.PP +But If you \f(CW\*(C`use\*(C'\fR \f(CW\*(C`JSON\*(C'\fR passing the optional string \f(CW\*(C`\-support_by_pp\*(C'\fR, +it makes a part of those unsupported methods available. +This feature is achieved by using \s-1JSON::PP\s0 in \f(CW\*(C`de/encode\*(C'\fR. +.PP +.Vb 4 +\& BEGIN { $ENV{PERL_JSON_BACKEND} = 2 } # with JSON::XS +\& use JSON \-support_by_pp; +\& my $json = JSON\->new; +\& $json\->allow_nonref\->escape_slash\->encode("/"); +.Ve +.PP +At this time, the returned object is a \f(CW\*(C`JSON::Backend::XS::Supportable\*(C'\fR +object (re-blessed \s-1XS\s0 object), and by checking \s-1JSON::XS\s0 unsupported flags +in de/encoding, can support some unsupported methods \- \f(CW\*(C`loose\*(C'\fR, \f(CW\*(C`allow_bignum\*(C'\fR, +\&\f(CW\*(C`allow_barekey\*(C'\fR, \f(CW\*(C`allow_singlequote\*(C'\fR, \f(CW\*(C`escape_slash\*(C'\fR and \f(CW\*(C`indent_length\*(C'\fR. +.PP +When any unsupported methods are not enable, \f(CW\*(C`XS de/encode\*(C'\fR will be +used as is. The switch is achieved by changing the symbolic tables. +.PP +\&\f(CW\*(C`\-support_by_pp\*(C'\fR is effective only when the backend module is \s-1JSON::XS\s0 +and it makes the de/encoding speed down a bit. +.PP +See to \*(L"\s-1JSON::PP\s0 \s-1SUPPORT\s0 \s-1METHODS\s0\*(R". +.SH "INCOMPATIBLE CHANGES TO OLD VERSION" +.IX Header "INCOMPATIBLE CHANGES TO OLD VERSION" +There are big incompatibility between new version (2.00) and old (1.xx). +If you use old \f(CW\*(C`JSON\*(C'\fR 1.xx in your code, please check it. +.PP +See to \*(L"Transition ways from 1.xx to 2.xx.\*(R" +.IP "jsonToObj and objToJson are obsoleted." 4 +.IX Item "jsonToObj and objToJson are obsoleted." +Non Perl-style name \f(CW\*(C`jsonToObj\*(C'\fR and \f(CW\*(C`objToJson\*(C'\fR are obsoleted +(but not yet deleted from the source). +If you use these functions in your code, please replace them +with \f(CW\*(C`from_json\*(C'\fR and \f(CW\*(C`to_json\*(C'\fR. +.IP "Global variables are no longer available." 4 +.IX Item "Global variables are no longer available." +\&\f(CW\*(C`JSON\*(C'\fR class variables \- \f(CW$JSON::AUTOCONVERT\fR, \f(CW$JSON::BareKey\fR, etc... +\&\- are not available any longer. +Instead, various features can be used through object methods. +.IP "Package JSON::Converter and JSON::Parser are deleted." 4 +.IX Item "Package JSON::Converter and JSON::Parser are deleted." +Now \f(CW\*(C`JSON\*(C'\fR bundles with \s-1JSON::PP\s0 which can handle \s-1JSON\s0 more properly than them. +.IP "Package JSON::NotString is deleted." 4 +.IX Item "Package JSON::NotString is deleted." +There was \f(CW\*(C`JSON::NotString\*(C'\fR class which represents \s-1JSON\s0 value \f(CW\*(C`true\*(C'\fR, \f(CW\*(C`false\*(C'\fR, \f(CW\*(C`null\*(C'\fR +and numbers. It was deleted and replaced by \f(CW\*(C`JSON::Boolean\*(C'\fR. +.Sp +\&\f(CW\*(C`JSON::Boolean\*(C'\fR represents \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR. +.Sp +\&\f(CW\*(C`JSON::Boolean\*(C'\fR does not represent \f(CW\*(C`null\*(C'\fR. +.Sp +\&\f(CW\*(C`JSON::null\*(C'\fR returns \f(CW\*(C`undef\*(C'\fR. +.Sp +\&\f(CW\*(C`JSON\*(C'\fR makes JSON::XS::Boolean and JSON::PP::Boolean is-a relation +to JSON::Boolean. +.IP "function JSON::Number is obsoleted." 4 +.IX Item "function JSON::Number is obsoleted." +\&\f(CW\*(C`JSON::Number\*(C'\fR is now needless because \s-1JSON::XS\s0 and \s-1JSON::PP\s0 have +round-trip integrity. +.IP "\s-1JSONRPC\s0 modules are deleted." 4 +.IX Item "JSONRPC modules are deleted." +Perl implementation of JSON-RPC protocol \- \f(CW\*(C`JSONRPC \*(C'\fR, \f(CW\*(C`JSONRPC::Transport::HTTP\*(C'\fR +and \f(CW\*(C`Apache::JSONRPC \*(C'\fR are deleted in this distribution. +Instead of them, there is \s-1JSON::RPC\s0 which supports JSON-RPC protocol version 1.1. +.SS "Transition ways from 1.xx to 2.xx." +.IX Subsection "Transition ways from 1.xx to 2.xx." +You should set \f(CW\*(C`suport_by_pp\*(C'\fR mode firstly, because +it is always successful for the below codes even with \s-1JSON::XS\s0. +.PP +.Vb 1 +\& use JSON \-support_by_pp; +.Ve +.IP "Exported jsonToObj (simple)" 4 +.IX Item "Exported jsonToObj (simple)" +.Vb 1 +\& from_json($json_text); +.Ve +.IP "Exported objToJson (simple)" 4 +.IX Item "Exported objToJson (simple)" +.Vb 1 +\& to_json($perl_scalar); +.Ve +.IP "Exported jsonToObj (advanced)" 4 +.IX Item "Exported jsonToObj (advanced)" +.Vb 2 +\& $flags = {allow_barekey => 1, allow_singlequote => 1}; +\& from_json($json_text, $flags); +.Ve +.Sp +equivalent to: +.Sp +.Vb 3 +\& $JSON::BareKey = 1; +\& $JSON::QuotApos = 1; +\& jsonToObj($json_text); +.Ve +.IP "Exported objToJson (advanced)" 4 +.IX Item "Exported objToJson (advanced)" +.Vb 2 +\& $flags = {allow_blessed => 1, allow_barekey => 1}; +\& to_json($perl_scalar, $flags); +.Ve +.Sp +equivalent to: +.Sp +.Vb 2 +\& $JSON::BareKey = 1; +\& objToJson($perl_scalar); +.Ve +.IP "jsonToObj as object method" 4 +.IX Item "jsonToObj as object method" +.Vb 1 +\& $json\->decode($json_text); +.Ve +.IP "objToJson as object method" 4 +.IX Item "objToJson as object method" +.Vb 1 +\& $json\->encode($perl_scalar); +.Ve +.IP "new method with parameters" 4 +.IX Item "new method with parameters" +The \f(CW\*(C`new\*(C'\fR method in 2.x takes any parameters no longer. +You can set parameters instead; +.Sp +.Vb 1 +\& $json = JSON\->new\->pretty; +.Ve +.ie n .IP "$JSON::Pretty, $JSON::Indent, $JSON::Delimiter" 4 +.el .IP "\f(CW$JSON::Pretty\fR, \f(CW$JSON::Indent\fR, \f(CW$JSON::Delimiter\fR" 4 +.IX Item "$JSON::Pretty, $JSON::Indent, $JSON::Delimiter" +If \f(CW\*(C`indent\*(C'\fR is enable, that means \f(CW$JSON::Pretty\fR flag set. And +\&\f(CW$JSON::Delimiter\fR was substituted by \f(CW\*(C`space_before\*(C'\fR and \f(CW\*(C`space_after\*(C'\fR. +In conclusion: +.Sp +.Vb 1 +\& $json\->indent\->space_before\->space_after; +.Ve +.Sp +Equivalent to: +.Sp +.Vb 1 +\& $json\->pretty; +.Ve +.Sp +To change indent length, use \f(CW\*(C`indent_length\*(C'\fR. +.Sp +(Only with \s-1JSON::PP\s0, if \f(CW\*(C`\-support_by_pp\*(C'\fR is not used.) +.Sp +.Vb 1 +\& $json\->pretty\->indent_length(2)\->encode($perl_scalar); +.Ve +.ie n .IP "$JSON::BareKey" 4 +.el .IP "\f(CW$JSON::BareKey\fR" 4 +.IX Item "$JSON::BareKey" +(Only with \s-1JSON::PP\s0, if \f(CW\*(C`\-support_by_pp\*(C'\fR is not used.) +.Sp +.Vb 1 +\& $json\->allow_barekey\->decode($json_text) +.Ve +.ie n .IP "$JSON::ConvBlessed" 4 +.el .IP "\f(CW$JSON::ConvBlessed\fR" 4 +.IX Item "$JSON::ConvBlessed" +use \f(CW\*(C`\-convert_blessed_universally\*(C'\fR. See to convert_blessed. +.ie n .IP "$JSON::QuotApos" 4 +.el .IP "\f(CW$JSON::QuotApos\fR" 4 +.IX Item "$JSON::QuotApos" +(Only with \s-1JSON::PP\s0, if \f(CW\*(C`\-support_by_pp\*(C'\fR is not used.) +.Sp +.Vb 1 +\& $json\->allow_singlequote\->decode($json_text) +.Ve +.ie n .IP "$JSON::SingleQuote" 4 +.el .IP "\f(CW$JSON::SingleQuote\fR" 4 +.IX Item "$JSON::SingleQuote" +Disable. \f(CW\*(C`JSON\*(C'\fR does not make such a invalid \s-1JSON\s0 string any longer. +.ie n .IP "$JSON::KeySort" 4 +.el .IP "\f(CW$JSON::KeySort\fR" 4 +.IX Item "$JSON::KeySort" +.Vb 1 +\& $json\->canonical\->encode($perl_scalar) +.Ve +.Sp +This is the ascii sort. +.Sp +If you want to use with your own sort routine, check the \f(CW\*(C`sort_by\*(C'\fR method. +.Sp +(Only with \s-1JSON::PP\s0, even if \f(CW\*(C`\-support_by_pp\*(C'\fR is used currently.) +.Sp +.Vb 1 +\& $json\->sort_by($sort_routine_ref)\->encode($perl_scalar) +\& +\& $json\->sort_by(sub { $JSON::PP::a <=> $JSON::PP::b })\->encode($perl_scalar) +.Ve +.Sp +Can't access \f(CW$a\fR and \f(CW$b\fR but \f(CW$JSON::PP::a\fR and \f(CW$JSON::PP::b\fR. +.ie n .IP "$JSON::SkipInvalid" 4 +.el .IP "\f(CW$JSON::SkipInvalid\fR" 4 +.IX Item "$JSON::SkipInvalid" +.Vb 1 +\& $json\->allow_unknown +.Ve +.ie n .IP "$JSON::AUTOCONVERT" 4 +.el .IP "\f(CW$JSON::AUTOCONVERT\fR" 4 +.IX Item "$JSON::AUTOCONVERT" +Needless. \f(CW\*(C`JSON\*(C'\fR backend modules have the round-trip integrity. +.ie n .IP "$JSON::UTF8" 4 +.el .IP "\f(CW$JSON::UTF8\fR" 4 +.IX Item "$JSON::UTF8" +Needless because \f(CW\*(C`JSON\*(C'\fR (\s-1JSON::XS/JSON::PP\s0) sets +the \s-1UTF8\s0 flag on properly. +.Sp +.Vb 1 +\& # With UTF8\-flagged strings +\& +\& $json\->allow_nonref; +\& $str = chr(1000); # UTF8\-flagged +\& +\& $json_text = $json\->utf8(0)\->encode($str); +\& utf8::is_utf8($json_text); +\& # true +\& $json_text = $json\->utf8(1)\->encode($str); +\& utf8::is_utf8($json_text); +\& # false +\& +\& $str = \*(Aq"\*(Aq . chr(1000) . \*(Aq"\*(Aq; # UTF8\-flagged +\& +\& $perl_scalar = $json\->utf8(0)\->decode($str); +\& utf8::is_utf8($perl_scalar); +\& # true +\& $perl_scalar = $json\->utf8(1)\->decode($str); +\& # died because of \*(AqWide character in subroutine\*(Aq +.Ve +.Sp +See to \*(L"A \s-1FEW\s0 \s-1NOTES\s0 \s-1ON\s0 \s-1UNICODE\s0 \s-1AND\s0 \s-1PERL\s0\*(R" in \s-1JSON::XS\s0. +.ie n .IP "$JSON::UnMapping" 4 +.el .IP "\f(CW$JSON::UnMapping\fR" 4 +.IX Item "$JSON::UnMapping" +Disable. See to \s-1MAPPING\s0. +.ie n .IP "$JSON::SelfConvert" 4 +.el .IP "\f(CW$JSON::SelfConvert\fR" 4 +.IX Item "$JSON::SelfConvert" +This option was deleted. +Instead of it, if a given blessed object has the \f(CW\*(C`TO_JSON\*(C'\fR method, +\&\f(CW\*(C`TO_JSON\*(C'\fR will be executed with \f(CW\*(C`convert_blessed\*(C'\fR. +.Sp +.Vb 2 +\& $json\->convert_blessed\->encode($blessed_hashref_or_arrayref) +\& # if need, call allow_blessed +.Ve +.Sp +Note that it was \f(CW\*(C`toJson\*(C'\fR in old version, but now not \f(CW\*(C`toJson\*(C'\fR but \f(CW\*(C`TO_JSON\*(C'\fR. +.SH "TODO" +.IX Header "TODO" +.IP "example programs" 4 +.IX Item "example programs" +.SH "THREADS" +.IX Header "THREADS" +No test with \s-1JSON::PP\s0. If with \s-1JSON::XS\s0, See to \*(L"\s-1THREADS\s0\*(R" in \s-1JSON::XS\s0. +.SH "BUGS" +.IX Header "BUGS" +Please report bugs relevant to \f(CW\*(C`JSON\*(C'\fR to <makamaka[at]cpan.org>. +.SH "SEE ALSO" +.IX Header "SEE ALSO" +Most of the document is copied and modified from \s-1JSON::XS\s0 doc. +.PP +\&\s-1JSON::XS\s0, \s-1JSON::PP\s0 +.PP +\&\f(CW\*(C`RFC4627\*(C'\fR(<http://www.ietf.org/rfc/rfc4627.txt>) +.SH "AUTHOR" +.IX Header "AUTHOR" +Makamaka Hannyaharamitu, <makamaka[at]cpan.org> +.PP +\&\s-1JSON::XS\s0 was written by Marc Lehmann <schmorp[at]schmorp.de> +.PP +The release of this new version owes to the courtesy of Marc Lehmann. +.SH "COPYRIGHT AND LICENSE" +.IX Header "COPYRIGHT AND LICENSE" +Copyright 2005\-2013 by Makamaka Hannyaharamitu +.PP +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. diff --git a/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP.3pm b/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP.3pm new file mode 100644 index 0000000..60015fb --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP.3pm @@ -0,0 +1,1379 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON::backportPP 3pm" +.TH JSON::backportPP 3pm "2013-05-23" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON::PP \- JSON::XS compatible pure\-Perl module. +.SH "SYNOPSIS" +.IX Header "SYNOPSIS" +.Vb 1 +\& use JSON::PP; +\& +\& # exported functions, they croak on error +\& # and expect/generate UTF\-8 +\& +\& $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; +\& $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; +\& +\& # OO\-interface +\& +\& $coder = JSON::PP\->new\->ascii\->pretty\->allow_nonref; +\& +\& $json_text = $json\->encode( $perl_scalar ); +\& $perl_scalar = $json\->decode( $json_text ); +\& +\& $pretty_printed = $json\->pretty\->encode( $perl_scalar ); # pretty\-printing +\& +\& # Note that JSON version 2.0 and above will automatically use +\& # JSON::XS or JSON::PP, so you should be able to just: +\& +\& use JSON; +.Ve +.SH "VERSION" +.IX Header "VERSION" +.Vb 1 +\& 2.27200 +.Ve +.PP +\&\s-1JSON::XS\s0 2.27 (~2.30) compatible. +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +This module is \s-1JSON::XS\s0 compatible pure Perl module. +(Perl 5.8 or later is recommended) +.PP +\&\s-1JSON::XS\s0 is the fastest and most proper \s-1JSON\s0 module on \s-1CPAN\s0. +It is written by Marc Lehmann in C, so must be compiled and +installed in the used environment. +.PP +\&\s-1JSON::PP\s0 is a pure-Perl module and has compatibility to \s-1JSON::XS\s0. +.SS "\s-1FEATURES\s0" +.IX Subsection "FEATURES" +.IP "\(bu" 4 +correct unicode handling +.Sp +This module knows how to handle Unicode (depending on Perl version). +.Sp +See to \*(L"A \s-1FEW\s0 \s-1NOTES\s0 \s-1ON\s0 \s-1UNICODE\s0 \s-1AND\s0 \s-1PERL\s0\*(R" in \s-1JSON::XS\s0 and +\&\*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R". +.IP "\(bu" 4 +round-trip integrity +.Sp +When you serialise a perl data structure using only data types +supported by \s-1JSON\s0 and Perl, the deserialised data structure is +identical on the Perl level. (e.g. the string \*(L"2.0\*(R" doesn't suddenly +become \*(L"2\*(R" just because it looks like a number). There \fIare\fR minor +exceptions to this, read the \s-1MAPPING\s0 section below to learn about +those. +.IP "\(bu" 4 +strict checking of \s-1JSON\s0 correctness +.Sp +There is no guessing, no generating of illegal \s-1JSON\s0 texts by default, +and only \s-1JSON\s0 is accepted as input by default (the latter is a +security feature). But when some options are set, loose checking +features are available. +.SH "FUNCTIONAL INTERFACE" +.IX Header "FUNCTIONAL INTERFACE" +Some documents are copied and modified from \*(L"\s-1FUNCTIONAL\s0 \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0. +.SS "encode_json" +.IX Subsection "encode_json" +.Vb 1 +\& $json_text = encode_json $perl_scalar +.Ve +.PP +Converts the given Perl data structure to a \s-1UTF\-8\s0 encoded, binary string. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $json_text = JSON::PP\->new\->utf8\->encode($perl_scalar) +.Ve +.SS "decode_json" +.IX Subsection "decode_json" +.Vb 1 +\& $perl_scalar = decode_json $json_text +.Ve +.PP +The opposite of \f(CW\*(C`encode_json\*(C'\fR: expects an \s-1UTF\-8\s0 (binary) string and tries +to parse that as an \s-1UTF\-8\s0 encoded \s-1JSON\s0 text, returning the resulting +reference. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $perl_scalar = JSON::PP\->new\->utf8\->decode($json_text) +.Ve +.SS "JSON::PP::is_bool" +.IX Subsection "JSON::PP::is_bool" +.Vb 1 +\& $is_boolean = JSON::PP::is_bool($scalar) +.Ve +.PP +Returns true if the passed scalar represents either JSON::PP::true or +JSON::PP::false, two constants that act like \f(CW1\fR and \f(CW0\fR respectively +and are also used to represent \s-1JSON\s0 \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR in Perl strings. +.SS "JSON::PP::true" +.IX Subsection "JSON::PP::true" +Returns \s-1JSON\s0 true value which is blessed object. +It \f(CW\*(C`isa\*(C'\fR JSON::PP::Boolean object. +.SS "JSON::PP::false" +.IX Subsection "JSON::PP::false" +Returns \s-1JSON\s0 false value which is blessed object. +It \f(CW\*(C`isa\*(C'\fR JSON::PP::Boolean object. +.SS "JSON::PP::null" +.IX Subsection "JSON::PP::null" +Returns \f(CW\*(C`undef\*(C'\fR. +.PP +See \s-1MAPPING\s0, below, for more information on how \s-1JSON\s0 values are mapped to +Perl. +.SH "HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER" +.IX Header "HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER" +This section supposes that your perl version is 5.8 or later. +.PP +If you know a \s-1JSON\s0 text from an outer world \- a network, a file content, and so on, +is encoded in \s-1UTF\-8\s0, you should use \f(CW\*(C`decode_json\*(C'\fR or \f(CW\*(C`JSON\*(C'\fR module object +with \f(CW\*(C`utf8\*(C'\fR enable. And the decoded result will contain \s-1UNICODE\s0 characters. +.PP +.Vb 4 +\& # from network +\& my $json = JSON::PP\->new\->utf8; +\& my $json_text = CGI\->new\->param( \*(Aqjson_data\*(Aq ); +\& my $perl_scalar = $json\->decode( $json_text ); +\& +\& # from file content +\& local $/; +\& open( my $fh, \*(Aq<\*(Aq, \*(Aqjson.data\*(Aq ); +\& $json_text = <$fh>; +\& $perl_scalar = decode_json( $json_text ); +.Ve +.PP +If an outer data is not encoded in \s-1UTF\-8\s0, firstly you should \f(CW\*(C`decode\*(C'\fR it. +.PP +.Vb 5 +\& use Encode; +\& local $/; +\& open( my $fh, \*(Aq<\*(Aq, \*(Aqjson.data\*(Aq ); +\& my $encoding = \*(Aqcp932\*(Aq; +\& my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE +\& +\& # or you can write the below code. +\& # +\& # open( my $fh, "<:encoding($encoding)", \*(Aqjson.data\*(Aq ); +\& # $unicode_json_text = <$fh>; +.Ve +.PP +In this case, \f(CW$unicode_json_text\fR is of course \s-1UNICODE\s0 string. +So you \fBcannot\fR use \f(CW\*(C`decode_json\*(C'\fR nor \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +Instead of them, you use \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR disable. +.PP +.Vb 1 +\& $perl_scalar = $json\->utf8(0)\->decode( $unicode_json_text ); +.Ve +.PP +Or \f(CW\*(C`encode \*(Aqutf8\*(Aq\*(C'\fR and \f(CW\*(C`decode_json\*(C'\fR: +.PP +.Vb 2 +\& $perl_scalar = decode_json( encode( \*(Aqutf8\*(Aq, $unicode_json_text ) ); +\& # this way is not efficient. +.Ve +.PP +And now, you want to convert your \f(CW$perl_scalar\fR into \s-1JSON\s0 data and +send it to an outer world \- a network or a file content, and so on. +.PP +Your data usually contains \s-1UNICODE\s0 strings and you want the converted data to be encoded +in \s-1UTF\-8\s0, you should use \f(CW\*(C`encode_json\*(C'\fR or \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +.PP +.Vb 3 +\& print encode_json( $perl_scalar ); # to a network? file? or display? +\& # or +\& print $json\->utf8\->encode( $perl_scalar ); +.Ve +.PP +If \f(CW$perl_scalar\fR does not contain \s-1UNICODE\s0 but \f(CW$encoding\fR\-encoded strings +for some reason, then its characters are regarded as \fBlatin1\fR for perl +(because it does not concern with your \f(CW$encoding\fR). +You \fBcannot\fR use \f(CW\*(C`encode_json\*(C'\fR nor \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +Instead of them, you use \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR disable. +Note that the resulted text is a \s-1UNICODE\s0 string but no problem to print it. +.PP +.Vb 4 +\& # $perl_scalar contains $encoding encoded string values +\& $unicode_json_text = $json\->utf8(0)\->encode( $perl_scalar ); +\& # $unicode_json_text consists of characters less than 0x100 +\& print $unicode_json_text; +.Ve +.PP +Or \f(CW\*(C`decode $encoding\*(C'\fR all string values and \f(CW\*(C`encode_json\*(C'\fR: +.PP +.Vb 3 +\& $perl_scalar\->{ foo } = decode( $encoding, $perl_scalar\->{ foo } ); +\& # ... do it to each string values, then encode_json +\& $json_text = encode_json( $perl_scalar ); +.Ve +.PP +This method is a proper way but probably not efficient. +.PP +See to Encode, perluniintro. +.SH "METHODS" +.IX Header "METHODS" +Basically, check to \s-1JSON\s0 or \s-1JSON::XS\s0. +.SS "new" +.IX Subsection "new" +.Vb 1 +\& $json = JSON::PP\->new +.Ve +.PP +Returns a new \s-1JSON::PP\s0 object that can be used to de/encode \s-1JSON\s0 +strings. +.PP +All boolean flags described below are by default \fIdisabled\fR. +.PP +The mutators for flags all return the \s-1JSON\s0 object again and thus calls can +be chained: +.PP +.Vb 2 +\& my $json = JSON::PP\->new\->utf8\->space_after\->encode({a => [1,2]}) +\& => {"a": [1, 2]} +.Ve +.SS "ascii" +.IX Subsection "ascii" +.Vb 1 +\& $json = $json\->ascii([$enable]) +\& +\& $enabled = $json\->get_ascii +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \euXXXX or a double \euHHHH\euLLLLL escape sequence, as per \s-1RFC4627\s0. +(See to \*(L"OBJECT-ORIENTED \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0). +.PP +In Perl 5.005, there is no character having high value (more than 255). +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R". +.PP +If \f(CW$enable\fR is false, then the encode method will not escape Unicode characters unless +required by the \s-1JSON\s0 syntax or other flags. This results in a faster and more compact format. +.PP +.Vb 2 +\& JSON::PP\->new\->ascii(1)\->encode([chr 0x10401]) +\& => ["\eud801\eudc01"] +.Ve +.SS "latin1" +.IX Subsection "latin1" +.Vb 1 +\& $json = $json\->latin1([$enable]) +\& +\& $enabled = $json\->get_latin1 +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will encode the resulting \s-1JSON\s0 +text as latin1 (or iso\-8859\-1), escaping any characters outside the code range 0..255. +.PP +If \f(CW$enable\fR is false, then the encode method will not escape Unicode characters +unless required by the \s-1JSON\s0 syntax or other flags. +.PP +.Vb 2 +\& JSON::XS\->new\->latin1\->encode (["\ex{89}\ex{abc}"] +\& => ["\ex{89}\e\eu0abc"] # (perl syntax, U+abc escaped, U+89 not) +.Ve +.PP +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R". +.SS "utf8" +.IX Subsection "utf8" +.Vb 1 +\& $json = $json\->utf8([$enable]) +\& +\& $enabled = $json\->get_utf8 +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will encode the \s-1JSON\s0 result +into \s-1UTF\-8\s0, as required by many protocols, while the decode method expects to be handled +an UTF\-8\-encoded string. Please note that UTF\-8\-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. +.PP +(In Perl 5.005, any character outside the range 0..255 does not exist. +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R".) +.PP +In future versions, enabling this option might enable autodetection of the \s-1UTF\-16\s0 and \s-1UTF\-32\s0 +encoding families, as described in \s-1RFC4627\s0. +.PP +If \f(CW$enable\fR is false, then the encode method will return the \s-1JSON\s0 string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to \s-1UTF\-8\s0 or \s-1UTF\-16\s0) needs to be done yourself, e.g. using the Encode module. +.PP +Example, output UTF\-16BE\-encoded \s-1JSON:\s0 +.PP +.Vb 2 +\& use Encode; +\& $jsontext = encode "UTF\-16BE", JSON::PP\->new\->encode ($object); +.Ve +.PP +Example, decode UTF\-32LE\-encoded \s-1JSON:\s0 +.PP +.Vb 2 +\& use Encode; +\& $object = JSON::PP\->new\->decode (decode "UTF\-32LE", $jsontext); +.Ve +.SS "pretty" +.IX Subsection "pretty" +.Vb 1 +\& $json = $json\->pretty([$enable]) +.Ve +.PP +This enables (or disables) all of the \f(CW\*(C`indent\*(C'\fR, \f(CW\*(C`space_before\*(C'\fR and +\&\f(CW\*(C`space_after\*(C'\fR flags in one call to generate the most readable +(or most compact) form possible. +.PP +Equivalent to: +.PP +.Vb 1 +\& $json\->indent\->space_before\->space_after +.Ve +.SS "indent" +.IX Subsection "indent" +.Vb 1 +\& $json = $json\->indent([$enable]) +\& +\& $enabled = $json\->get_indent +.Ve +.PP +The default indent space length is three. +You can use \f(CW\*(C`indent_length\*(C'\fR to change the length. +.SS "space_before" +.IX Subsection "space_before" +.Vb 1 +\& $json = $json\->space_before([$enable]) +\& +\& $enabled = $json\->get_space_before +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will add an extra +optional space before the \f(CW\*(C`:\*(C'\fR separating keys from values in \s-1JSON\s0 objects. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will not add any extra +space at those places. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +Example, space_before enabled, space_after and indent disabled: +.PP +.Vb 1 +\& {"key" :"value"} +.Ve +.SS "space_after" +.IX Subsection "space_after" +.Vb 1 +\& $json = $json\->space_after([$enable]) +\& +\& $enabled = $json\->get_space_after +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will add an extra +optional space after the \f(CW\*(C`:\*(C'\fR separating keys from values in \s-1JSON\s0 objects +and extra whitespace after the \f(CW\*(C`,\*(C'\fR separating key-value pairs and array +members. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will not add any extra +space at those places. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +Example, space_before and indent disabled, space_after enabled: +.PP +.Vb 1 +\& {"key": "value"} +.Ve +.SS "relaxed" +.IX Subsection "relaxed" +.Vb 1 +\& $json = $json\->relaxed([$enable]) +\& +\& $enabled = $json\->get_relaxed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept some +extensions to normal \s-1JSON\s0 syntax (see below). \f(CW\*(C`encode\*(C'\fR will not be +affected in anyway. \fIBe aware that this option makes you accept invalid +\&\s-1JSON\s0 texts as if they were valid!\fR. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) +.PP +If \f(CW$enable\fR is false (the default), then \f(CW\*(C`decode\*(C'\fR will only accept +valid \s-1JSON\s0 texts. +.PP +Currently accepted extensions are: +.IP "\(bu" 4 +list items can have an end-comma +.Sp +\&\s-1JSON\s0 \fIseparates\fR array elements and key-value pairs with commas. This +can be annoying if you write \s-1JSON\s0 texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: +.Sp +.Vb 8 +\& [ +\& 1, +\& 2, <\- this comma not normally allowed +\& ] +\& { +\& "k1": "v1", +\& "k2": "v2", <\- this comma not normally allowed +\& } +.Ve +.IP "\(bu" 4 +shell-style '#'\-comments +.Sp +Whenever \s-1JSON\s0 allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. +.Sp +.Vb 4 +\& [ +\& 1, # this comment not allowed in JSON +\& # neither this one... +\& ] +.Ve +.SS "canonical" +.IX Subsection "canonical" +.Vb 1 +\& $json = $json\->canonical([$enable]) +\& +\& $enabled = $json\->get_canonical +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will output \s-1JSON\s0 objects +by sorting their keys. This is adding a comparatively high overhead. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). +.PP +This option is useful if you want the same data structure to be encoded as +the same \s-1JSON\s0 text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +If you want your own sorting routine, you can give a code reference +or a subroutine name to \f(CW\*(C`sort_by\*(C'\fR. See to \f(CW\*(C`JSON::PP OWN METHODS\*(C'\fR. +.SS "allow_nonref" +.IX Subsection "allow_nonref" +.Vb 1 +\& $json = $json\->allow_nonref([$enable]) +\& +\& $enabled = $json\->get_allow_nonref +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method can convert a +non-reference into its corresponding string, number or null \s-1JSON\s0 value, +which is an extension to \s-1RFC4627\s0. Likewise, \f(CW\*(C`decode\*(C'\fR will accept those \s-1JSON\s0 +values instead of croaking. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will croak if it isn't +passed an arrayref or hashref, as \s-1JSON\s0 texts must either be an object +or array. Likewise, \f(CW\*(C`decode\*(C'\fR will croak if given something that is not a +\&\s-1JSON\s0 object or array. +.PP +.Vb 2 +\& JSON::PP\->new\->allow_nonref\->encode ("Hello, World!") +\& => "Hello, World!" +.Ve +.SS "allow_unknown" +.IX Subsection "allow_unknown" +.Vb 1 +\& $json = $json\->allow_unknown ([$enable]) +\& +\& $enabled = $json\->get_allow_unknown +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \*(L"encode\*(R" will *not* throw an +exception when it encounters values it cannot represent in \s-1JSON\s0 (for +example, filehandles) but instead will encode a \s-1JSON\s0 \*(L"null\*(R" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. +.PP +If \f(CW$enable\fR is false (the default), then \*(L"encode\*(R" will throw an +exception when it encounters anything it cannot encode as \s-1JSON\s0. +.PP +This option does not affect \*(L"decode\*(R" in any way, and it is +recommended to leave it off unless you know your communications +partner. +.SS "allow_blessed" +.IX Subsection "allow_blessed" +.Vb 1 +\& $json = $json\->allow_blessed([$enable]) +\& +\& $enabled = $json\->get_allow_blessed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will not +barf when it encounters a blessed reference. Instead, the value of the +\&\fBconvert_blessed\fR option will decide whether \f(CW\*(C`null\*(C'\fR (\f(CW\*(C`convert_blessed\*(C'\fR +disabled or no \f(CW\*(C`TO_JSON\*(C'\fR method found) or a representation of the +object (\f(CW\*(C`convert_blessed\*(C'\fR enabled and \f(CW\*(C`TO_JSON\*(C'\fR method found) is being +encoded. Has no effect on \f(CW\*(C`decode\*(C'\fR. +.PP +If \f(CW$enable\fR is false (the default), then \f(CW\*(C`encode\*(C'\fR will throw an +exception when it encounters a blessed object. +.SS "convert_blessed" +.IX Subsection "convert_blessed" +.Vb 1 +\& $json = $json\->convert_blessed([$enable]) +\& +\& $enabled = $json\->get_convert_blessed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`encode\*(C'\fR, upon encountering a +blessed object, will check for the availability of the \f(CW\*(C`TO_JSON\*(C'\fR method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +\&\f(CW\*(C`TO_JSON\*(C'\fR method is found, the value of \f(CW\*(C`allow_blessed\*(C'\fR will decide what +to do. +.PP +The \f(CW\*(C`TO_JSON\*(C'\fR method may safely call die if it wants. If \f(CW\*(C`TO_JSON\*(C'\fR +returns other blessed objects, those will be handled in the same +way. \f(CW\*(C`TO_JSON\*(C'\fR must take care of not causing an endless recursion cycle +(== crash) in this case. The name of \f(CW\*(C`TO_JSON\*(C'\fR was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the \f(CW\*(C`to_json\*(C'\fR +function or method. +.PP +This setting does not yet influence \f(CW\*(C`decode\*(C'\fR in any way. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`allow_blessed\*(C'\fR setting will decide what +to do when a blessed object is found. +.SS "filter_json_object" +.IX Subsection "filter_json_object" +.Vb 1 +\& $json = $json\->filter_json_object([$coderef]) +.Ve +.PP +When \f(CW$coderef\fR is specified, it will be called from \f(CW\*(C`decode\*(C'\fR each +time it decodes a \s-1JSON\s0 object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(\s-1NOTE:\s0 \fInot\fR \f(CW\*(C`undef\*(C'\fR, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. +.PP +When \f(CW$coderef\fR is omitted or undefined, any existing callback will +be removed and \f(CW\*(C`decode\*(C'\fR will not change the deserialised hash in any +way. +.PP +Example, convert all \s-1JSON\s0 objects into the integer 5: +.PP +.Vb 6 +\& my $js = JSON::PP\->new\->filter_json_object (sub { 5 }); +\& # returns [5] +\& $js\->decode (\*(Aq[{}]\*(Aq); # the given subroutine takes a hash reference. +\& # throw an exception because allow_nonref is not enabled +\& # so a lone 5 is not allowed. +\& $js\->decode (\*(Aq{"a":1, "b":2}\*(Aq); +.Ve +.SS "filter_json_single_key_object" +.IX Subsection "filter_json_single_key_object" +.Vb 1 +\& $json = $json\->filter_json_single_key_object($key [=> $coderef]) +.Ve +.PP +Works remotely similar to \f(CW\*(C`filter_json_object\*(C'\fR, but is only called for +\&\s-1JSON\s0 objects having a single key named \f(CW$key\fR. +.PP +This \f(CW$coderef\fR is called before the one specified via +\&\f(CW\*(C`filter_json_object\*(C'\fR, if any. It gets passed the single value in the \s-1JSON\s0 +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even \f(CW\*(C`undef\*(C'\fR but the empty list), +the callback from \f(CW\*(C`filter_json_object\*(C'\fR will be called next, as if no +single-key callback were specified. +.PP +If \f(CW$coderef\fR is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. +.PP +As this callback gets called less often then the \f(CW\*(C`filter_json_object\*(C'\fR +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key \s-1JSON\s0 objects are as close to the type-tagged value concept +as \s-1JSON\s0 gets (it's basically an \s-1ID/VALUE\s0 tuple). Of course, \s-1JSON\s0 does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. +.PP +Typical names for the single object key are \f(CW\*(C`_\|_class_whatever_\|_\*(C'\fR, or +\&\f(CW\*(C`$_\|_dollars_are_rarely_used_\|_$\*(C'\fR or \f(CW\*(C`}ugly_brace_placement\*(C'\fR, or even +things like \f(CW\*(C`_\|_class_md5sum(classname)_\|_\*(C'\fR, to reduce the risk of clashing +with real hashes. +.PP +Example, decode \s-1JSON\s0 objects of the form \f(CW\*(C`{ "_\|_widget_\|_" => <id> }\*(C'\fR +into the corresponding \f(CW$WIDGET{<id>}\fR object: +.PP +.Vb 7 +\& # return whatever is in $WIDGET{5}: +\& JSON::PP +\& \->new +\& \->filter_json_single_key_object (_\|_widget_\|_ => sub { +\& $WIDGET{ $_[0] } +\& }) +\& \->decode (\*(Aq{"_\|_widget_\|_": 5\*(Aq) +\& +\& # this can be used with a TO_JSON method in some "widget" class +\& # for serialisation to json: +\& sub WidgetBase::TO_JSON { +\& my ($self) = @_; +\& +\& unless ($self\->{id}) { +\& $self\->{id} = ..get..some..id..; +\& $WIDGET{$self\->{id}} = $self; +\& } +\& +\& { _\|_widget_\|_ => $self\->{id} } +\& } +.Ve +.SS "shrink" +.IX Subsection "shrink" +.Vb 1 +\& $json = $json\->shrink([$enable]) +\& +\& $enabled = $json\->get_shrink +.Ve +.PP +In \s-1JSON::XS\s0, this flag resizes strings generated by either +\&\f(CW\*(C`encode\*(C'\fR or \f(CW\*(C`decode\*(C'\fR to their minimum size possible. +It will also try to downgrade any strings to octet-form if possible. +.PP +In \s-1JSON::PP\s0, it is noop about resizing strings but tries +\&\f(CW\*(C`utf8::downgrade\*(C'\fR to the returned string by \f(CW\*(C`encode\*(C'\fR. +See to utf8. +.PP +See to \*(L"OBJECT-ORIENTED \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0 +.SS "max_depth" +.IX Subsection "max_depth" +.Vb 1 +\& $json = $json\->max_depth([$maximum_nesting_depth]) +\& +\& $max_depth = $json\->get_max_depth +.Ve +.PP +Sets the maximum nesting level (default \f(CW512\fR) accepted while encoding +or decoding. If a higher nesting level is detected in \s-1JSON\s0 text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. +.PP +Nesting level is defined by number of hash\- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of \f(CW\*(C`{\*(C'\fR or \f(CW\*(C`[\*(C'\fR +characters without their matching closing parenthesis crossed to reach a +given character in a string. +.PP +If no argument is given, the highest possible setting will be used, which +is rarely useful. +.PP +See \*(L"\s-1SSECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0 for more info on why this is useful. +.PP +When a large value (100 or more) was set and it de/encodes a deep nested object/text, +it may raise a warning 'Deep recursion on subroutine' at the perl runtime phase. +.SS "max_size" +.IX Subsection "max_size" +.Vb 1 +\& $json = $json\->max_size([$maximum_string_size]) +\& +\& $max_size = $json\->get_max_size +.Ve +.PP +Set the maximum length a \s-1JSON\s0 text may have (in bytes) where decoding is +being attempted. The default is \f(CW0\fR, meaning no limit. When \f(CW\*(C`decode\*(C'\fR +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on \f(CW\*(C`encode\*(C'\fR (yet). +.PP +If no argument is given, the limit check will be deactivated (same as when +\&\f(CW0\fR is specified). +.PP +See \*(L"\s-1SECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0 for more info on why this is useful. +.SS "encode" +.IX Subsection "encode" +.Vb 1 +\& $json_text = $json\->encode($perl_scalar) +.Ve +.PP +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its \s-1JSON\s0 representation. Simple scalars will be +converted into \s-1JSON\s0 string or number sequences, while references to arrays +become \s-1JSON\s0 arrays and references to hashes become \s-1JSON\s0 objects. Undefined +Perl values (e.g. \f(CW\*(C`undef\*(C'\fR) become \s-1JSON\s0 \f(CW\*(C`null\*(C'\fR values. +References to the integers \f(CW0\fR and \f(CW1\fR are converted into \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR. +.SS "decode" +.IX Subsection "decode" +.Vb 1 +\& $perl_scalar = $json\->decode($json_text) +.Ve +.PP +The opposite of \f(CW\*(C`encode\*(C'\fR: expects a \s-1JSON\s0 text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. +.PP +\&\s-1JSON\s0 numbers and strings become simple Perl scalars. \s-1JSON\s0 arrays become +Perl arrayrefs and \s-1JSON\s0 objects become Perl hashrefs. \f(CW\*(C`true\*(C'\fR becomes +\&\f(CW1\fR (\f(CW\*(C`JSON::true\*(C'\fR), \f(CW\*(C`false\*(C'\fR becomes \f(CW0\fR (\f(CW\*(C`JSON::false\*(C'\fR) and +\&\f(CW\*(C`null\*(C'\fR becomes \f(CW\*(C`undef\*(C'\fR. +.SS "decode_prefix" +.IX Subsection "decode_prefix" +.Vb 1 +\& ($perl_scalar, $characters) = $json\->decode_prefix($json_text) +.Ve +.PP +This works like the \f(CW\*(C`decode\*(C'\fR method, but instead of raising an exception +when there is trailing garbage after the first \s-1JSON\s0 object, it will +silently stop parsing there and return the number of characters consumed +so far. +.PP +.Vb 2 +\& JSON\->new\->decode_prefix ("[1] the tail") +\& => ([], 3) +.Ve +.SH "INCREMENTAL PARSING" +.IX Header "INCREMENTAL PARSING" +Most of this section are copied and modified from \*(L"\s-1INCREMENTAL\s0 \s-1PARSING\s0\*(R" in \s-1JSON::XS\s0. +.PP +In some cases, there is the need for incremental parsing of \s-1JSON\s0 texts. +This module does allow you to parse a \s-1JSON\s0 stream incrementally. +It does so by accumulating text until it has a full \s-1JSON\s0 object, which +it then can decode. This process is similar to using \f(CW\*(C`decode_prefix\*(C'\fR +to see if a full \s-1JSON\s0 object is available, but is much more efficient +(and can be implemented with a minimum of method calls). +.PP +This module will only attempt to parse the \s-1JSON\s0 text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid \s-1JSON\s0 text has been seen. This means you need +to set resource limits (e.g. \f(CW\*(C`max_size\*(C'\fR) to ensure the parser will stop +parsing in the presence if syntax errors. +.PP +The following methods implement this incremental parser. +.SS "incr_parse" +.IX Subsection "incr_parse" +.Vb 1 +\& $json\->incr_parse( [$string] ) # void context +\& +\& $obj_or_undef = $json\->incr_parse( [$string] ) # scalar context +\& +\& @obj_or_empty = $json\->incr_parse( [$string] ) # list context +.Ve +.PP +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). +.PP +If \f(CW$string\fR is given, then this string is appended to the already +existing \s-1JSON\s0 fragment stored in the \f(CW$json\fR object. +.PP +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. +.PP +If the method is called in scalar context, then it will try to extract +exactly \fIone\fR \s-1JSON\s0 object. If that is successful, it will return this +object, otherwise it will return \f(CW\*(C`undef\*(C'\fR. If there is a parse error, +this method will croak just as \f(CW\*(C`decode\*(C'\fR would do (one can then use +\&\f(CW\*(C`incr_skip\*(C'\fR to skip the erroneous part). This is the most common way of +using the method. +.PP +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the \s-1JSON\s0 +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed \s-1JSON\s0 texts will be +lost. +.PP +Example: Parse some \s-1JSON\s0 arrays/objects in a given string and return them. +.PP +.Vb 1 +\& my @objs = JSON\->new\->incr_parse ("[5][7][1,2]"); +.Ve +.SS "incr_text" +.IX Subsection "incr_text" +.Vb 1 +\& $lvalue_string = $json\->incr_text +.Ve +.PP +This method returns the currently stored \s-1JSON\s0 fragment as an lvalue, that +is, you can manipulate it. This \fIonly\fR works when a preceding call to +\&\f(CW\*(C`incr_parse\*(C'\fR in \fIscalar context\fR successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it \fIwill\fR fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. +.PP +This function is useful in two cases: a) finding the trailing text after a +\&\s-1JSON\s0 object or b) parsing multiple \s-1JSON\s0 objects separated by non-JSON text +(such as commas). +.PP +.Vb 1 +\& $json\->incr_text =~ s/\es*,\es*//; +.Ve +.PP +In Perl 5.005, \f(CW\*(C`lvalue\*(C'\fR attribute is not available. +You must write codes like the below: +.PP +.Vb 3 +\& $string = $json\->incr_text; +\& $string =~ s/\es*,\es*//; +\& $json\->incr_text( $string ); +.Ve +.SS "incr_skip" +.IX Subsection "incr_skip" +.Vb 1 +\& $json\->incr_skip +.Ve +.PP +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after \f(CW\*(C`incr_parse\*(C'\fR +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. +.SS "incr_reset" +.IX Subsection "incr_reset" +.Vb 1 +\& $json\->incr_reset +.Ve +.PP +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. +.PP +This is useful if you want to repeatedly parse \s-1JSON\s0 objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. +.PP +See to \*(L"\s-1INCREMENTAL\s0 \s-1PARSING\s0\*(R" in \s-1JSON::XS\s0 for examples. +.SH "JSON::PP OWN METHODS" +.IX Header "JSON::PP OWN METHODS" +.SS "allow_singlequote" +.IX Subsection "allow_singlequote" +.Vb 1 +\& $json = $json\->allow_singlequote([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept +\&\s-1JSON\s0 strings quoted by single quotations that are invalid \s-1JSON\s0 +format. +.PP +.Vb 3 +\& $json\->allow_singlequote\->decode({"foo":\*(Aqbar\*(Aq}); +\& $json\->allow_singlequote\->decode({\*(Aqfoo\*(Aq:"bar"}); +\& $json\->allow_singlequote\->decode({\*(Aqfoo\*(Aq:\*(Aqbar\*(Aq}); +.Ve +.PP +As same as the \f(CW\*(C`relaxed\*(C'\fR option, this option may be used to parse +application-specific files written by humans. +.SS "allow_barekey" +.IX Subsection "allow_barekey" +.Vb 1 +\& $json = $json\->allow_barekey([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept +bare keys of \s-1JSON\s0 object that are invalid \s-1JSON\s0 format. +.PP +As same as the \f(CW\*(C`relaxed\*(C'\fR option, this option may be used to parse +application-specific files written by humans. +.PP +.Vb 1 +\& $json\->allow_barekey\->decode(\*(Aq{foo:"bar"}\*(Aq); +.Ve +.SS "allow_bignum" +.IX Subsection "allow_bignum" +.Vb 1 +\& $json = $json\->allow_bignum([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will convert +the big integer Perl cannot handle as integer into a Math::BigInt +object and convert a floating number (any) into a Math::BigFloat. +.PP +On the contrary, \f(CW\*(C`encode\*(C'\fR converts \f(CW\*(C`Math::BigInt\*(C'\fR objects and \f(CW\*(C`Math::BigFloat\*(C'\fR +objects into \s-1JSON\s0 numbers with \f(CW\*(C`allow_blessed\*(C'\fR enable. +.PP +.Vb 4 +\& $json\->allow_nonref\->allow_blessed\->allow_bignum; +\& $bigfloat = $json\->decode(\*(Aq2.000000000000000000000000001\*(Aq); +\& print $json\->encode($bigfloat); +\& # => 2.000000000000000000000000001 +.Ve +.PP +See to \*(L"\s-1MAPPING\s0\*(R" in \s-1JSON::XS\s0 about the normal conversion of \s-1JSON\s0 number. +.SS "loose" +.IX Subsection "loose" +.Vb 1 +\& $json = $json\->loose([$enable]) +.Ve +.PP +The unescaped [\ex00\-\ex1f\ex22\ex2f\ex5c] strings are invalid in \s-1JSON\s0 strings +and the module doesn't allow to \f(CW\*(C`decode\*(C'\fR to these (except for \ex2f). +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept these +unescaped strings. +.PP +.Vb 2 +\& $json\->loose\->decode(qq|["abc +\& def"]|); +.Ve +.PP +See \*(L"\s-1SSECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0. +.SS "escape_slash" +.IX Subsection "escape_slash" +.Vb 1 +\& $json = $json\->escape_slash([$enable]) +.Ve +.PP +According to \s-1JSON\s0 Grammar, \fIslash\fR (U+002F) is escaped. But default +\&\s-1JSON::PP\s0 (as same as \s-1JSON::XS\s0) encodes strings without escaping slash. +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`encode\*(C'\fR will escape slashes. +.SS "indent_length" +.IX Subsection "indent_length" +.Vb 1 +\& $json = $json\->indent_length($length) +.Ve +.PP +\&\s-1JSON::XS\s0 indent space length is 3 and cannot be changed. +\&\s-1JSON::PP\s0 set the indent space length with the given \f(CW$length\fR. +The default is 3. The acceptable range is 0 to 15. +.SS "sort_by" +.IX Subsection "sort_by" +.Vb 2 +\& $json = $json\->sort_by($function_name) +\& $json = $json\->sort_by($subroutine_ref) +.Ve +.PP +If \f(CW$function_name\fR or \f(CW$subroutine_ref\fR are set, its sort routine are used +in encoding \s-1JSON\s0 objects. +.PP +.Vb 2 +\& $js = $pc\->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })\->encode($obj); +\& # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); +\& +\& $js = $pc\->sort_by(\*(Aqown_sort\*(Aq)\->encode($obj); +\& # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); +\& +\& sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } +.Ve +.PP +As the sorting routine runs in the \s-1JSON::PP\s0 scope, the given +subroutine name and the special variables \f(CW$a\fR, \f(CW$b\fR will begin +\&'\s-1JSON::PP::\s0'. +.PP +If \f(CW$integer\fR is set, then the effect is same as \f(CW\*(C`canonical\*(C'\fR on. +.SH "INTERNAL" +.IX Header "INTERNAL" +For developers. +.IP "PP_encode_box" 4 +.IX Item "PP_encode_box" +Returns +.Sp +.Vb 4 +\& { +\& depth => $depth, +\& indent_count => $indent_count, +\& } +.Ve +.IP "PP_decode_box" 4 +.IX Item "PP_decode_box" +Returns +.Sp +.Vb 9 +\& { +\& text => $text, +\& at => $at, +\& ch => $ch, +\& len => $len, +\& depth => $depth, +\& encoding => $encoding, +\& is_valid_utf8 => $is_valid_utf8, +\& }; +.Ve +.SH "MAPPING" +.IX Header "MAPPING" +This section is copied from \s-1JSON::XS\s0 and modified to \f(CW\*(C`JSON::PP\*(C'\fR. +\&\s-1JSON::XS\s0 and \s-1JSON::PP\s0 mapping mechanisms are almost equivalent. +.PP +See to \*(L"\s-1MAPPING\s0\*(R" in \s-1JSON::XS\s0. +.SS "\s-1JSON\s0 \-> \s-1PERL\s0" +.IX Subsection "JSON -> PERL" +.IP "object" 4 +.IX Item "object" +A \s-1JSON\s0 object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (\s-1JSON\s0 does not preserver object key ordering itself). +.IP "array" 4 +.IX Item "array" +A \s-1JSON\s0 array becomes a reference to an array in Perl. +.IP "string" 4 +.IX Item "string" +A \s-1JSON\s0 string becomes a string scalar in Perl \- Unicode codepoints in \s-1JSON\s0 +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. +.IP "number" 4 +.IX Item "number" +A \s-1JSON\s0 number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. +.Sp +If the number consists of digits only, \f(CW\*(C`JSON\*(C'\fR will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the \s-1JSON\s0 number will be +re-encoded to a \s-1JSON\s0 string). +.Sp +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the \s-1JSON\s0 number will still be re-encoded as a \s-1JSON\s0 number). +.Sp +Note that precision is not accuracy \- binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, \f(CW\*(C`JSON\*(C'\fR only guarantees precision up to but not including +the least significant bit. +.Sp +When \f(CW\*(C`allow_bignum\*(C'\fR is enable, the big integers +and the numeric can be optionally converted into Math::BigInt and +Math::BigFloat objects. +.IP "true, false" 4 +.IX Item "true, false" +These \s-1JSON\s0 atoms become \f(CW\*(C`JSON::PP::true\*(C'\fR and \f(CW\*(C`JSON::PP::false\*(C'\fR, +respectively. They are overloaded to act almost exactly like the numbers +\&\f(CW1\fR and \f(CW0\fR. You can check whether a scalar is a \s-1JSON\s0 boolean by using +the \f(CW\*(C`JSON::is_bool\*(C'\fR function. +.Sp +.Vb 4 +\& print JSON::PP::true . "\en"; +\& => true +\& print JSON::PP::true + 1; +\& => 1 +\& +\& ok(JSON::true eq \*(Aq1\*(Aq); +\& ok(JSON::true == 1); +.Ve +.Sp +\&\f(CW\*(C`JSON\*(C'\fR will install these missing overloading features to the backend modules. +.IP "null" 4 +.IX Item "null" +A \s-1JSON\s0 null atom becomes \f(CW\*(C`undef\*(C'\fR in Perl. +.Sp +\&\f(CW\*(C`JSON::PP::null\*(C'\fR returns \f(CW\*(C`undef\*(C'\fR. +.SS "\s-1PERL\s0 \-> \s-1JSON\s0" +.IX Subsection "PERL -> JSON" +The mapping from Perl to \s-1JSON\s0 is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which \s-1JSON\s0 type is meant by +a Perl value. +.IP "hash references" 4 +.IX Item "hash references" +Perl hash references become \s-1JSON\s0 objects. As there is no inherent ordering +in hash keys (or \s-1JSON\s0 objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. \f(CW\*(C`JSON\*(C'\fR +optionally sort the hash keys (determined by the \fIcanonical\fR flag), so +the same data structure will serialise to the same \s-1JSON\s0 text (given same +settings and version of \s-1JSON::XS\s0), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some \s-1JSON\s0 text +against another for equality. +.IP "array references" 4 +.IX Item "array references" +Perl array references become \s-1JSON\s0 arrays. +.IP "other references" 4 +.IX Item "other references" +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers \f(CW0\fR and +\&\f(CW1\fR, which get turned into \f(CW\*(C`false\*(C'\fR and \f(CW\*(C`true\*(C'\fR atoms in \s-1JSON\s0. You can +also use \f(CW\*(C`JSON::false\*(C'\fR and \f(CW\*(C`JSON::true\*(C'\fR to improve readability. +.Sp +.Vb 1 +\& to_json [\e0,JSON::PP::true] # yields [false,true] +.Ve +.IP "JSON::PP::true, JSON::PP::false, JSON::PP::null" 4 +.IX Item "JSON::PP::true, JSON::PP::false, JSON::PP::null" +These special values become \s-1JSON\s0 true and \s-1JSON\s0 false values, +respectively. You can also use \f(CW\*(C`\e1\*(C'\fR and \f(CW\*(C`\e0\*(C'\fR directly if you want. +.Sp +JSON::PP::null returns \f(CW\*(C`undef\*(C'\fR. +.IP "blessed objects" 4 +.IX Item "blessed objects" +Blessed objects are not directly representable in \s-1JSON\s0. See the +\&\f(CW\*(C`allow_blessed\*(C'\fR and \f(CW\*(C`convert_blessed\*(C'\fR methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. +.Sp +See to convert_blessed. +.IP "simple scalars" 4 +.IX Item "simple scalars" +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: \s-1JSON::XS\s0 and \s-1JSON::PP\s0 will encode undefined scalars as +\&\s-1JSON\s0 \f(CW\*(C`null\*(C'\fR values, scalars that have last been used in a string context +before encoding as \s-1JSON\s0 strings, and anything else as number value: +.Sp +.Vb 4 +\& # dump as number +\& encode_json [2] # yields [2] +\& encode_json [\-3.0e17] # yields [\-3e+17] +\& my $value = 5; encode_json [$value] # yields [5] +\& +\& # used as string, so dump as string +\& print $value; +\& encode_json [$value] # yields ["5"] +\& +\& # undef becomes null +\& encode_json [undef] # yields [null] +.Ve +.Sp +You can force the type to be a string by stringifying it: +.Sp +.Vb 4 +\& my $x = 3.1; # some variable containing a number +\& "$x"; # stringified +\& $x .= ""; # another, more awkward way to stringify +\& print $x; # perl does it for you, too, quite often +.Ve +.Sp +You can force the type to be a number by numifying it: +.Sp +.Vb 3 +\& my $x = "3"; # some variable containing a string +\& $x += 0; # numify it, ensuring it will be dumped as a number +\& $x *= 1; # same thing, the choice is yours. +.Ve +.Sp +You can not currently force the type in other, less obscure, ways. +.Sp +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's \- these cannot be represented in \s-1JSON\s0, and it is an +error to pass those in. +.IP "Big Number" 4 +.IX Item "Big Number" +When \f(CW\*(C`allow_bignum\*(C'\fR is enable, +\&\f(CW\*(C`encode\*(C'\fR converts \f(CW\*(C`Math::BigInt\*(C'\fR objects and \f(CW\*(C`Math::BigFloat\*(C'\fR +objects into \s-1JSON\s0 numbers. +.SH "UNICODE HANDLING ON PERLS" +.IX Header "UNICODE HANDLING ON PERLS" +If you do not know about Unicode on Perl well, +please check \*(L"A \s-1FEW\s0 \s-1NOTES\s0 \s-1ON\s0 \s-1UNICODE\s0 \s-1AND\s0 \s-1PERL\s0\*(R" in \s-1JSON::XS\s0. +.SS "Perl 5.8 and later" +.IX Subsection "Perl 5.8 and later" +Perl can handle Unicode and the \s-1JSON::PP\s0 de/encode methods also work properly. +.PP +.Vb 2 +\& $json\->allow_nonref\->encode(chr hex 3042); +\& $json\->allow_nonref\->encode(chr hex 12345); +.Ve +.PP +Returns \f(CW"\eu3042"\fR and \f(CW"\eud808\eudf45"\fR respectively. +.PP +.Vb 2 +\& $json\->allow_nonref\->decode(\*(Aq"\eu3042"\*(Aq); +\& $json\->allow_nonref\->decode(\*(Aq"\eud808\eudf45"\*(Aq); +.Ve +.PP +Returns \s-1UTF\-8\s0 encoded strings with \s-1UTF8\s0 flag, regarded as \f(CW\*(C`U+3042\*(C'\fR and \f(CW\*(C`U+12345\*(C'\fR. +.PP +Note that the versions from Perl 5.8.0 to 5.8.2, Perl built-in \f(CW\*(C`join\*(C'\fR was broken, +so \s-1JSON::PP\s0 wraps the \f(CW\*(C`join\*(C'\fR with a subroutine. Thus \s-1JSON::PP\s0 works slow in the versions. +.SS "Perl 5.6" +.IX Subsection "Perl 5.6" +Perl can handle Unicode and the \s-1JSON::PP\s0 de/encode methods also work. +.SS "Perl 5.005" +.IX Subsection "Perl 5.005" +Perl 5.005 is a byte semantics world \*(-- all strings are sequences of bytes. +That means the unicode handling is not available. +.PP +In encoding, +.PP +.Vb 2 +\& $json\->allow_nonref\->encode(chr hex 3042); # hex 3042 is 12354. +\& $json\->allow_nonref\->encode(chr hex 12345); # hex 12345 is 74565. +.Ve +.PP +Returns \f(CW\*(C`B\*(C'\fR and \f(CW\*(C`E\*(C'\fR, as \f(CW\*(C`chr\*(C'\fR takes a value more than 255, it treats +as \f(CW\*(C`$value % 256\*(C'\fR, so the above codes are equivalent to : +.PP +.Vb 2 +\& $json\->allow_nonref\->encode(chr 66); +\& $json\->allow_nonref\->encode(chr 69); +.Ve +.PP +In decoding, +.PP +.Vb 1 +\& $json\->decode(\*(Aq"\eu00e3\eu0081\eu0082"\*(Aq); +.Ve +.PP +The returned is a byte sequence \f(CW\*(C`0xE3 0x81 0x82\*(C'\fR for \s-1UTF\-8\s0 encoded +japanese character (\f(CW\*(C`HIRAGANA LETTER A\*(C'\fR). +And if it is represented in Unicode code point, \f(CW\*(C`U+3042\*(C'\fR. +.PP +Next, +.PP +.Vb 1 +\& $json\->decode(\*(Aq"\eu3042"\*(Aq); +.Ve +.PP +We ordinary expect the returned value is a Unicode character \f(CW\*(C`U+3042\*(C'\fR. +But here is 5.005 world. This is \f(CW\*(C`0xE3 0x81 0x82\*(C'\fR. +.PP +.Vb 1 +\& $json\->decode(\*(Aq"\eud808\eudf45"\*(Aq); +.Ve +.PP +This is not a character \f(CW\*(C`U+12345\*(C'\fR but bytes \- \f(CW\*(C`0xf0 0x92 0x8d 0x85\*(C'\fR. +.SH "TODO" +.IX Header "TODO" +.IP "speed" 4 +.IX Item "speed" +.PD 0 +.IP "memory saving" 4 +.IX Item "memory saving" +.PD +.SH "SEE ALSO" +.IX Header "SEE ALSO" +Most of the document are copied and modified from \s-1JSON::XS\s0 doc. +.PP +\&\s-1JSON::XS\s0 +.PP +\&\s-1RFC4627\s0 (<http://www.ietf.org/rfc/rfc4627.txt>) +.SH "AUTHOR" +.IX Header "AUTHOR" +Makamaka Hannyaharamitu, <makamaka[at]cpan.org> +.SH "COPYRIGHT AND LICENSE" +.IX Header "COPYRIGHT AND LICENSE" +Copyright 2007\-2012 by Makamaka Hannyaharamitu +.PP +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. diff --git a/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Boolean.3pm b/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Boolean.3pm new file mode 100644 index 0000000..9ddc65d --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Boolean.3pm @@ -0,0 +1,146 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON::backportPP::Boolean 3pm" +.TH JSON::backportPP::Boolean 3pm "2013-04-05" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON::PP::Boolean \- dummy module providing JSON::PP::Boolean +.SH "SYNOPSIS" +.IX Header "SYNOPSIS" +.Vb 1 +\& # do not "use" yourself +.Ve +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +This module exists only to provide overload resolution for Storable +and similar modules. See \s-1JSON::PP\s0 for more info about this class. +.SH "AUTHOR" +.IX Header "AUTHOR" +This idea is from JSON::XS::Boolean written by +Marc Lehmann <schmorp[at]schmorp.de> diff --git a/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5005.3pm b/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5005.3pm new file mode 100644 index 0000000..5796269 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5005.3pm @@ -0,0 +1,145 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON::backportPP::Compat5005 3pm" +.TH JSON::backportPP::Compat5005 3pm "2013-04-05" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON::PP5005 \- Helper module in using JSON::PP in Perl 5.005 +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +\&\s-1JSON::PP\s0 calls internally. +.SH "AUTHOR" +.IX Header "AUTHOR" +Makamaka Hannyaharamitu, <makamaka[at]cpan.org> +.SH "COPYRIGHT AND LICENSE" +.IX Header "COPYRIGHT AND LICENSE" +Copyright 2007\-2012 by Makamaka Hannyaharamitu +.PP +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. diff --git a/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5006.3pm b/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5006.3pm new file mode 100644 index 0000000..3186e73 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5006.3pm @@ -0,0 +1,145 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON::backportPP::Compat5006 3pm" +.TH JSON::backportPP::Compat5006 3pm "2013-04-05" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON::PP56 \- Helper module in using JSON::PP in Perl 5.6 +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +\&\s-1JSON::PP\s0 calls internally. +.SH "AUTHOR" +.IX Header "AUTHOR" +Makamaka Hannyaharamitu, <makamaka[at]cpan.org> +.SH "COPYRIGHT AND LICENSE" +.IX Header "COPYRIGHT AND LICENSE" +Copyright 2007\-2012 by Makamaka Hannyaharamitu +.PP +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. diff --git a/third_party/JSON/JSON-2.59/blib/script/.exists b/third_party/JSON/JSON-2.59/blib/script/.exists new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/third_party/JSON/JSON-2.59/blib/script/.exists diff --git a/third_party/JSON/JSON-2.59/eg/bench_decode.pl b/third_party/JSON/JSON-2.59/eg/bench_decode.pl new file mode 100755 index 0000000..cfa0f5f --- /dev/null +++ b/third_party/JSON/JSON-2.59/eg/bench_decode.pl @@ -0,0 +1,70 @@ +#!/usr/bin/perl + +use strict; +use warnings; +use Benchmark qw( cmpthese timethese ); + +our $VERSION = '1.00'; + +my $wanttime = $ARGV[1] || 5; + +use JSON qw( -support_by_pp -no_export ); # for JSON::PP::Boolean inheritance +use JSON::PP (); +use JSON::XS (); +use utf8; + +my $pp = JSON::PP->new->utf8; +my $xs = JSON::XS->new->utf8; + +local $/; + +my $json = <>; +my $perl = JSON::XS::decode_json $json; +my $result; + + +printf( "JSON::PP %s\n", JSON::PP->VERSION ); +printf( "JSON::XS %s\n", JSON::XS->VERSION ); + + +print "-----------------------------------\n"; +print "->decode()\n"; +print "-----------------------------------\n"; + +$result = timethese( -$wanttime, + { + 'JSON::PP' => sub { $pp->decode( $json ) }, + 'JSON::XS' => sub { $xs->decode( $json ) }, + }, + 'none' +); +cmpthese( $result ); + +print "-----------------------------------\n"; + + +__END__ + +=pod + +=head1 SYNOPSYS + + bench_decode.pl json-file + # or + bench_decode.pl json-file minimum-time + +=head1 DESCRIPTION + +L<JSON::PP> and L<JSON::XS> decoding benchmark. + +=head1 AUTHOR + +makamaka + +=head1 LISENCE + +This library is free software; you can redistribute it and/or modify it +under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/JSON-2.59/eg/bench_encode.pl b/third_party/JSON/JSON-2.59/eg/bench_encode.pl new file mode 100755 index 0000000..d360a5c --- /dev/null +++ b/third_party/JSON/JSON-2.59/eg/bench_encode.pl @@ -0,0 +1,86 @@ +#!/usr/bin/perl + +use strict; +use warnings; +use Benchmark qw( cmpthese timethese ); + +our $VERSION = '1.00'; + +my $wanttime = $ARGV[1] || 5; + +use JSON qw( -support_by_pp -no_export ); # for JSON::PP::Boolean inheritance +use JSON::PP (); +use JSON::XS (); +use utf8; + +my $pp = JSON::PP->new->utf8; +my $xs = JSON::XS->new->utf8; + +local $/; + +my $json = <>; +my $perl = JSON::XS::decode_json $json; +my $result; + + +printf( "JSON::PP %s\n", JSON::PP->VERSION ); +printf( "JSON::XS %s\n", JSON::XS->VERSION ); + + +print "-----------------------------------\n"; +print "->encode()\n"; +print "-----------------------------------\n"; + +$result = timethese( -$wanttime, + { + 'JSON::PP' => sub { $pp->encode( $perl ) }, + 'JSON::XS' => sub { $xs->encode( $perl ) }, + }, + 'none' +); +cmpthese( $result ); + +print "-----------------------------------\n"; +print "->pretty->canonical->encode()\n"; +print "-----------------------------------\n"; + +$pp->pretty->canonical; +$xs->pretty->canonical; + +$result = timethese( -$wanttime, + { + 'JSON::PP' => sub { $pp->encode( $perl ) }, + 'JSON::XS' => sub { $xs->encode( $perl ) }, + }, + 'none' +); +cmpthese( $result ); + +print "-----------------------------------\n"; + + +__END__ + +=pod + +=head1 SYNOPSYS + + bench_encode.pl json-file + # or + bench_encode.pl json-file minimum-time + +=head1 DESCRIPTION + +L<JSON::PP> and L<JSON::XS> encoding benchmark. + +=head1 AUTHOR + +makamaka + +=head1 LISENCE + +This library is free software; you can redistribute it and/or modify it +under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/JSON-2.59/lib/JSON.pm b/third_party/JSON/JSON-2.59/lib/JSON.pm new file mode 100644 index 0000000..bd39cd8 --- /dev/null +++ b/third_party/JSON/JSON-2.59/lib/JSON.pm @@ -0,0 +1,2292 @@ +package JSON; + + +use strict; +use Carp (); +use base qw(Exporter); +@JSON::EXPORT = qw(from_json to_json jsonToObj objToJson encode_json decode_json); + +BEGIN { + $JSON::VERSION = '2.59'; + $JSON::DEBUG = 0 unless (defined $JSON::DEBUG); + $JSON::DEBUG = $ENV{ PERL_JSON_DEBUG } if exists $ENV{ PERL_JSON_DEBUG }; +} + +my $Module_XS = 'JSON::XS'; +my $Module_PP = 'JSON::PP'; +my $Module_bp = 'JSON::backportPP'; # included in JSON distribution +my $PP_Version = '2.27200'; +my $XS_Version = '2.34'; + + +# XS and PP common methods + +my @PublicMethods = qw/ + ascii latin1 utf8 pretty indent space_before space_after relaxed canonical allow_nonref + allow_blessed convert_blessed filter_json_object filter_json_single_key_object + shrink max_depth max_size encode decode decode_prefix allow_unknown +/; + +my @Properties = qw/ + ascii latin1 utf8 indent space_before space_after relaxed canonical allow_nonref + allow_blessed convert_blessed shrink max_depth max_size allow_unknown +/; + +my @XSOnlyMethods = qw//; # Currently nothing + +my @PPOnlyMethods = qw/ + indent_length sort_by + allow_singlequote allow_bignum loose allow_barekey escape_slash as_nonblessed +/; # JSON::PP specific + + +# used in _load_xs and _load_pp ($INSTALL_ONLY is not used currently) +my $_INSTALL_DONT_DIE = 1; # When _load_xs fails to load XS, don't die. +my $_INSTALL_ONLY = 2; # Don't call _set_methods() +my $_ALLOW_UNSUPPORTED = 0; +my $_UNIV_CONV_BLESSED = 0; +my $_USSING_bpPP = 0; + + +# Check the environment variable to decide worker module. + +unless ($JSON::Backend) { + $JSON::DEBUG and Carp::carp("Check used worker module..."); + + my $backend = exists $ENV{PERL_JSON_BACKEND} ? $ENV{PERL_JSON_BACKEND} : 1; + + if ($backend eq '1' or $backend =~ /JSON::XS\s*,\s*JSON::PP/) { + _load_xs($_INSTALL_DONT_DIE) or _load_pp(); + } + elsif ($backend eq '0' or $backend eq 'JSON::PP') { + _load_pp(); + } + elsif ($backend eq '2' or $backend eq 'JSON::XS') { + _load_xs(); + } + elsif ($backend eq 'JSON::backportPP') { + $_USSING_bpPP = 1; + _load_pp(); + } + else { + Carp::croak "The value of environmental variable 'PERL_JSON_BACKEND' is invalid."; + } +} + + +sub import { + my $pkg = shift; + my @what_to_export; + my $no_export; + + for my $tag (@_) { + if ($tag eq '-support_by_pp') { + if (!$_ALLOW_UNSUPPORTED++) { + JSON::Backend::XS + ->support_by_pp(@PPOnlyMethods) if ($JSON::Backend eq $Module_XS); + } + next; + } + elsif ($tag eq '-no_export') { + $no_export++, next; + } + elsif ( $tag eq '-convert_blessed_universally' ) { + eval q| + require B; + *UNIVERSAL::TO_JSON = sub { + my $b_obj = B::svref_2object( $_[0] ); + return $b_obj->isa('B::HV') ? { %{ $_[0] } } + : $b_obj->isa('B::AV') ? [ @{ $_[0] } ] + : undef + ; + } + | if ( !$_UNIV_CONV_BLESSED++ ); + next; + } + push @what_to_export, $tag; + } + + return if ($no_export); + + __PACKAGE__->export_to_level(1, $pkg, @what_to_export); +} + + +# OBSOLETED + +sub jsonToObj { + my $alternative = 'from_json'; + if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) { + shift @_; $alternative = 'decode'; + } + Carp::carp "'jsonToObj' will be obsoleted. Please use '$alternative' instead."; + return JSON::from_json(@_); +}; + +sub objToJson { + my $alternative = 'to_json'; + if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) { + shift @_; $alternative = 'encode'; + } + Carp::carp "'objToJson' will be obsoleted. Please use '$alternative' instead."; + JSON::to_json(@_); +}; + + +# INTERFACES + +sub to_json ($@) { + if ( + ref($_[0]) eq 'JSON' + or (@_ > 2 and $_[0] eq 'JSON') + ) { + Carp::croak "to_json should not be called as a method."; + } + my $json = JSON->new; + + if (@_ == 2 and ref $_[1] eq 'HASH') { + my $opt = $_[1]; + for my $method (keys %$opt) { + $json->$method( $opt->{$method} ); + } + } + + $json->encode($_[0]); +} + + +sub from_json ($@) { + if ( ref($_[0]) eq 'JSON' or $_[0] eq 'JSON' ) { + Carp::croak "from_json should not be called as a method."; + } + my $json = JSON->new; + + if (@_ == 2 and ref $_[1] eq 'HASH') { + my $opt = $_[1]; + for my $method (keys %$opt) { + $json->$method( $opt->{$method} ); + } + } + + return $json->decode( $_[0] ); +} + + +sub true { $JSON::true } + +sub false { $JSON::false } + +sub null { undef; } + + +sub require_xs_version { $XS_Version; } + +sub backend { + my $proto = shift; + $JSON::Backend; +} + +#*module = *backend; + + +sub is_xs { + return $_[0]->module eq $Module_XS; +} + + +sub is_pp { + return not $_[0]->xs; +} + + +sub pureperl_only_methods { @PPOnlyMethods; } + + +sub property { + my ($self, $name, $value) = @_; + + if (@_ == 1) { + my %props; + for $name (@Properties) { + my $method = 'get_' . $name; + if ($name eq 'max_size') { + my $value = $self->$method(); + $props{$name} = $value == 1 ? 0 : $value; + next; + } + $props{$name} = $self->$method(); + } + return \%props; + } + elsif (@_ > 3) { + Carp::croak('property() can take only the option within 2 arguments.'); + } + elsif (@_ == 2) { + if ( my $method = $self->can('get_' . $name) ) { + if ($name eq 'max_size') { + my $value = $self->$method(); + return $value == 1 ? 0 : $value; + } + $self->$method(); + } + } + else { + $self->$name($value); + } + +} + + + +# INTERNAL + +sub _load_xs { + my $opt = shift; + + $JSON::DEBUG and Carp::carp "Load $Module_XS."; + + # if called after install module, overload is disable.... why? + JSON::Boolean::_overrride_overload($Module_XS); + JSON::Boolean::_overrride_overload($Module_PP); + + eval qq| + use $Module_XS $XS_Version (); + |; + + if ($@) { + if (defined $opt and $opt & $_INSTALL_DONT_DIE) { + $JSON::DEBUG and Carp::carp "Can't load $Module_XS...($@)"; + return 0; + } + Carp::croak $@; + } + + unless (defined $opt and $opt & $_INSTALL_ONLY) { + _set_module( $JSON::Backend = $Module_XS ); + my $data = join("", <DATA>); # this code is from Jcode 2.xx. + close(DATA); + eval $data; + JSON::Backend::XS->init; + } + + return 1; +}; + + +sub _load_pp { + my $opt = shift; + my $backend = $_USSING_bpPP ? $Module_bp : $Module_PP; + + $JSON::DEBUG and Carp::carp "Load $backend."; + + # if called after install module, overload is disable.... why? + JSON::Boolean::_overrride_overload($Module_XS); + JSON::Boolean::_overrride_overload($backend); + + if ( $_USSING_bpPP ) { + eval qq| require $backend |; + } + else { + eval qq| use $backend $PP_Version () |; + } + + if ($@) { + if ( $backend eq $Module_PP ) { + $JSON::DEBUG and Carp::carp "Can't load $Module_PP ($@), so try to load $Module_bp"; + $_USSING_bpPP++; + $backend = $Module_bp; + JSON::Boolean::_overrride_overload($backend); + local $^W; # if PP installed but invalid version, backportPP redefines methods. + eval qq| require $Module_bp |; + } + Carp::croak $@ if $@; + } + + unless (defined $opt and $opt & $_INSTALL_ONLY) { + _set_module( $JSON::Backend = $Module_PP ); # even if backportPP, set $Backend with 'JSON::PP' + JSON::Backend::PP->init; + } +}; + + +sub _set_module { + return if defined $JSON::true; + + my $module = shift; + + local $^W; + no strict qw(refs); + + $JSON::true = ${"$module\::true"}; + $JSON::false = ${"$module\::false"}; + + push @JSON::ISA, $module; + push @{"$module\::Boolean::ISA"}, qw(JSON::Boolean); + + *{"JSON::is_bool"} = \&{"$module\::is_bool"}; + + for my $method ($module eq $Module_XS ? @PPOnlyMethods : @XSOnlyMethods) { + *{"JSON::$method"} = sub { + Carp::carp("$method is not supported in $module."); + $_[0]; + }; + } + + return 1; +} + + + +# +# JSON Boolean +# + +package JSON::Boolean; + +my %Installed; + +sub _overrride_overload { + return if ($Installed{ $_[0] }++); + + my $boolean = $_[0] . '::Boolean'; + + eval sprintf(q| + package %s; + use overload ( + '""' => sub { ${$_[0]} == 1 ? 'true' : 'false' }, + 'eq' => sub { + my ($obj, $op) = ref ($_[0]) ? ($_[0], $_[1]) : ($_[1], $_[0]); + if ($op eq 'true' or $op eq 'false') { + return "$obj" eq 'true' ? 'true' eq $op : 'false' eq $op; + } + else { + return $obj ? 1 == $op : 0 == $op; + } + }, + ); + |, $boolean); + + if ($@) { Carp::croak $@; } + + if ( exists $INC{'JSON/XS.pm'} and $boolean eq 'JSON::XS::Boolean' ) { + local $^W; + my $true = do { bless \(my $dummy = 1), $boolean }; + my $false = do { bless \(my $dummy = 0), $boolean }; + *JSON::XS::true = sub () { $true }; + *JSON::XS::false = sub () { $false }; + } + elsif ( exists $INC{'JSON/PP.pm'} and $boolean eq 'JSON::PP::Boolean' ) { + local $^W; + my $true = do { bless \(my $dummy = 1), $boolean }; + my $false = do { bless \(my $dummy = 0), $boolean }; + *JSON::PP::true = sub { $true }; + *JSON::PP::false = sub { $false }; + } + + return 1; +} + + +# +# Helper classes for Backend Module (PP) +# + +package JSON::Backend::PP; + +sub init { + local $^W; + no strict qw(refs); # this routine may be called after JSON::Backend::XS init was called. + *{"JSON::decode_json"} = \&{"JSON::PP::decode_json"}; + *{"JSON::encode_json"} = \&{"JSON::PP::encode_json"}; + *{"JSON::PP::is_xs"} = sub { 0 }; + *{"JSON::PP::is_pp"} = sub { 1 }; + return 1; +} + +# +# To save memory, the below lines are read only when XS backend is used. +# + +package JSON; + +1; +__DATA__ + + +# +# Helper classes for Backend Module (XS) +# + +package JSON::Backend::XS; + +use constant INDENT_LENGTH_FLAG => 15 << 12; + +use constant UNSUPPORTED_ENCODE_FLAG => { + ESCAPE_SLASH => 0x00000010, + ALLOW_BIGNUM => 0x00000020, + AS_NONBLESSED => 0x00000040, + EXPANDED => 0x10000000, # for developer's +}; + +use constant UNSUPPORTED_DECODE_FLAG => { + LOOSE => 0x00000001, + ALLOW_BIGNUM => 0x00000002, + ALLOW_BAREKEY => 0x00000004, + ALLOW_SINGLEQUOTE => 0x00000008, + EXPANDED => 0x20000000, # for developer's +}; + + +sub init { + local $^W; + no strict qw(refs); + *{"JSON::decode_json"} = \&{"JSON::XS::decode_json"}; + *{"JSON::encode_json"} = \&{"JSON::XS::encode_json"}; + *{"JSON::XS::is_xs"} = sub { 1 }; + *{"JSON::XS::is_pp"} = sub { 0 }; + return 1; +} + + +sub support_by_pp { + my ($class, @methods) = @_; + + local $^W; + no strict qw(refs); + + my $JSON_XS_encode_orignal = \&JSON::XS::encode; + my $JSON_XS_decode_orignal = \&JSON::XS::decode; + my $JSON_XS_incr_parse_orignal = \&JSON::XS::incr_parse; + + *JSON::XS::decode = \&JSON::Backend::XS::Supportable::_decode; + *JSON::XS::encode = \&JSON::Backend::XS::Supportable::_encode; + *JSON::XS::incr_parse = \&JSON::Backend::XS::Supportable::_incr_parse; + + *{JSON::XS::_original_decode} = $JSON_XS_decode_orignal; + *{JSON::XS::_original_encode} = $JSON_XS_encode_orignal; + *{JSON::XS::_original_incr_parse} = $JSON_XS_incr_parse_orignal; + + push @JSON::Backend::XS::Supportable::ISA, 'JSON'; + + my $pkg = 'JSON::Backend::XS::Supportable'; + + *{JSON::new} = sub { + my $proto = JSON::XS->new; $$proto = 0; + bless $proto, $pkg; + }; + + + for my $method (@methods) { + my $flag = uc($method); + my $type |= (UNSUPPORTED_ENCODE_FLAG->{$flag} || 0); + $type |= (UNSUPPORTED_DECODE_FLAG->{$flag} || 0); + + next unless($type); + + $pkg->_make_unsupported_method($method => $type); + } + + push @{"JSON::XS::Boolean::ISA"}, qw(JSON::PP::Boolean); + push @{"JSON::PP::Boolean::ISA"}, qw(JSON::Boolean); + + $JSON::DEBUG and Carp::carp("set -support_by_pp mode."); + + return 1; +} + + + + +# +# Helper classes for XS +# + +package JSON::Backend::XS::Supportable; + +$Carp::Internal{'JSON::Backend::XS::Supportable'} = 1; + +sub _make_unsupported_method { + my ($pkg, $method, $type) = @_; + + local $^W; + no strict qw(refs); + + *{"$pkg\::$method"} = sub { + local $^W; + if (defined $_[1] ? $_[1] : 1) { + ${$_[0]} |= $type; + } + else { + ${$_[0]} &= ~$type; + } + $_[0]; + }; + + *{"$pkg\::get_$method"} = sub { + ${$_[0]} & $type ? 1 : ''; + }; + +} + + +sub _set_for_pp { + JSON::_load_pp( $_INSTALL_ONLY ); + + my $type = shift; + my $pp = JSON::PP->new; + my $prop = $_[0]->property; + + for my $name (keys %$prop) { + $pp->$name( $prop->{$name} ? $prop->{$name} : 0 ); + } + + my $unsupported = $type eq 'encode' ? JSON::Backend::XS::UNSUPPORTED_ENCODE_FLAG + : JSON::Backend::XS::UNSUPPORTED_DECODE_FLAG; + my $flags = ${$_[0]} || 0; + + for my $name (keys %$unsupported) { + next if ($name eq 'EXPANDED'); # for developer's + my $enable = ($flags & $unsupported->{$name}) ? 1 : 0; + my $method = lc $name; + $pp->$method($enable); + } + + $pp->indent_length( $_[0]->get_indent_length ); + + return $pp; +} + +sub _encode { # using with PP encode + if (${$_[0]}) { + _set_for_pp('encode' => @_)->encode($_[1]); + } + else { + $_[0]->_original_encode( $_[1] ); + } +} + + +sub _decode { # if unsupported-flag is set, use PP + if (${$_[0]}) { + _set_for_pp('decode' => @_)->decode($_[1]); + } + else { + $_[0]->_original_decode( $_[1] ); + } +} + + +sub decode_prefix { # if unsupported-flag is set, use PP + _set_for_pp('decode' => @_)->decode_prefix($_[1]); +} + + +sub _incr_parse { + if (${$_[0]}) { + _set_for_pp('decode' => @_)->incr_parse($_[1]); + } + else { + $_[0]->_original_incr_parse( $_[1] ); + } +} + + +sub get_indent_length { + ${$_[0]} << 4 >> 16; +} + + +sub indent_length { + my $length = $_[1]; + + if (!defined $length or $length > 15 or $length < 0) { + Carp::carp "The acceptable range of indent_length() is 0 to 15."; + } + else { + local $^W; + $length <<= 12; + ${$_[0]} &= ~ JSON::Backend::XS::INDENT_LENGTH_FLAG; + ${$_[0]} |= $length; + *JSON::XS::encode = \&JSON::Backend::XS::Supportable::_encode; + } + + $_[0]; +} + + +1; +__END__ + +=head1 NAME + +JSON - JSON (JavaScript Object Notation) encoder/decoder + +=head1 SYNOPSIS + + use JSON; # imports encode_json, decode_json, to_json and from_json. + + # simple and fast interfaces (expect/generate UTF-8) + + $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; + $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; + + # OO-interface + + $json = JSON->new->allow_nonref; + + $json_text = $json->encode( $perl_scalar ); + $perl_scalar = $json->decode( $json_text ); + + $pretty_printed = $json->pretty->encode( $perl_scalar ); # pretty-printing + + # If you want to use PP only support features, call with '-support_by_pp' + # When XS unsupported feature is enable, using PP (de|en)code instead of XS ones. + + use JSON -support_by_pp; + + # option-acceptable interfaces (expect/generate UNICODE by default) + + $json_text = to_json( $perl_scalar, { ascii => 1, pretty => 1 } ); + $perl_scalar = from_json( $json_text, { utf8 => 1 } ); + + # Between (en|de)code_json and (to|from)_json, if you want to write + # a code which communicates to an outer world (encoded in UTF-8), + # recommend to use (en|de)code_json. + +=head1 VERSION + + 2.59 + +This version is compatible with JSON::XS B<2.34> and later. + + +=head1 NOTE + +JSON::PP was earlier included in the C<JSON> distribution, but +has since Perl 5.14 been a core module. For this reason, +L<JSON::PP> was removed from the JSON distribution and can now +be found also in the Perl5 repository at + +=over + +=item * L<http://perl5.git.perl.org/perl.git> + +=back + +(The newest JSON::PP version still exists in CPAN.) + +Instead, the C<JSON> distribution will include JSON::backportPP +for backwards computability. JSON.pm should thus work as it did +before. + +=head1 DESCRIPTION + + ************************** CAUTION ******************************** + * This is 'JSON module version 2' and there are many differences * + * to version 1.xx * + * Please check your applications using old version. * + * See to 'INCOMPATIBLE CHANGES TO OLD VERSION' * + ******************************************************************* + +JSON (JavaScript Object Notation) is a simple data format. +See to L<http://www.json.org/> and C<RFC4627>(L<http://www.ietf.org/rfc/rfc4627.txt>). + +This module converts Perl data structures to JSON and vice versa using either +L<JSON::XS> or L<JSON::PP>. + +JSON::XS is the fastest and most proper JSON module on CPAN which must be +compiled and installed in your environment. +JSON::PP is a pure-Perl module which is bundled in this distribution and +has a strong compatibility to JSON::XS. + +This module try to use JSON::XS by default and fail to it, use JSON::PP instead. +So its features completely depend on JSON::XS or JSON::PP. + +See to L<BACKEND MODULE DECISION>. + +To distinguish the module name 'JSON' and the format type JSON, +the former is quoted by CE<lt>E<gt> (its results vary with your using media), +and the latter is left just as it is. + +Module name : C<JSON> + +Format type : JSON + +=head2 FEATURES + +=over + +=item * correct unicode handling + +This module (i.e. backend modules) knows how to handle Unicode, documents +how and when it does so, and even documents what "correct" means. + +Even though there are limitations, this feature is available since Perl version 5.6. + +JSON::XS requires Perl 5.8.2 (but works correctly in 5.8.8 or later), so in older versions +C<JSON> should call JSON::PP as the backend which can be used since Perl 5.005. + +With Perl 5.8.x JSON::PP works, but from 5.8.0 to 5.8.2, because of a Perl side problem, +JSON::PP works slower in the versions. And in 5.005, the Unicode handling is not available. +See to L<JSON::PP/UNICODE HANDLING ON PERLS> for more information. + +See also to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL> +and L<JSON::XS/ENCODING/CODESET_FLAG_NOTES>. + + +=item * round-trip integrity + +When you serialise a perl data structure using only data types supported +by JSON and Perl, the deserialised data structure is identical on the Perl +level. (e.g. the string "2.0" doesn't suddenly become "2" just because +it looks like a number). There I<are> minor exceptions to this, read the +L</MAPPING> section below to learn about those. + + +=item * strict checking of JSON correctness + +There is no guessing, no generating of illegal JSON texts by default, +and only JSON is accepted as input by default (the latter is a security +feature). + +See to L<JSON::XS/FEATURES> and L<JSON::PP/FEATURES>. + +=item * fast + +This module returns a JSON::XS object itself if available. +Compared to other JSON modules and other serialisers such as Storable, +JSON::XS usually compares favorably in terms of speed, too. + +If not available, C<JSON> returns a JSON::PP object instead of JSON::XS and +it is very slow as pure-Perl. + +=item * simple to use + +This module has both a simple functional interface as well as an +object oriented interface interface. + +=item * reasonably versatile output formats + +You can choose between the most compact guaranteed-single-line format possible +(nice for simple line-based protocols), a pure-ASCII format (for when your transport +is not 8-bit clean, still supports the whole Unicode range), or a pretty-printed +format (for when you want to read that stuff). Or you can combine those features +in whatever way you like. + +=back + +=head1 FUNCTIONAL INTERFACE + +Some documents are copied and modified from L<JSON::XS/FUNCTIONAL INTERFACE>. +C<to_json> and C<from_json> are additional functions. + +=head2 encode_json + + $json_text = encode_json $perl_scalar + +Converts the given Perl data structure to a UTF-8 encoded, binary string. + +This function call is functionally identical to: + + $json_text = JSON->new->utf8->encode($perl_scalar) + +=head2 decode_json + + $perl_scalar = decode_json $json_text + +The opposite of C<encode_json>: expects an UTF-8 (binary) string and tries +to parse that as an UTF-8 encoded JSON text, returning the resulting +reference. + +This function call is functionally identical to: + + $perl_scalar = JSON->new->utf8->decode($json_text) + + +=head2 to_json + + $json_text = to_json($perl_scalar) + +Converts the given Perl data structure to a json string. + +This function call is functionally identical to: + + $json_text = JSON->new->encode($perl_scalar) + +Takes a hash reference as the second. + + $json_text = to_json($perl_scalar, $flag_hashref) + +So, + + $json_text = to_json($perl_scalar, {utf8 => 1, pretty => 1}) + +equivalent to: + + $json_text = JSON->new->utf8(1)->pretty(1)->encode($perl_scalar) + +If you want to write a modern perl code which communicates to outer world, +you should use C<encode_json> (supposed that JSON data are encoded in UTF-8). + +=head2 from_json + + $perl_scalar = from_json($json_text) + +The opposite of C<to_json>: expects a json string and tries +to parse it, returning the resulting reference. + +This function call is functionally identical to: + + $perl_scalar = JSON->decode($json_text) + +Takes a hash reference as the second. + + $perl_scalar = from_json($json_text, $flag_hashref) + +So, + + $perl_scalar = from_json($json_text, {utf8 => 1}) + +equivalent to: + + $perl_scalar = JSON->new->utf8(1)->decode($json_text) + +If you want to write a modern perl code which communicates to outer world, +you should use C<decode_json> (supposed that JSON data are encoded in UTF-8). + +=head2 JSON::is_bool + + $is_boolean = JSON::is_bool($scalar) + +Returns true if the passed scalar represents either JSON::true or +JSON::false, two constants that act like C<1> and C<0> respectively +and are also used to represent JSON C<true> and C<false> in Perl strings. + +=head2 JSON::true + +Returns JSON true value which is blessed object. +It C<isa> JSON::Boolean object. + +=head2 JSON::false + +Returns JSON false value which is blessed object. +It C<isa> JSON::Boolean object. + +=head2 JSON::null + +Returns C<undef>. + +See L<MAPPING>, below, for more information on how JSON values are mapped to +Perl. + +=head1 HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER + +This section supposes that your perl version is 5.8 or later. + +If you know a JSON text from an outer world - a network, a file content, and so on, +is encoded in UTF-8, you should use C<decode_json> or C<JSON> module object +with C<utf8> enable. And the decoded result will contain UNICODE characters. + + # from network + my $json = JSON->new->utf8; + my $json_text = CGI->new->param( 'json_data' ); + my $perl_scalar = $json->decode( $json_text ); + + # from file content + local $/; + open( my $fh, '<', 'json.data' ); + $json_text = <$fh>; + $perl_scalar = decode_json( $json_text ); + +If an outer data is not encoded in UTF-8, firstly you should C<decode> it. + + use Encode; + local $/; + open( my $fh, '<', 'json.data' ); + my $encoding = 'cp932'; + my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE + + # or you can write the below code. + # + # open( my $fh, "<:encoding($encoding)", 'json.data' ); + # $unicode_json_text = <$fh>; + +In this case, C<$unicode_json_text> is of course UNICODE string. +So you B<cannot> use C<decode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable or C<from_json>. + + $perl_scalar = $json->utf8(0)->decode( $unicode_json_text ); + # or + $perl_scalar = from_json( $unicode_json_text ); + +Or C<encode 'utf8'> and C<decode_json>: + + $perl_scalar = decode_json( encode( 'utf8', $unicode_json_text ) ); + # this way is not efficient. + +And now, you want to convert your C<$perl_scalar> into JSON data and +send it to an outer world - a network or a file content, and so on. + +Your data usually contains UNICODE strings and you want the converted data to be encoded +in UTF-8, you should use C<encode_json> or C<JSON> module object with C<utf8> enable. + + print encode_json( $perl_scalar ); # to a network? file? or display? + # or + print $json->utf8->encode( $perl_scalar ); + +If C<$perl_scalar> does not contain UNICODE but C<$encoding>-encoded strings +for some reason, then its characters are regarded as B<latin1> for perl +(because it does not concern with your $encoding). +You B<cannot> use C<encode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable or C<to_json>. +Note that the resulted text is a UNICODE string but no problem to print it. + + # $perl_scalar contains $encoding encoded string values + $unicode_json_text = $json->utf8(0)->encode( $perl_scalar ); + # or + $unicode_json_text = to_json( $perl_scalar ); + # $unicode_json_text consists of characters less than 0x100 + print $unicode_json_text; + +Or C<decode $encoding> all string values and C<encode_json>: + + $perl_scalar->{ foo } = decode( $encoding, $perl_scalar->{ foo } ); + # ... do it to each string values, then encode_json + $json_text = encode_json( $perl_scalar ); + +This method is a proper way but probably not efficient. + +See to L<Encode>, L<perluniintro>. + + +=head1 COMMON OBJECT-ORIENTED INTERFACE + +=head2 new + + $json = JSON->new + +Returns a new C<JSON> object inherited from either JSON::XS or JSON::PP +that can be used to de/encode JSON strings. + +All boolean flags described below are by default I<disabled>. + +The mutators for flags all return the JSON object again and thus calls can +be chained: + + my $json = JSON->new->utf8->space_after->encode({a => [1,2]}) + => {"a": [1, 2]} + +=head2 ascii + + $json = $json->ascii([$enable]) + + $enabled = $json->get_ascii + +If $enable is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627. + +If $enable is false, then the encode method will not escape Unicode characters unless +required by the JSON syntax or other flags. This results in a faster and more compact format. + +This feature depends on the used Perl version and environment. + +See to L<JSON::PP/UNICODE HANDLING ON PERLS> if the backend is PP. + + JSON->new->ascii(1)->encode([chr 0x10401]) + => ["\ud801\udc01"] + +=head2 latin1 + + $json = $json->latin1([$enable]) + + $enabled = $json->get_latin1 + +If $enable is true (or missing), then the encode method will encode the resulting JSON +text as latin1 (or iso-8859-1), escaping any characters outside the code range 0..255. + +If $enable is false, then the encode method will not escape Unicode characters +unless required by the JSON syntax or other flags. + + JSON->new->latin1->encode (["\x{89}\x{abc}"] + => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not) + +=head2 utf8 + + $json = $json->utf8([$enable]) + + $enabled = $json->get_utf8 + +If $enable is true (or missing), then the encode method will encode the JSON result +into UTF-8, as required by many protocols, while the decode method expects to be handled +an UTF-8-encoded string. Please note that UTF-8-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. + +In future versions, enabling this option might enable autodetection of the UTF-16 and UTF-32 +encoding families, as described in RFC4627. + +If $enable is false, then the encode method will return the JSON string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to UTF-8 or UTF-16) needs to be done yourself, e.g. using the Encode module. + + +Example, output UTF-16BE-encoded JSON: + + use Encode; + $jsontext = encode "UTF-16BE", JSON::XS->new->encode ($object); + +Example, decode UTF-32LE-encoded JSON: + + use Encode; + $object = JSON::XS->new->decode (decode "UTF-32LE", $jsontext); + +See to L<JSON::PP/UNICODE HANDLING ON PERLS> if the backend is PP. + + +=head2 pretty + + $json = $json->pretty([$enable]) + +This enables (or disables) all of the C<indent>, C<space_before> and +C<space_after> (and in the future possibly more) flags in one call to +generate the most readable (or most compact) form possible. + +Equivalent to: + + $json->indent->space_before->space_after + +The indent space length is three and JSON::XS cannot change the indent +space length. + +=head2 indent + + $json = $json->indent([$enable]) + + $enabled = $json->get_indent + +If C<$enable> is true (or missing), then the C<encode> method will use a multiline +format as output, putting every array member or object/hash key-value pair +into its own line, identifying them properly. + +If C<$enable> is false, no newlines or indenting will be produced, and the +resulting JSON text is guaranteed not to contain any C<newlines>. + +This setting has no effect when decoding JSON texts. + +The indent space length is three. +With JSON::PP, you can also access C<indent_length> to change indent space length. + + +=head2 space_before + + $json = $json->space_before([$enable]) + + $enabled = $json->get_space_before + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space before the C<:> separating keys from values in JSON objects. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before enabled, space_after and indent disabled: + + {"key" :"value"} + + +=head2 space_after + + $json = $json->space_after([$enable]) + + $enabled = $json->get_space_after + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space after the C<:> separating keys from values in JSON objects +and extra whitespace after the C<,> separating key-value pairs and array +members. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before and indent disabled, space_after enabled: + + {"key": "value"} + + +=head2 relaxed + + $json = $json->relaxed([$enable]) + + $enabled = $json->get_relaxed + +If C<$enable> is true (or missing), then C<decode> will accept some +extensions to normal JSON syntax (see below). C<encode> will not be +affected in anyway. I<Be aware that this option makes you accept invalid +JSON texts as if they were valid!>. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) + +If C<$enable> is false (the default), then C<decode> will only accept +valid JSON texts. + +Currently accepted extensions are: + +=over 4 + +=item * list items can have an end-comma + +JSON I<separates> array elements and key-value pairs with commas. This +can be annoying if you write JSON texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: + + [ + 1, + 2, <- this comma not normally allowed + ] + { + "k1": "v1", + "k2": "v2", <- this comma not normally allowed + } + +=item * shell-style '#'-comments + +Whenever JSON allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. + + [ + 1, # this comment not allowed in JSON + # neither this one... + ] + +=back + + +=head2 canonical + + $json = $json->canonical([$enable]) + + $enabled = $json->get_canonical + +If C<$enable> is true (or missing), then the C<encode> method will output JSON objects +by sorting their keys. This is adding a comparatively high overhead. + +If C<$enable> is false, then the C<encode> method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). + +This option is useful if you want the same data structure to be encoded as +the same JSON text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. + +This setting has no effect when decoding JSON texts. + +=head2 allow_nonref + + $json = $json->allow_nonref([$enable]) + + $enabled = $json->get_allow_nonref + +If C<$enable> is true (or missing), then the C<encode> method can convert a +non-reference into its corresponding string, number or null JSON value, +which is an extension to RFC4627. Likewise, C<decode> will accept those JSON +values instead of croaking. + +If C<$enable> is false, then the C<encode> method will croak if it isn't +passed an arrayref or hashref, as JSON texts must either be an object +or array. Likewise, C<decode> will croak if given something that is not a +JSON object or array. + + JSON->new->allow_nonref->encode ("Hello, World!") + => "Hello, World!" + +=head2 allow_unknown + + $json = $json->allow_unknown ([$enable]) + + $enabled = $json->get_allow_unknown + +If $enable is true (or missing), then "encode" will *not* throw an +exception when it encounters values it cannot represent in JSON (for +example, filehandles) but instead will encode a JSON "null" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. + +If $enable is false (the default), then "encode" will throw an +exception when it encounters anything it cannot encode as JSON. + +This option does not affect "decode" in any way, and it is +recommended to leave it off unless you know your communications +partner. + +=head2 allow_blessed + + $json = $json->allow_blessed([$enable]) + + $enabled = $json->get_allow_blessed + +If C<$enable> is true (or missing), then the C<encode> method will not +barf when it encounters a blessed reference. Instead, the value of the +B<convert_blessed> option will decide whether C<null> (C<convert_blessed> +disabled or no C<TO_JSON> method found) or a representation of the +object (C<convert_blessed> enabled and C<TO_JSON> method found) is being +encoded. Has no effect on C<decode>. + +If C<$enable> is false (the default), then C<encode> will throw an +exception when it encounters a blessed object. + + +=head2 convert_blessed + + $json = $json->convert_blessed([$enable]) + + $enabled = $json->get_convert_blessed + +If C<$enable> is true (or missing), then C<encode>, upon encountering a +blessed object, will check for the availability of the C<TO_JSON> method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +C<TO_JSON> method is found, the value of C<allow_blessed> will decide what +to do. + +The C<TO_JSON> method may safely call die if it wants. If C<TO_JSON> +returns other blessed objects, those will be handled in the same +way. C<TO_JSON> must take care of not causing an endless recursion cycle +(== crash) in this case. The name of C<TO_JSON> was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the C<to_json> +function or method. + +This setting does not yet influence C<decode> in any way. + +If C<$enable> is false, then the C<allow_blessed> setting will decide what +to do when a blessed object is found. + +=over + +=item convert_blessed_universally mode + +If use C<JSON> with C<-convert_blessed_universally>, the C<UNIVERSAL::TO_JSON> +subroutine is defined as the below code: + + *UNIVERSAL::TO_JSON = sub { + my $b_obj = B::svref_2object( $_[0] ); + return $b_obj->isa('B::HV') ? { %{ $_[0] } } + : $b_obj->isa('B::AV') ? [ @{ $_[0] } ] + : undef + ; + } + +This will cause that C<encode> method converts simple blessed objects into +JSON objects as non-blessed object. + + JSON -convert_blessed_universally; + $json->allow_blessed->convert_blessed->encode( $blessed_object ) + +This feature is experimental and may be removed in the future. + +=back + +=head2 filter_json_object + + $json = $json->filter_json_object([$coderef]) + +When C<$coderef> is specified, it will be called from C<decode> each +time it decodes a JSON object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(NOTE: I<not> C<undef>, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. + +When C<$coderef> is omitted or undefined, any existing callback will +be removed and C<decode> will not change the deserialised hash in any +way. + +Example, convert all JSON objects into the integer 5: + + my $js = JSON->new->filter_json_object (sub { 5 }); + # returns [5] + $js->decode ('[{}]'); # the given subroutine takes a hash reference. + # throw an exception because allow_nonref is not enabled + # so a lone 5 is not allowed. + $js->decode ('{"a":1, "b":2}'); + + +=head2 filter_json_single_key_object + + $json = $json->filter_json_single_key_object($key [=> $coderef]) + +Works remotely similar to C<filter_json_object>, but is only called for +JSON objects having a single key named C<$key>. + +This C<$coderef> is called before the one specified via +C<filter_json_object>, if any. It gets passed the single value in the JSON +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even C<undef> but the empty list), +the callback from C<filter_json_object> will be called next, as if no +single-key callback were specified. + +If C<$coderef> is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. + +As this callback gets called less often then the C<filter_json_object> +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key JSON objects are as close to the type-tagged value concept +as JSON gets (it's basically an ID/VALUE tuple). Of course, JSON does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. + +Typical names for the single object key are C<__class_whatever__>, or +C<$__dollars_are_rarely_used__$> or C<}ugly_brace_placement>, or even +things like C<__class_md5sum(classname)__>, to reduce the risk of clashing +with real hashes. + +Example, decode JSON objects of the form C<< { "__widget__" => <id> } >> +into the corresponding C<< $WIDGET{<id>} >> object: + + # return whatever is in $WIDGET{5}: + JSON + ->new + ->filter_json_single_key_object (__widget__ => sub { + $WIDGET{ $_[0] } + }) + ->decode ('{"__widget__": 5') + + # this can be used with a TO_JSON method in some "widget" class + # for serialisation to json: + sub WidgetBase::TO_JSON { + my ($self) = @_; + + unless ($self->{id}) { + $self->{id} = ..get..some..id..; + $WIDGET{$self->{id}} = $self; + } + + { __widget__ => $self->{id} } + } + + +=head2 shrink + + $json = $json->shrink([$enable]) + + $enabled = $json->get_shrink + +With JSON::XS, this flag resizes strings generated by either +C<encode> or C<decode> to their minimum size possible. This can save +memory when your JSON texts are either very very long or you have many +short strings. It will also try to downgrade any strings to octet-form +if possible: perl stores strings internally either in an encoding called +UTF-X or in octet-form. The latter cannot store everything but uses less +space in general (and some buggy Perl or C code might even rely on that +internal representation being used). + +With JSON::PP, it is noop about resizing strings but tries +C<utf8::downgrade> to the returned string by C<encode>. See to L<utf8>. + +See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> and L<JSON::PP/METHODS>. + +=head2 max_depth + + $json = $json->max_depth([$maximum_nesting_depth]) + + $max_depth = $json->get_max_depth + +Sets the maximum nesting level (default C<512>) accepted while encoding +or decoding. If a higher nesting level is detected in JSON text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. + +Nesting level is defined by number of hash- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of C<{> or C<[> +characters without their matching closing parenthesis crossed to reach a +given character in a string. + +If no argument is given, the highest possible setting will be used, which +is rarely useful. + +Note that nesting is implemented by recursion in C. The default value has +been chosen to be as large as typical operating systems allow without +crashing. (JSON::XS) + +With JSON::PP as the backend, when a large value (100 or more) was set and +it de/encodes a deep nested object/text, it may raise a warning +'Deep recursion on subroutine' at the perl runtime phase. + +See L<JSON::XS/SECURITY CONSIDERATIONS> for more info on why this is useful. + +=head2 max_size + + $json = $json->max_size([$maximum_string_size]) + + $max_size = $json->get_max_size + +Set the maximum length a JSON text may have (in bytes) where decoding is +being attempted. The default is C<0>, meaning no limit. When C<decode> +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on C<encode> (yet). + +If no argument is given, the limit check will be deactivated (same as when +C<0> is specified). + +See L<JSON::XS/SECURITY CONSIDERATIONS>, below, for more info on why this is useful. + +=head2 encode + + $json_text = $json->encode($perl_scalar) + +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its JSON representation. Simple scalars will be +converted into JSON string or number sequences, while references to arrays +become JSON arrays and references to hashes become JSON objects. Undefined +Perl values (e.g. C<undef>) become JSON C<null> values. +References to the integers C<0> and C<1> are converted into C<true> and C<false>. + +=head2 decode + + $perl_scalar = $json->decode($json_text) + +The opposite of C<encode>: expects a JSON text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. + +JSON numbers and strings become simple Perl scalars. JSON arrays become +Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes +C<1> (C<JSON::true>), C<false> becomes C<0> (C<JSON::false>) and +C<null> becomes C<undef>. + +=head2 decode_prefix + + ($perl_scalar, $characters) = $json->decode_prefix($json_text) + +This works like the C<decode> method, but instead of raising an exception +when there is trailing garbage after the first JSON object, it will +silently stop parsing there and return the number of characters consumed +so far. + + JSON->new->decode_prefix ("[1] the tail") + => ([], 3) + +See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> + +=head2 property + + $boolean = $json->property($property_name) + +Returns a boolean value about above some properties. + +The available properties are C<ascii>, C<latin1>, C<utf8>, +C<indent>,C<space_before>, C<space_after>, C<relaxed>, C<canonical>, +C<allow_nonref>, C<allow_unknown>, C<allow_blessed>, C<convert_blessed>, +C<shrink>, C<max_depth> and C<max_size>. + + $boolean = $json->property('utf8'); + => 0 + $json->utf8; + $boolean = $json->property('utf8'); + => 1 + +Sets the property with a given boolean value. + + $json = $json->property($property_name => $boolean); + +With no argument, it returns all the above properties as a hash reference. + + $flag_hashref = $json->property(); + +=head1 INCREMENTAL PARSING + +Most of this section are copied and modified from L<JSON::XS/INCREMENTAL PARSING>. + +In some cases, there is the need for incremental parsing of JSON texts. +This module does allow you to parse a JSON stream incrementally. +It does so by accumulating text until it has a full JSON object, which +it then can decode. This process is similar to using C<decode_prefix> +to see if a full JSON object is available, but is much more efficient +(and can be implemented with a minimum of method calls). + +The backend module will only attempt to parse the JSON text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid JSON text has been seen. This means you need +to set resource limits (e.g. C<max_size>) to ensure the parser will stop +parsing in the presence if syntax errors. + +The following methods implement this incremental parser. + +=head2 incr_parse + + $json->incr_parse( [$string] ) # void context + + $obj_or_undef = $json->incr_parse( [$string] ) # scalar context + + @obj_or_empty = $json->incr_parse( [$string] ) # list context + +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). + +If C<$string> is given, then this string is appended to the already +existing JSON fragment stored in the C<$json> object. + +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. + +If the method is called in scalar context, then it will try to extract +exactly I<one> JSON object. If that is successful, it will return this +object, otherwise it will return C<undef>. If there is a parse error, +this method will croak just as C<decode> would do (one can then use +C<incr_skip> to skip the erroneous part). This is the most common way of +using the method. + +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the JSON +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed JSON texts will be +lost. + +Example: Parse some JSON arrays/objects in a given string and return them. + + my @objs = JSON->new->incr_parse ("[5][7][1,2]"); + +=head2 incr_text + + $lvalue_string = $json->incr_text + +This method returns the currently stored JSON fragment as an lvalue, that +is, you can manipulate it. This I<only> works when a preceding call to +C<incr_parse> in I<scalar context> successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it I<will> fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. + +This function is useful in two cases: a) finding the trailing text after a +JSON object or b) parsing multiple JSON objects separated by non-JSON text +(such as commas). + + $json->incr_text =~ s/\s*,\s*//; + +In Perl 5.005, C<lvalue> attribute is not available. +You must write codes like the below: + + $string = $json->incr_text; + $string =~ s/\s*,\s*//; + $json->incr_text( $string ); + +=head2 incr_skip + + $json->incr_skip + +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after C<incr_parse> +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. + +=head2 incr_reset + + $json->incr_reset + +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. + +This is useful if you want to repeatedly parse JSON objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. + +See to L<JSON::XS/INCREMENTAL PARSING> for examples. + + +=head1 JSON::PP SUPPORT METHODS + +The below methods are JSON::PP own methods, so when C<JSON> works +with JSON::PP (i.e. the created object is a JSON::PP object), available. +See to L<JSON::PP/JSON::PP OWN METHODS> in detail. + +If you use C<JSON> with additional C<-support_by_pp>, some methods +are available even with JSON::XS. See to L<USE PP FEATURES EVEN THOUGH XS BACKEND>. + + BEING { $ENV{PERL_JSON_BACKEND} = 'JSON::XS' } + + use JSON -support_by_pp; + + my $json = JSON->new; + $json->allow_nonref->escape_slash->encode("/"); + + # functional interfaces too. + print to_json(["/"], {escape_slash => 1}); + print from_json('["foo"]', {utf8 => 1}); + +If you do not want to all functions but C<-support_by_pp>, +use C<-no_export>. + + use JSON -support_by_pp, -no_export; + # functional interfaces are not exported. + +=head2 allow_singlequote + + $json = $json->allow_singlequote([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +any JSON strings quoted by single quotations that are invalid JSON +format. + + $json->allow_singlequote->decode({"foo":'bar'}); + $json->allow_singlequote->decode({'foo':"bar"}); + $json->allow_singlequote->decode({'foo':'bar'}); + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + +=head2 allow_barekey + + $json = $json->allow_barekey([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +bare keys of JSON object that are invalid JSON format. + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + + $json->allow_barekey->decode('{foo:"bar"}'); + +=head2 allow_bignum + + $json = $json->allow_bignum([$enable]) + +If C<$enable> is true (or missing), then C<decode> will convert +the big integer Perl cannot handle as integer into a L<Math::BigInt> +object and convert a floating number (any) into a L<Math::BigFloat>. + +On the contrary, C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers with C<allow_blessed> enable. + + $json->allow_nonref->allow_blessed->allow_bignum; + $bigfloat = $json->decode('2.000000000000000000000000001'); + print $json->encode($bigfloat); + # => 2.000000000000000000000000001 + +See to L<MAPPING> about the conversion of JSON number. + +=head2 loose + + $json = $json->loose([$enable]) + +The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON strings +and the module doesn't allow to C<decode> to these (except for \x2f). +If C<$enable> is true (or missing), then C<decode> will accept these +unescaped strings. + + $json->loose->decode(qq|["abc + def"]|); + +See to L<JSON::PP/JSON::PP OWN METHODS>. + +=head2 escape_slash + + $json = $json->escape_slash([$enable]) + +According to JSON Grammar, I<slash> (U+002F) is escaped. But by default +JSON backend modules encode strings without escaping slash. + +If C<$enable> is true (or missing), then C<encode> will escape slashes. + +=head2 indent_length + + $json = $json->indent_length($length) + +With JSON::XS, The indent space length is 3 and cannot be changed. +With JSON::PP, it sets the indent space length with the given $length. +The default is 3. The acceptable range is 0 to 15. + +=head2 sort_by + + $json = $json->sort_by($function_name) + $json = $json->sort_by($subroutine_ref) + +If $function_name or $subroutine_ref are set, its sort routine are used. + + $js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + $js = $pc->sort_by('own_sort')->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } + +As the sorting routine runs in the JSON::PP scope, the given +subroutine name and the special variables C<$a>, C<$b> will begin +with 'JSON::PP::'. + +If $integer is set, then the effect is same as C<canonical> on. + +See to L<JSON::PP/JSON::PP OWN METHODS>. + +=head1 MAPPING + +This section is copied from JSON::XS and modified to C<JSON>. +JSON::XS and JSON::PP mapping mechanisms are almost equivalent. + +See to L<JSON::XS/MAPPING>. + +=head2 JSON -> PERL + +=over 4 + +=item object + +A JSON object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (JSON does not preserver object key ordering itself). + +=item array + +A JSON array becomes a reference to an array in Perl. + +=item string + +A JSON string becomes a string scalar in Perl - Unicode codepoints in JSON +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. + +=item number + +A JSON number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. + +If the number consists of digits only, C<JSON> will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the JSON number will be +re-encoded to a JSON string). + +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the JSON number will still be re-encoded as a JSON number). + +Note that precision is not accuracy - binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, C<JSON> only guarantees precision up to but not including +the least significant bit. + +If the backend is JSON::PP and C<allow_bignum> is enable, the big integers +and the numeric can be optionally converted into L<Math::BigInt> and +L<Math::BigFloat> objects. + +=item true, false + +These JSON atoms become C<JSON::true> and C<JSON::false>, +respectively. They are overloaded to act almost exactly like the numbers +C<1> and C<0>. You can check whether a scalar is a JSON boolean by using +the C<JSON::is_bool> function. + +If C<JSON::true> and C<JSON::false> are used as strings or compared as strings, +they represent as C<true> and C<false> respectively. + + print JSON::true . "\n"; + => true + print JSON::true + 1; + => 1 + + ok(JSON::true eq 'true'); + ok(JSON::true eq '1'); + ok(JSON::true == 1); + +C<JSON> will install these missing overloading features to the backend modules. + + +=item null + +A JSON null atom becomes C<undef> in Perl. + +C<JSON::null> returns C<undef>. + +=back + + +=head2 PERL -> JSON + +The mapping from Perl to JSON is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which JSON type is meant by +a Perl value. + +=over 4 + +=item hash references + +Perl hash references become JSON objects. As there is no inherent ordering +in hash keys (or JSON objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. C<JSON> +optionally sort the hash keys (determined by the I<canonical> flag), so +the same data structure will serialise to the same JSON text (given same +settings and version of JSON::XS), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some JSON text +against another for equality. + +In future, the ordered object feature will be added to JSON::PP using C<tie> mechanism. + + +=item array references + +Perl array references become JSON arrays. + +=item other references + +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers C<0> and +C<1>, which get turned into C<false> and C<true> atoms in JSON. You can +also use C<JSON::false> and C<JSON::true> to improve readability. + + to_json [\0,JSON::true] # yields [false,true] + +=item JSON::true, JSON::false, JSON::null + +These special values become JSON true and JSON false values, +respectively. You can also use C<\1> and C<\0> directly if you want. + +JSON::null returns C<undef>. + +=item blessed objects + +Blessed objects are not directly representable in JSON. See the +C<allow_blessed> and C<convert_blessed> methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. + +With C<convert_blessed_universally> mode, C<encode> converts blessed +hash references or blessed array references (contains other blessed references) +into JSON members and arrays. + + use JSON -convert_blessed_universally; + JSON->new->allow_blessed->convert_blessed->encode( $blessed_object ); + +See to L<convert_blessed>. + +=item simple scalars + +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: JSON::XS and JSON::PP will encode undefined scalars as +JSON C<null> values, scalars that have last been used in a string context +before encoding as JSON strings, and anything else as number value: + + # dump as number + encode_json [2] # yields [2] + encode_json [-3.0e17] # yields [-3e+17] + my $value = 5; encode_json [$value] # yields [5] + + # used as string, so dump as string + print $value; + encode_json [$value] # yields ["5"] + + # undef becomes null + encode_json [undef] # yields [null] + +You can force the type to be a string by stringifying it: + + my $x = 3.1; # some variable containing a number + "$x"; # stringified + $x .= ""; # another, more awkward way to stringify + print $x; # perl does it for you, too, quite often + +You can force the type to be a number by numifying it: + + my $x = "3"; # some variable containing a string + $x += 0; # numify it, ensuring it will be dumped as a number + $x *= 1; # same thing, the choice is yours. + +You can not currently force the type in other, less obscure, ways. + +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's - these cannot be represented in JSON, and it is an +error to pass those in. + +=item Big Number + +If the backend is JSON::PP and C<allow_bignum> is enable, +C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers. + + +=back + +=head1 JSON and ECMAscript + +See to L<JSON::XS/JSON and ECMAscript>. + +=head1 JSON and YAML + +JSON is not a subset of YAML. +See to L<JSON::XS/JSON and YAML>. + + +=head1 BACKEND MODULE DECISION + +When you use C<JSON>, C<JSON> tries to C<use> JSON::XS. If this call failed, it will +C<uses> JSON::PP. The required JSON::XS version is I<2.2> or later. + +The C<JSON> constructor method returns an object inherited from the backend module, +and JSON::XS object is a blessed scalar reference while JSON::PP is a blessed hash +reference. + +So, your program should not depend on the backend module, especially +returned objects should not be modified. + + my $json = JSON->new; # XS or PP? + $json->{stash} = 'this is xs object'; # this code may raise an error! + +To check the backend module, there are some methods - C<backend>, C<is_pp> and C<is_xs>. + + JSON->backend; # 'JSON::XS' or 'JSON::PP' + + JSON->backend->is_pp: # 0 or 1 + + JSON->backend->is_xs: # 1 or 0 + + $json->is_xs; # 1 or 0 + + $json->is_pp; # 0 or 1 + + +If you set an environment variable C<PERL_JSON_BACKEND>, the calling action will be changed. + +=over + +=item PERL_JSON_BACKEND = 0 or PERL_JSON_BACKEND = 'JSON::PP' + +Always use JSON::PP + +=item PERL_JSON_BACKEND == 1 or PERL_JSON_BACKEND = 'JSON::XS,JSON::PP' + +(The default) Use compiled JSON::XS if it is properly compiled & installed, +otherwise use JSON::PP. + +=item PERL_JSON_BACKEND == 2 or PERL_JSON_BACKEND = 'JSON::XS' + +Always use compiled JSON::XS, die if it isn't properly compiled & installed. + +=item PERL_JSON_BACKEND = 'JSON::backportPP' + +Always use JSON::backportPP. +JSON::backportPP is JSON::PP back port module. +C<JSON> includes JSON::backportPP instead of JSON::PP. + +=back + +These ideas come from L<DBI::PurePerl> mechanism. + +example: + + BEGIN { $ENV{PERL_JSON_BACKEND} = 'JSON::PP' } + use JSON; # always uses JSON::PP + +In future, it may be able to specify another module. + +=head1 USE PP FEATURES EVEN THOUGH XS BACKEND + +Many methods are available with either JSON::XS or JSON::PP and +when the backend module is JSON::XS, if any JSON::PP specific (i.e. JSON::XS unsupported) +method is called, it will C<warn> and be noop. + +But If you C<use> C<JSON> passing the optional string C<-support_by_pp>, +it makes a part of those unsupported methods available. +This feature is achieved by using JSON::PP in C<de/encode>. + + BEGIN { $ENV{PERL_JSON_BACKEND} = 2 } # with JSON::XS + use JSON -support_by_pp; + my $json = JSON->new; + $json->allow_nonref->escape_slash->encode("/"); + +At this time, the returned object is a C<JSON::Backend::XS::Supportable> +object (re-blessed XS object), and by checking JSON::XS unsupported flags +in de/encoding, can support some unsupported methods - C<loose>, C<allow_bignum>, +C<allow_barekey>, C<allow_singlequote>, C<escape_slash> and C<indent_length>. + +When any unsupported methods are not enable, C<XS de/encode> will be +used as is. The switch is achieved by changing the symbolic tables. + +C<-support_by_pp> is effective only when the backend module is JSON::XS +and it makes the de/encoding speed down a bit. + +See to L<JSON::PP SUPPORT METHODS>. + +=head1 INCOMPATIBLE CHANGES TO OLD VERSION + +There are big incompatibility between new version (2.00) and old (1.xx). +If you use old C<JSON> 1.xx in your code, please check it. + +See to L<Transition ways from 1.xx to 2.xx.> + +=over + +=item jsonToObj and objToJson are obsoleted. + +Non Perl-style name C<jsonToObj> and C<objToJson> are obsoleted +(but not yet deleted from the source). +If you use these functions in your code, please replace them +with C<from_json> and C<to_json>. + + +=item Global variables are no longer available. + +C<JSON> class variables - C<$JSON::AUTOCONVERT>, C<$JSON::BareKey>, etc... +- are not available any longer. +Instead, various features can be used through object methods. + + +=item Package JSON::Converter and JSON::Parser are deleted. + +Now C<JSON> bundles with JSON::PP which can handle JSON more properly than them. + +=item Package JSON::NotString is deleted. + +There was C<JSON::NotString> class which represents JSON value C<true>, C<false>, C<null> +and numbers. It was deleted and replaced by C<JSON::Boolean>. + +C<JSON::Boolean> represents C<true> and C<false>. + +C<JSON::Boolean> does not represent C<null>. + +C<JSON::null> returns C<undef>. + +C<JSON> makes L<JSON::XS::Boolean> and L<JSON::PP::Boolean> is-a relation +to L<JSON::Boolean>. + +=item function JSON::Number is obsoleted. + +C<JSON::Number> is now needless because JSON::XS and JSON::PP have +round-trip integrity. + +=item JSONRPC modules are deleted. + +Perl implementation of JSON-RPC protocol - C<JSONRPC >, C<JSONRPC::Transport::HTTP> +and C<Apache::JSONRPC > are deleted in this distribution. +Instead of them, there is L<JSON::RPC> which supports JSON-RPC protocol version 1.1. + +=back + +=head2 Transition ways from 1.xx to 2.xx. + +You should set C<suport_by_pp> mode firstly, because +it is always successful for the below codes even with JSON::XS. + + use JSON -support_by_pp; + +=over + +=item Exported jsonToObj (simple) + + from_json($json_text); + +=item Exported objToJson (simple) + + to_json($perl_scalar); + +=item Exported jsonToObj (advanced) + + $flags = {allow_barekey => 1, allow_singlequote => 1}; + from_json($json_text, $flags); + +equivalent to: + + $JSON::BareKey = 1; + $JSON::QuotApos = 1; + jsonToObj($json_text); + +=item Exported objToJson (advanced) + + $flags = {allow_blessed => 1, allow_barekey => 1}; + to_json($perl_scalar, $flags); + +equivalent to: + + $JSON::BareKey = 1; + objToJson($perl_scalar); + +=item jsonToObj as object method + + $json->decode($json_text); + +=item objToJson as object method + + $json->encode($perl_scalar); + +=item new method with parameters + +The C<new> method in 2.x takes any parameters no longer. +You can set parameters instead; + + $json = JSON->new->pretty; + +=item $JSON::Pretty, $JSON::Indent, $JSON::Delimiter + +If C<indent> is enable, that means C<$JSON::Pretty> flag set. And +C<$JSON::Delimiter> was substituted by C<space_before> and C<space_after>. +In conclusion: + + $json->indent->space_before->space_after; + +Equivalent to: + + $json->pretty; + +To change indent length, use C<indent_length>. + +(Only with JSON::PP, if C<-support_by_pp> is not used.) + + $json->pretty->indent_length(2)->encode($perl_scalar); + +=item $JSON::BareKey + +(Only with JSON::PP, if C<-support_by_pp> is not used.) + + $json->allow_barekey->decode($json_text) + +=item $JSON::ConvBlessed + +use C<-convert_blessed_universally>. See to L<convert_blessed>. + +=item $JSON::QuotApos + +(Only with JSON::PP, if C<-support_by_pp> is not used.) + + $json->allow_singlequote->decode($json_text) + +=item $JSON::SingleQuote + +Disable. C<JSON> does not make such a invalid JSON string any longer. + +=item $JSON::KeySort + + $json->canonical->encode($perl_scalar) + +This is the ascii sort. + +If you want to use with your own sort routine, check the C<sort_by> method. + +(Only with JSON::PP, even if C<-support_by_pp> is used currently.) + + $json->sort_by($sort_routine_ref)->encode($perl_scalar) + + $json->sort_by(sub { $JSON::PP::a <=> $JSON::PP::b })->encode($perl_scalar) + +Can't access C<$a> and C<$b> but C<$JSON::PP::a> and C<$JSON::PP::b>. + +=item $JSON::SkipInvalid + + $json->allow_unknown + +=item $JSON::AUTOCONVERT + +Needless. C<JSON> backend modules have the round-trip integrity. + +=item $JSON::UTF8 + +Needless because C<JSON> (JSON::XS/JSON::PP) sets +the UTF8 flag on properly. + + # With UTF8-flagged strings + + $json->allow_nonref; + $str = chr(1000); # UTF8-flagged + + $json_text = $json->utf8(0)->encode($str); + utf8::is_utf8($json_text); + # true + $json_text = $json->utf8(1)->encode($str); + utf8::is_utf8($json_text); + # false + + $str = '"' . chr(1000) . '"'; # UTF8-flagged + + $perl_scalar = $json->utf8(0)->decode($str); + utf8::is_utf8($perl_scalar); + # true + $perl_scalar = $json->utf8(1)->decode($str); + # died because of 'Wide character in subroutine' + +See to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL>. + +=item $JSON::UnMapping + +Disable. See to L<MAPPING>. + +=item $JSON::SelfConvert + +This option was deleted. +Instead of it, if a given blessed object has the C<TO_JSON> method, +C<TO_JSON> will be executed with C<convert_blessed>. + + $json->convert_blessed->encode($blessed_hashref_or_arrayref) + # if need, call allow_blessed + +Note that it was C<toJson> in old version, but now not C<toJson> but C<TO_JSON>. + +=back + +=head1 TODO + +=over + +=item example programs + +=back + +=head1 THREADS + +No test with JSON::PP. If with JSON::XS, See to L<JSON::XS/THREADS>. + + +=head1 BUGS + +Please report bugs relevant to C<JSON> to E<lt>makamaka[at]cpan.orgE<gt>. + + +=head1 SEE ALSO + +Most of the document is copied and modified from JSON::XS doc. + +L<JSON::XS>, L<JSON::PP> + +C<RFC4627>(L<http://www.ietf.org/rfc/rfc4627.txt>) + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + +JSON::XS was written by Marc Lehmann <schmorp[at]schmorp.de> + +The release of this new version owes to the courtesy of Marc Lehmann. + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2005-2013 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/JSON-2.59/lib/JSON/backportPP.pm b/third_party/JSON/JSON-2.59/lib/JSON/backportPP.pm new file mode 100644 index 0000000..cdf0c76 --- /dev/null +++ b/third_party/JSON/JSON-2.59/lib/JSON/backportPP.pm @@ -0,0 +1,2803 @@ +package # This is JSON::backportPP + JSON::PP; + +# JSON-2.0 + +use 5.005; +use strict; +use base qw(Exporter); +use overload (); + +use Carp (); +use B (); +#use Devel::Peek; + +use vars qw($VERSION); +$VERSION = '2.27202'; + +@JSON::PP::EXPORT = qw(encode_json decode_json from_json to_json); + +# instead of hash-access, i tried index-access for speed. +# but this method is not faster than what i expected. so it will be changed. + +use constant P_ASCII => 0; +use constant P_LATIN1 => 1; +use constant P_UTF8 => 2; +use constant P_INDENT => 3; +use constant P_CANONICAL => 4; +use constant P_SPACE_BEFORE => 5; +use constant P_SPACE_AFTER => 6; +use constant P_ALLOW_NONREF => 7; +use constant P_SHRINK => 8; +use constant P_ALLOW_BLESSED => 9; +use constant P_CONVERT_BLESSED => 10; +use constant P_RELAXED => 11; + +use constant P_LOOSE => 12; +use constant P_ALLOW_BIGNUM => 13; +use constant P_ALLOW_BAREKEY => 14; +use constant P_ALLOW_SINGLEQUOTE => 15; +use constant P_ESCAPE_SLASH => 16; +use constant P_AS_NONBLESSED => 17; + +use constant P_ALLOW_UNKNOWN => 18; + +use constant OLD_PERL => $] < 5.008 ? 1 : 0; + +BEGIN { + my @xs_compati_bit_properties = qw( + latin1 ascii utf8 indent canonical space_before space_after allow_nonref shrink + allow_blessed convert_blessed relaxed allow_unknown + ); + my @pp_bit_properties = qw( + allow_singlequote allow_bignum loose + allow_barekey escape_slash as_nonblessed + ); + + # Perl version check, Unicode handling is enable? + # Helper module sets @JSON::PP::_properties. + if ($] < 5.008 ) { + my $helper = $] >= 5.006 ? 'JSON::backportPP::Compat5006' : 'JSON::backportPP::Compat5005'; + eval qq| require $helper |; + if ($@) { Carp::croak $@; } + } + + for my $name (@xs_compati_bit_properties, @pp_bit_properties) { + my $flag_name = 'P_' . uc($name); + + eval qq/ + sub $name { + my \$enable = defined \$_[1] ? \$_[1] : 1; + + if (\$enable) { + \$_[0]->{PROPS}->[$flag_name] = 1; + } + else { + \$_[0]->{PROPS}->[$flag_name] = 0; + } + + \$_[0]; + } + + sub get_$name { + \$_[0]->{PROPS}->[$flag_name] ? 1 : ''; + } + /; + } + +} + + + +# Functions + +my %encode_allow_method + = map {($_ => 1)} qw/utf8 pretty allow_nonref latin1 self_encode escape_slash + allow_blessed convert_blessed indent indent_length allow_bignum + as_nonblessed + /; +my %decode_allow_method + = map {($_ => 1)} qw/utf8 allow_nonref loose allow_singlequote allow_bignum + allow_barekey max_size relaxed/; + + +my $JSON; # cache + +sub encode_json ($) { # encode + ($JSON ||= __PACKAGE__->new->utf8)->encode(@_); +} + + +sub decode_json { # decode + ($JSON ||= __PACKAGE__->new->utf8)->decode(@_); +} + +# Obsoleted + +sub to_json($) { + Carp::croak ("JSON::PP::to_json has been renamed to encode_json."); +} + + +sub from_json($) { + Carp::croak ("JSON::PP::from_json has been renamed to decode_json."); +} + + +# Methods + +sub new { + my $class = shift; + my $self = { + max_depth => 512, + max_size => 0, + indent => 0, + FLAGS => 0, + fallback => sub { encode_error('Invalid value. JSON can only reference.') }, + indent_length => 3, + }; + + bless $self, $class; +} + + +sub encode { + return $_[0]->PP_encode_json($_[1]); +} + + +sub decode { + return $_[0]->PP_decode_json($_[1], 0x00000000); +} + + +sub decode_prefix { + return $_[0]->PP_decode_json($_[1], 0x00000001); +} + + +# accessor + + +# pretty printing + +sub pretty { + my ($self, $v) = @_; + my $enable = defined $v ? $v : 1; + + if ($enable) { # indent_length(3) for JSON::XS compatibility + $self->indent(1)->indent_length(3)->space_before(1)->space_after(1); + } + else { + $self->indent(0)->space_before(0)->space_after(0); + } + + $self; +} + +# etc + +sub max_depth { + my $max = defined $_[1] ? $_[1] : 0x80000000; + $_[0]->{max_depth} = $max; + $_[0]; +} + + +sub get_max_depth { $_[0]->{max_depth}; } + + +sub max_size { + my $max = defined $_[1] ? $_[1] : 0; + $_[0]->{max_size} = $max; + $_[0]; +} + + +sub get_max_size { $_[0]->{max_size}; } + + +sub filter_json_object { + $_[0]->{cb_object} = defined $_[1] ? $_[1] : 0; + $_[0]->{F_HOOK} = ($_[0]->{cb_object} or $_[0]->{cb_sk_object}) ? 1 : 0; + $_[0]; +} + +sub filter_json_single_key_object { + if (@_ > 1) { + $_[0]->{cb_sk_object}->{$_[1]} = $_[2]; + } + $_[0]->{F_HOOK} = ($_[0]->{cb_object} or $_[0]->{cb_sk_object}) ? 1 : 0; + $_[0]; +} + +sub indent_length { + if (!defined $_[1] or $_[1] > 15 or $_[1] < 0) { + Carp::carp "The acceptable range of indent_length() is 0 to 15."; + } + else { + $_[0]->{indent_length} = $_[1]; + } + $_[0]; +} + +sub get_indent_length { + $_[0]->{indent_length}; +} + +sub sort_by { + $_[0]->{sort_by} = defined $_[1] ? $_[1] : 1; + $_[0]; +} + +sub allow_bigint { + Carp::carp("allow_bigint() is obsoleted. use allow_bignum() insted."); +} + +############################### + +### +### Perl => JSON +### + + +{ # Convert + + my $max_depth; + my $indent; + my $ascii; + my $latin1; + my $utf8; + my $space_before; + my $space_after; + my $canonical; + my $allow_blessed; + my $convert_blessed; + + my $indent_length; + my $escape_slash; + my $bignum; + my $as_nonblessed; + + my $depth; + my $indent_count; + my $keysort; + + + sub PP_encode_json { + my $self = shift; + my $obj = shift; + + $indent_count = 0; + $depth = 0; + + my $idx = $self->{PROPS}; + + ($ascii, $latin1, $utf8, $indent, $canonical, $space_before, $space_after, $allow_blessed, + $convert_blessed, $escape_slash, $bignum, $as_nonblessed) + = @{$idx}[P_ASCII .. P_SPACE_AFTER, P_ALLOW_BLESSED, P_CONVERT_BLESSED, + P_ESCAPE_SLASH, P_ALLOW_BIGNUM, P_AS_NONBLESSED]; + + ($max_depth, $indent_length) = @{$self}{qw/max_depth indent_length/}; + + $keysort = $canonical ? sub { $a cmp $b } : undef; + + if ($self->{sort_by}) { + $keysort = ref($self->{sort_by}) eq 'CODE' ? $self->{sort_by} + : $self->{sort_by} =~ /\D+/ ? $self->{sort_by} + : sub { $a cmp $b }; + } + + encode_error("hash- or arrayref expected (not a simple scalar, use allow_nonref to allow this)") + if(!ref $obj and !$idx->[ P_ALLOW_NONREF ]); + + my $str = $self->object_to_json($obj); + + $str .= "\n" if ( $indent ); # JSON::XS 2.26 compatible + + unless ($ascii or $latin1 or $utf8) { + utf8::upgrade($str); + } + + if ($idx->[ P_SHRINK ]) { + utf8::downgrade($str, 1); + } + + return $str; + } + + + sub object_to_json { + my ($self, $obj) = @_; + my $type = ref($obj); + + if($type eq 'HASH'){ + return $self->hash_to_json($obj); + } + elsif($type eq 'ARRAY'){ + return $self->array_to_json($obj); + } + elsif ($type) { # blessed object? + if (blessed($obj)) { + + return $self->value_to_json($obj) if ( $obj->isa('JSON::PP::Boolean') ); + + if ( $convert_blessed and $obj->can('TO_JSON') ) { + my $result = $obj->TO_JSON(); + if ( defined $result and ref( $result ) ) { + if ( refaddr( $obj ) eq refaddr( $result ) ) { + encode_error( sprintf( + "%s::TO_JSON method returned same object as was passed instead of a new one", + ref $obj + ) ); + } + } + + return $self->object_to_json( $result ); + } + + return "$obj" if ( $bignum and _is_bignum($obj) ); + return $self->blessed_to_json($obj) if ($allow_blessed and $as_nonblessed); # will be removed. + + encode_error( sprintf("encountered object '%s', but neither allow_blessed " + . "nor convert_blessed settings are enabled", $obj) + ) unless ($allow_blessed); + + return 'null'; + } + else { + return $self->value_to_json($obj); + } + } + else{ + return $self->value_to_json($obj); + } + } + + + sub hash_to_json { + my ($self, $obj) = @_; + my @res; + + encode_error("json text or perl structure exceeds maximum nesting level (max_depth set too low?)") + if (++$depth > $max_depth); + + my ($pre, $post) = $indent ? $self->_up_indent() : ('', ''); + my $del = ($space_before ? ' ' : '') . ':' . ($space_after ? ' ' : ''); + + for my $k ( _sort( $obj ) ) { + if ( OLD_PERL ) { utf8::decode($k) } # key for Perl 5.6 / be optimized + push @res, string_to_json( $self, $k ) + . $del + . ( $self->object_to_json( $obj->{$k} ) || $self->value_to_json( $obj->{$k} ) ); + } + + --$depth; + $self->_down_indent() if ($indent); + + return '{' . ( @res ? $pre : '' ) . ( @res ? join( ",$pre", @res ) . $post : '' ) . '}'; + } + + + sub array_to_json { + my ($self, $obj) = @_; + my @res; + + encode_error("json text or perl structure exceeds maximum nesting level (max_depth set too low?)") + if (++$depth > $max_depth); + + my ($pre, $post) = $indent ? $self->_up_indent() : ('', ''); + + for my $v (@$obj){ + push @res, $self->object_to_json($v) || $self->value_to_json($v); + } + + --$depth; + $self->_down_indent() if ($indent); + + return '[' . ( @res ? $pre : '' ) . ( @res ? join( ",$pre", @res ) . $post : '' ) . ']'; + } + + + sub value_to_json { + my ($self, $value) = @_; + + return 'null' if(!defined $value); + + my $b_obj = B::svref_2object(\$value); # for round trip problem + my $flags = $b_obj->FLAGS; + + return $value # as is + if $flags & ( B::SVp_IOK | B::SVp_NOK ) and !( $flags & B::SVp_POK ); # SvTYPE is IV or NV? + + my $type = ref($value); + + if(!$type){ + return string_to_json($self, $value); + } + elsif( blessed($value) and $value->isa('JSON::PP::Boolean') ){ + return $$value == 1 ? 'true' : 'false'; + } + elsif ($type) { + if ((overload::StrVal($value) =~ /=(\w+)/)[0]) { + return $self->value_to_json("$value"); + } + + if ($type eq 'SCALAR' and defined $$value) { + return $$value eq '1' ? 'true' + : $$value eq '0' ? 'false' + : $self->{PROPS}->[ P_ALLOW_UNKNOWN ] ? 'null' + : encode_error("cannot encode reference to scalar"); + } + + if ( $self->{PROPS}->[ P_ALLOW_UNKNOWN ] ) { + return 'null'; + } + else { + if ( $type eq 'SCALAR' or $type eq 'REF' ) { + encode_error("cannot encode reference to scalar"); + } + else { + encode_error("encountered $value, but JSON can only represent references to arrays or hashes"); + } + } + + } + else { + return $self->{fallback}->($value) + if ($self->{fallback} and ref($self->{fallback}) eq 'CODE'); + return 'null'; + } + + } + + + my %esc = ( + "\n" => '\n', + "\r" => '\r', + "\t" => '\t', + "\f" => '\f', + "\b" => '\b', + "\"" => '\"', + "\\" => '\\\\', + "\'" => '\\\'', + ); + + + sub string_to_json { + my ($self, $arg) = @_; + + $arg =~ s/([\x22\x5c\n\r\t\f\b])/$esc{$1}/g; + $arg =~ s/\//\\\//g if ($escape_slash); + $arg =~ s/([\x00-\x08\x0b\x0e-\x1f])/'\\u00' . unpack('H2', $1)/eg; + + if ($ascii) { + $arg = JSON_PP_encode_ascii($arg); + } + + if ($latin1) { + $arg = JSON_PP_encode_latin1($arg); + } + + if ($utf8) { + utf8::encode($arg); + } + + return '"' . $arg . '"'; + } + + + sub blessed_to_json { + my $reftype = reftype($_[1]) || ''; + if ($reftype eq 'HASH') { + return $_[0]->hash_to_json($_[1]); + } + elsif ($reftype eq 'ARRAY') { + return $_[0]->array_to_json($_[1]); + } + else { + return 'null'; + } + } + + + sub encode_error { + my $error = shift; + Carp::croak "$error"; + } + + + sub _sort { + defined $keysort ? (sort $keysort (keys %{$_[0]})) : keys %{$_[0]}; + } + + + sub _up_indent { + my $self = shift; + my $space = ' ' x $indent_length; + + my ($pre,$post) = ('',''); + + $post = "\n" . $space x $indent_count; + + $indent_count++; + + $pre = "\n" . $space x $indent_count; + + return ($pre,$post); + } + + + sub _down_indent { $indent_count--; } + + + sub PP_encode_box { + { + depth => $depth, + indent_count => $indent_count, + }; + } + +} # Convert + + +sub _encode_ascii { + join('', + map { + $_ <= 127 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', _encode_surrogates($_)); + } unpack('U*', $_[0]) + ); +} + + +sub _encode_latin1 { + join('', + map { + $_ <= 255 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', _encode_surrogates($_)); + } unpack('U*', $_[0]) + ); +} + + +sub _encode_surrogates { # from perlunicode + my $uni = $_[0] - 0x10000; + return ($uni / 0x400 + 0xD800, $uni % 0x400 + 0xDC00); +} + + +sub _is_bignum { + $_[0]->isa('Math::BigInt') or $_[0]->isa('Math::BigFloat'); +} + + + +# +# JSON => Perl +# + +my $max_intsize; + +BEGIN { + my $checkint = 1111; + for my $d (5..64) { + $checkint .= 1; + my $int = eval qq| $checkint |; + if ($int =~ /[eE]/) { + $max_intsize = $d - 1; + last; + } + } +} + +{ # PARSE + + my %escapes = ( # by Jeremy Muhlich <jmuhlich [at] bitflood.org> + b => "\x8", + t => "\x9", + n => "\xA", + f => "\xC", + r => "\xD", + '\\' => '\\', + '"' => '"', + '/' => '/', + ); + + my $text; # json data + my $at; # offset + my $ch; # 1chracter + my $len; # text length (changed according to UTF8 or NON UTF8) + # INTERNAL + my $depth; # nest counter + my $encoding; # json text encoding + my $is_valid_utf8; # temp variable + my $utf8_len; # utf8 byte length + # FLAGS + my $utf8; # must be utf8 + my $max_depth; # max nest number of objects and arrays + my $max_size; + my $relaxed; + my $cb_object; + my $cb_sk_object; + + my $F_HOOK; + + my $allow_bigint; # using Math::BigInt + my $singlequote; # loosely quoting + my $loose; # + my $allow_barekey; # bareKey + + # $opt flag + # 0x00000001 .... decode_prefix + # 0x10000000 .... incr_parse + + sub PP_decode_json { + my ($self, $opt); # $opt is an effective flag during this decode_json. + + ($self, $text, $opt) = @_; + + ($at, $ch, $depth) = (0, '', 0); + + if ( !defined $text or ref $text ) { + decode_error("malformed JSON string, neither array, object, number, string or atom"); + } + + my $idx = $self->{PROPS}; + + ($utf8, $relaxed, $loose, $allow_bigint, $allow_barekey, $singlequote) + = @{$idx}[P_UTF8, P_RELAXED, P_LOOSE .. P_ALLOW_SINGLEQUOTE]; + + if ( $utf8 ) { + utf8::downgrade( $text, 1 ) or Carp::croak("Wide character in subroutine entry"); + } + else { + utf8::upgrade( $text ); + } + + $len = length $text; + + ($max_depth, $max_size, $cb_object, $cb_sk_object, $F_HOOK) + = @{$self}{qw/max_depth max_size cb_object cb_sk_object F_HOOK/}; + + if ($max_size > 1) { + use bytes; + my $bytes = length $text; + decode_error( + sprintf("attempted decode of JSON text of %s bytes size, but max_size is set to %s" + , $bytes, $max_size), 1 + ) if ($bytes > $max_size); + } + + # Currently no effect + # should use regexp + my @octets = unpack('C4', $text); + $encoding = ( $octets[0] and $octets[1]) ? 'UTF-8' + : (!$octets[0] and $octets[1]) ? 'UTF-16BE' + : (!$octets[0] and !$octets[1]) ? 'UTF-32BE' + : ( $octets[2] ) ? 'UTF-16LE' + : (!$octets[2] ) ? 'UTF-32LE' + : 'unknown'; + + white(); # remove head white space + + my $valid_start = defined $ch; # Is there a first character for JSON structure? + + my $result = value(); + + return undef if ( !$result && ( $opt & 0x10000000 ) ); # for incr_parse + + decode_error("malformed JSON string, neither array, object, number, string or atom") unless $valid_start; + + if ( !$idx->[ P_ALLOW_NONREF ] and !ref $result ) { + decode_error( + 'JSON text must be an object or array (but found number, string, true, false or null,' + . ' use allow_nonref to allow this)', 1); + } + + Carp::croak('something wrong.') if $len < $at; # we won't arrive here. + + my $consumed = defined $ch ? $at - 1 : $at; # consumed JSON text length + + white(); # remove tail white space + + if ( $ch ) { + return ( $result, $consumed ) if ($opt & 0x00000001); # all right if decode_prefix + decode_error("garbage after JSON object"); + } + + ( $opt & 0x00000001 ) ? ( $result, $consumed ) : $result; + } + + + sub next_chr { + return $ch = undef if($at >= $len); + $ch = substr($text, $at++, 1); + } + + + sub value { + white(); + return if(!defined $ch); + return object() if($ch eq '{'); + return array() if($ch eq '['); + return string() if($ch eq '"' or ($singlequote and $ch eq "'")); + return number() if($ch =~ /[0-9]/ or $ch eq '-'); + return word(); + } + + sub string { + my ($i, $s, $t, $u); + my $utf16; + my $is_utf8; + + ($is_valid_utf8, $utf8_len) = ('', 0); + + $s = ''; # basically UTF8 flag on + + if($ch eq '"' or ($singlequote and $ch eq "'")){ + my $boundChar = $ch; + + OUTER: while( defined(next_chr()) ){ + + if($ch eq $boundChar){ + next_chr(); + + if ($utf16) { + decode_error("missing low surrogate character in surrogate pair"); + } + + utf8::decode($s) if($is_utf8); + + return $s; + } + elsif($ch eq '\\'){ + next_chr(); + if(exists $escapes{$ch}){ + $s .= $escapes{$ch}; + } + elsif($ch eq 'u'){ # UNICODE handling + my $u = ''; + + for(1..4){ + $ch = next_chr(); + last OUTER if($ch !~ /[0-9a-fA-F]/); + $u .= $ch; + } + + # U+D800 - U+DBFF + if ($u =~ /^[dD][89abAB][0-9a-fA-F]{2}/) { # UTF-16 high surrogate? + $utf16 = $u; + } + # U+DC00 - U+DFFF + elsif ($u =~ /^[dD][c-fC-F][0-9a-fA-F]{2}/) { # UTF-16 low surrogate? + unless (defined $utf16) { + decode_error("missing high surrogate character in surrogate pair"); + } + $is_utf8 = 1; + $s .= JSON_PP_decode_surrogates($utf16, $u) || next; + $utf16 = undef; + } + else { + if (defined $utf16) { + decode_error("surrogate pair expected"); + } + + if ( ( my $hex = hex( $u ) ) > 127 ) { + $is_utf8 = 1; + $s .= JSON_PP_decode_unicode($u) || next; + } + else { + $s .= chr $hex; + } + } + + } + else{ + unless ($loose) { + $at -= 2; + decode_error('illegal backslash escape sequence in string'); + } + $s .= $ch; + } + } + else{ + + if ( ord $ch > 127 ) { + if ( $utf8 ) { + unless( $ch = is_valid_utf8($ch) ) { + $at -= 1; + decode_error("malformed UTF-8 character in JSON string"); + } + else { + $at += $utf8_len - 1; + } + } + else { + utf8::encode( $ch ); + } + + $is_utf8 = 1; + } + + if (!$loose) { + if ($ch =~ /[\x00-\x1f\x22\x5c]/) { # '/' ok + $at--; + decode_error('invalid character encountered while parsing JSON string'); + } + } + + $s .= $ch; + } + } + } + + decode_error("unexpected end of string while parsing JSON string"); + } + + + sub white { + while( defined $ch ){ + if($ch le ' '){ + next_chr(); + } + elsif($ch eq '/'){ + next_chr(); + if(defined $ch and $ch eq '/'){ + 1 while(defined(next_chr()) and $ch ne "\n" and $ch ne "\r"); + } + elsif(defined $ch and $ch eq '*'){ + next_chr(); + while(1){ + if(defined $ch){ + if($ch eq '*'){ + if(defined(next_chr()) and $ch eq '/'){ + next_chr(); + last; + } + } + else{ + next_chr(); + } + } + else{ + decode_error("Unterminated comment"); + } + } + next; + } + else{ + $at--; + decode_error("malformed JSON string, neither array, object, number, string or atom"); + } + } + else{ + if ($relaxed and $ch eq '#') { # correctly? + pos($text) = $at; + $text =~ /\G([^\n]*(?:\r\n|\r|\n|$))/g; + $at = pos($text); + next_chr; + next; + } + + last; + } + } + } + + + sub array { + my $a = $_[0] || []; # you can use this code to use another array ref object. + + decode_error('json text or perl structure exceeds maximum nesting level (max_depth set too low?)') + if (++$depth > $max_depth); + + next_chr(); + white(); + + if(defined $ch and $ch eq ']'){ + --$depth; + next_chr(); + return $a; + } + else { + while(defined($ch)){ + push @$a, value(); + + white(); + + if (!defined $ch) { + last; + } + + if($ch eq ']'){ + --$depth; + next_chr(); + return $a; + } + + if($ch ne ','){ + last; + } + + next_chr(); + white(); + + if ($relaxed and $ch eq ']') { + --$depth; + next_chr(); + return $a; + } + + } + } + + decode_error(", or ] expected while parsing array"); + } + + + sub object { + my $o = $_[0] || {}; # you can use this code to use another hash ref object. + my $k; + + decode_error('json text or perl structure exceeds maximum nesting level (max_depth set too low?)') + if (++$depth > $max_depth); + next_chr(); + white(); + + if(defined $ch and $ch eq '}'){ + --$depth; + next_chr(); + if ($F_HOOK) { + return _json_object_hook($o); + } + return $o; + } + else { + while (defined $ch) { + $k = ($allow_barekey and $ch ne '"' and $ch ne "'") ? bareKey() : string(); + white(); + + if(!defined $ch or $ch ne ':'){ + $at--; + decode_error("':' expected"); + } + + next_chr(); + $o->{$k} = value(); + white(); + + last if (!defined $ch); + + if($ch eq '}'){ + --$depth; + next_chr(); + if ($F_HOOK) { + return _json_object_hook($o); + } + return $o; + } + + if($ch ne ','){ + last; + } + + next_chr(); + white(); + + if ($relaxed and $ch eq '}') { + --$depth; + next_chr(); + if ($F_HOOK) { + return _json_object_hook($o); + } + return $o; + } + + } + + } + + $at--; + decode_error(", or } expected while parsing object/hash"); + } + + + sub bareKey { # doesn't strictly follow Standard ECMA-262 3rd Edition + my $key; + while($ch =~ /[^\x00-\x23\x25-\x2F\x3A-\x40\x5B-\x5E\x60\x7B-\x7F]/){ + $key .= $ch; + next_chr(); + } + return $key; + } + + + sub word { + my $word = substr($text,$at-1,4); + + if($word eq 'true'){ + $at += 3; + next_chr; + return $JSON::PP::true; + } + elsif($word eq 'null'){ + $at += 3; + next_chr; + return undef; + } + elsif($word eq 'fals'){ + $at += 3; + if(substr($text,$at,1) eq 'e'){ + $at++; + next_chr; + return $JSON::PP::false; + } + } + + $at--; # for decode_error report + + decode_error("'null' expected") if ($word =~ /^n/); + decode_error("'true' expected") if ($word =~ /^t/); + decode_error("'false' expected") if ($word =~ /^f/); + decode_error("malformed JSON string, neither array, object, number, string or atom"); + } + + + sub number { + my $n = ''; + my $v; + + # According to RFC4627, hex or oct digits are invalid. + if($ch eq '0'){ + my $peek = substr($text,$at,1); + my $hex = $peek =~ /[xX]/; # 0 or 1 + + if($hex){ + decode_error("malformed number (leading zero must not be followed by another digit)"); + ($n) = ( substr($text, $at+1) =~ /^([0-9a-fA-F]+)/); + } + else{ # oct + ($n) = ( substr($text, $at) =~ /^([0-7]+)/); + if (defined $n and length $n > 1) { + decode_error("malformed number (leading zero must not be followed by another digit)"); + } + } + + if(defined $n and length($n)){ + if (!$hex and length($n) == 1) { + decode_error("malformed number (leading zero must not be followed by another digit)"); + } + $at += length($n) + $hex; + next_chr; + return $hex ? hex($n) : oct($n); + } + } + + if($ch eq '-'){ + $n = '-'; + next_chr; + if (!defined $ch or $ch !~ /\d/) { + decode_error("malformed number (no digits after initial minus)"); + } + } + + while(defined $ch and $ch =~ /\d/){ + $n .= $ch; + next_chr; + } + + if(defined $ch and $ch eq '.'){ + $n .= '.'; + + next_chr; + if (!defined $ch or $ch !~ /\d/) { + decode_error("malformed number (no digits after decimal point)"); + } + else { + $n .= $ch; + } + + while(defined(next_chr) and $ch =~ /\d/){ + $n .= $ch; + } + } + + if(defined $ch and ($ch eq 'e' or $ch eq 'E')){ + $n .= $ch; + next_chr; + + if(defined($ch) and ($ch eq '+' or $ch eq '-')){ + $n .= $ch; + next_chr; + if (!defined $ch or $ch =~ /\D/) { + decode_error("malformed number (no digits after exp sign)"); + } + $n .= $ch; + } + elsif(defined($ch) and $ch =~ /\d/){ + $n .= $ch; + } + else { + decode_error("malformed number (no digits after exp sign)"); + } + + while(defined(next_chr) and $ch =~ /\d/){ + $n .= $ch; + } + + } + + $v .= $n; + + if ($v !~ /[.eE]/ and length $v > $max_intsize) { + if ($allow_bigint) { # from Adam Sussman + require Math::BigInt; + return Math::BigInt->new($v); + } + else { + return "$v"; + } + } + elsif ($allow_bigint) { + require Math::BigFloat; + return Math::BigFloat->new($v); + } + + return 0+$v; + } + + + sub is_valid_utf8 { + + $utf8_len = $_[0] =~ /[\x00-\x7F]/ ? 1 + : $_[0] =~ /[\xC2-\xDF]/ ? 2 + : $_[0] =~ /[\xE0-\xEF]/ ? 3 + : $_[0] =~ /[\xF0-\xF4]/ ? 4 + : 0 + ; + + return unless $utf8_len; + + my $is_valid_utf8 = substr($text, $at - 1, $utf8_len); + + return ( $is_valid_utf8 =~ /^(?: + [\x00-\x7F] + |[\xC2-\xDF][\x80-\xBF] + |[\xE0][\xA0-\xBF][\x80-\xBF] + |[\xE1-\xEC][\x80-\xBF][\x80-\xBF] + |[\xED][\x80-\x9F][\x80-\xBF] + |[\xEE-\xEF][\x80-\xBF][\x80-\xBF] + |[\xF0][\x90-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF4][\x80-\x8F][\x80-\xBF][\x80-\xBF] + )$/x ) ? $is_valid_utf8 : ''; + } + + + sub decode_error { + my $error = shift; + my $no_rep = shift; + my $str = defined $text ? substr($text, $at) : ''; + my $mess = ''; + my $type = $] >= 5.008 ? 'U*' + : $] < 5.006 ? 'C*' + : utf8::is_utf8( $str ) ? 'U*' # 5.6 + : 'C*' + ; + + for my $c ( unpack( $type, $str ) ) { # emulate pv_uni_display() ? + $mess .= $c == 0x07 ? '\a' + : $c == 0x09 ? '\t' + : $c == 0x0a ? '\n' + : $c == 0x0d ? '\r' + : $c == 0x0c ? '\f' + : $c < 0x20 ? sprintf('\x{%x}', $c) + : $c == 0x5c ? '\\\\' + : $c < 0x80 ? chr($c) + : sprintf('\x{%x}', $c) + ; + if ( length $mess >= 20 ) { + $mess .= '...'; + last; + } + } + + unless ( length $mess ) { + $mess = '(end of string)'; + } + + Carp::croak ( + $no_rep ? "$error" : "$error, at character offset $at (before \"$mess\")" + ); + + } + + + sub _json_object_hook { + my $o = $_[0]; + my @ks = keys %{$o}; + + if ( $cb_sk_object and @ks == 1 and exists $cb_sk_object->{ $ks[0] } and ref $cb_sk_object->{ $ks[0] } ) { + my @val = $cb_sk_object->{ $ks[0] }->( $o->{$ks[0]} ); + if (@val == 1) { + return $val[0]; + } + } + + my @val = $cb_object->($o) if ($cb_object); + if (@val == 0 or @val > 1) { + return $o; + } + else { + return $val[0]; + } + } + + + sub PP_decode_box { + { + text => $text, + at => $at, + ch => $ch, + len => $len, + depth => $depth, + encoding => $encoding, + is_valid_utf8 => $is_valid_utf8, + }; + } + +} # PARSE + + +sub _decode_surrogates { # from perlunicode + my $uni = 0x10000 + (hex($_[0]) - 0xD800) * 0x400 + (hex($_[1]) - 0xDC00); + my $un = pack('U*', $uni); + utf8::encode( $un ); + return $un; +} + + +sub _decode_unicode { + my $un = pack('U', hex shift); + utf8::encode( $un ); + return $un; +} + +# +# Setup for various Perl versions (the code from JSON::PP58) +# + +BEGIN { + + unless ( defined &utf8::is_utf8 ) { + require Encode; + *utf8::is_utf8 = *Encode::is_utf8; + } + + if ( $] >= 5.008 ) { + *JSON::PP::JSON_PP_encode_ascii = \&_encode_ascii; + *JSON::PP::JSON_PP_encode_latin1 = \&_encode_latin1; + *JSON::PP::JSON_PP_decode_surrogates = \&_decode_surrogates; + *JSON::PP::JSON_PP_decode_unicode = \&_decode_unicode; + } + + if ($] >= 5.008 and $] < 5.008003) { # join() in 5.8.0 - 5.8.2 is broken. + package # hide from PAUSE + JSON::PP; + require subs; + subs->import('join'); + eval q| + sub join { + return '' if (@_ < 2); + my $j = shift; + my $str = shift; + for (@_) { $str .= $j . $_; } + return $str; + } + |; + } + + + sub JSON::PP::incr_parse { + local $Carp::CarpLevel = 1; + ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_parse( @_ ); + } + + + sub JSON::PP::incr_skip { + ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_skip; + } + + + sub JSON::PP::incr_reset { + ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_reset; + } + + eval q{ + sub JSON::PP::incr_text : lvalue { + $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new; + + if ( $_[0]->{_incr_parser}->{incr_parsing} ) { + Carp::croak("incr_text can not be called when the incremental parser already started parsing"); + } + $_[0]->{_incr_parser}->{incr_text}; + } + } if ( $] >= 5.006 ); + +} # Setup for various Perl versions (the code from JSON::PP58) + + +############################### +# Utilities +# + +BEGIN { + eval 'require Scalar::Util'; + unless($@){ + *JSON::PP::blessed = \&Scalar::Util::blessed; + *JSON::PP::reftype = \&Scalar::Util::reftype; + *JSON::PP::refaddr = \&Scalar::Util::refaddr; + } + else{ # This code is from Scalar::Util. + # warn $@; + eval 'sub UNIVERSAL::a_sub_not_likely_to_be_here { ref($_[0]) }'; + *JSON::PP::blessed = sub { + local($@, $SIG{__DIE__}, $SIG{__WARN__}); + ref($_[0]) ? eval { $_[0]->a_sub_not_likely_to_be_here } : undef; + }; + my %tmap = qw( + B::NULL SCALAR + B::HV HASH + B::AV ARRAY + B::CV CODE + B::IO IO + B::GV GLOB + B::REGEXP REGEXP + ); + *JSON::PP::reftype = sub { + my $r = shift; + + return undef unless length(ref($r)); + + my $t = ref(B::svref_2object($r)); + + return + exists $tmap{$t} ? $tmap{$t} + : length(ref($$r)) ? 'REF' + : 'SCALAR'; + }; + *JSON::PP::refaddr = sub { + return undef unless length(ref($_[0])); + + my $addr; + if(defined(my $pkg = blessed($_[0]))) { + $addr .= bless $_[0], 'Scalar::Util::Fake'; + bless $_[0], $pkg; + } + else { + $addr .= $_[0] + } + + $addr =~ /0x(\w+)/; + local $^W; + #no warnings 'portable'; + hex($1); + } + } +} + + +# shamelessly copied and modified from JSON::XS code. + +$JSON::PP::true = do { bless \(my $dummy = 1), "JSON::backportPP::Boolean" }; +$JSON::PP::false = do { bless \(my $dummy = 0), "JSON::backportPP::Boolean" }; + +sub is_bool { defined $_[0] and UNIVERSAL::isa($_[0], "JSON::PP::Boolean"); } + +sub true { $JSON::PP::true } +sub false { $JSON::PP::false } +sub null { undef; } + +############################### + +package JSON::backportPP::Boolean; + +@JSON::backportPP::Boolean::ISA = ('JSON::PP::Boolean'); +use overload ( + "0+" => sub { ${$_[0]} }, + "++" => sub { $_[0] = ${$_[0]} + 1 }, + "--" => sub { $_[0] = ${$_[0]} - 1 }, + fallback => 1, +); + + +############################### + +package # hide from PAUSE + JSON::PP::IncrParser; + +use strict; + +use constant INCR_M_WS => 0; # initial whitespace skipping +use constant INCR_M_STR => 1; # inside string +use constant INCR_M_BS => 2; # inside backslash +use constant INCR_M_JSON => 3; # outside anything, count nesting +use constant INCR_M_C0 => 4; +use constant INCR_M_C1 => 5; + +use vars qw($VERSION); +$VERSION = '1.01'; + +my $unpack_format = $] < 5.006 ? 'C*' : 'U*'; + +sub new { + my ( $class ) = @_; + + bless { + incr_nest => 0, + incr_text => undef, + incr_parsing => 0, + incr_p => 0, + }, $class; +} + + +sub incr_parse { + my ( $self, $coder, $text ) = @_; + + $self->{incr_text} = '' unless ( defined $self->{incr_text} ); + + if ( defined $text ) { + if ( utf8::is_utf8( $text ) and !utf8::is_utf8( $self->{incr_text} ) ) { + utf8::upgrade( $self->{incr_text} ) ; + utf8::decode( $self->{incr_text} ) ; + } + $self->{incr_text} .= $text; + } + + + my $max_size = $coder->get_max_size; + + if ( defined wantarray ) { + + $self->{incr_mode} = INCR_M_WS unless defined $self->{incr_mode}; + + if ( wantarray ) { + my @ret; + + $self->{incr_parsing} = 1; + + do { + push @ret, $self->_incr_parse( $coder, $self->{incr_text} ); + + unless ( !$self->{incr_nest} and $self->{incr_mode} == INCR_M_JSON ) { + $self->{incr_mode} = INCR_M_WS if $self->{incr_mode} != INCR_M_STR; + } + + } until ( length $self->{incr_text} >= $self->{incr_p} ); + + $self->{incr_parsing} = 0; + + return @ret; + } + else { # in scalar context + $self->{incr_parsing} = 1; + my $obj = $self->_incr_parse( $coder, $self->{incr_text} ); + $self->{incr_parsing} = 0 if defined $obj; # pointed by Martin J. Evans + return $obj ? $obj : undef; # $obj is an empty string, parsing was completed. + } + + } + +} + + +sub _incr_parse { + my ( $self, $coder, $text, $skip ) = @_; + my $p = $self->{incr_p}; + my $restore = $p; + + my @obj; + my $len = length $text; + + if ( $self->{incr_mode} == INCR_M_WS ) { + while ( $len > $p ) { + my $s = substr( $text, $p, 1 ); + $p++ and next if ( 0x20 >= unpack($unpack_format, $s) ); + $self->{incr_mode} = INCR_M_JSON; + last; + } + } + + while ( $len > $p ) { + my $s = substr( $text, $p++, 1 ); + + if ( $s eq '"' ) { + if (substr( $text, $p - 2, 1 ) eq '\\' ) { + next; + } + + if ( $self->{incr_mode} != INCR_M_STR ) { + $self->{incr_mode} = INCR_M_STR; + } + else { + $self->{incr_mode} = INCR_M_JSON; + unless ( $self->{incr_nest} ) { + last; + } + } + } + + if ( $self->{incr_mode} == INCR_M_JSON ) { + + if ( $s eq '[' or $s eq '{' ) { + if ( ++$self->{incr_nest} > $coder->get_max_depth ) { + Carp::croak('json text or perl structure exceeds maximum nesting level (max_depth set too low?)'); + } + } + elsif ( $s eq ']' or $s eq '}' ) { + last if ( --$self->{incr_nest} <= 0 ); + } + elsif ( $s eq '#' ) { + while ( $len > $p ) { + last if substr( $text, $p++, 1 ) eq "\n"; + } + } + + } + + } + + $self->{incr_p} = $p; + + return if ( $self->{incr_mode} == INCR_M_STR and not $self->{incr_nest} ); + return if ( $self->{incr_mode} == INCR_M_JSON and $self->{incr_nest} > 0 ); + + return '' unless ( length substr( $self->{incr_text}, 0, $p ) ); + + local $Carp::CarpLevel = 2; + + $self->{incr_p} = $restore; + $self->{incr_c} = $p; + + my ( $obj, $tail ) = $coder->PP_decode_json( substr( $self->{incr_text}, 0, $p ), 0x10000001 ); + + $self->{incr_text} = substr( $self->{incr_text}, $p ); + $self->{incr_p} = 0; + + return $obj or ''; +} + + +sub incr_text { + if ( $_[0]->{incr_parsing} ) { + Carp::croak("incr_text can not be called when the incremental parser already started parsing"); + } + $_[0]->{incr_text}; +} + + +sub incr_skip { + my $self = shift; + $self->{incr_text} = substr( $self->{incr_text}, $self->{incr_c} ); + $self->{incr_p} = 0; +} + + +sub incr_reset { + my $self = shift; + $self->{incr_text} = undef; + $self->{incr_p} = 0; + $self->{incr_mode} = 0; + $self->{incr_nest} = 0; + $self->{incr_parsing} = 0; +} + +############################### + + +1; +__END__ +=pod + +=head1 NAME + +JSON::PP - JSON::XS compatible pure-Perl module. + +=head1 SYNOPSIS + + use JSON::PP; + + # exported functions, they croak on error + # and expect/generate UTF-8 + + $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; + $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; + + # OO-interface + + $coder = JSON::PP->new->ascii->pretty->allow_nonref; + + $json_text = $json->encode( $perl_scalar ); + $perl_scalar = $json->decode( $json_text ); + + $pretty_printed = $json->pretty->encode( $perl_scalar ); # pretty-printing + + # Note that JSON version 2.0 and above will automatically use + # JSON::XS or JSON::PP, so you should be able to just: + + use JSON; + + +=head1 VERSION + + 2.27200 + +L<JSON::XS> 2.27 (~2.30) compatible. + +=head1 DESCRIPTION + +This module is L<JSON::XS> compatible pure Perl module. +(Perl 5.8 or later is recommended) + +JSON::XS is the fastest and most proper JSON module on CPAN. +It is written by Marc Lehmann in C, so must be compiled and +installed in the used environment. + +JSON::PP is a pure-Perl module and has compatibility to JSON::XS. + + +=head2 FEATURES + +=over + +=item * correct unicode handling + +This module knows how to handle Unicode (depending on Perl version). + +See to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL> and +L<UNICODE HANDLING ON PERLS>. + + +=item * round-trip integrity + +When you serialise a perl data structure using only data types +supported by JSON and Perl, the deserialised data structure is +identical on the Perl level. (e.g. the string "2.0" doesn't suddenly +become "2" just because it looks like a number). There I<are> minor +exceptions to this, read the MAPPING section below to learn about +those. + + +=item * strict checking of JSON correctness + +There is no guessing, no generating of illegal JSON texts by default, +and only JSON is accepted as input by default (the latter is a +security feature). But when some options are set, loose checking +features are available. + +=back + +=head1 FUNCTIONAL INTERFACE + +Some documents are copied and modified from L<JSON::XS/FUNCTIONAL INTERFACE>. + +=head2 encode_json + + $json_text = encode_json $perl_scalar + +Converts the given Perl data structure to a UTF-8 encoded, binary string. + +This function call is functionally identical to: + + $json_text = JSON::PP->new->utf8->encode($perl_scalar) + +=head2 decode_json + + $perl_scalar = decode_json $json_text + +The opposite of C<encode_json>: expects an UTF-8 (binary) string and tries +to parse that as an UTF-8 encoded JSON text, returning the resulting +reference. + +This function call is functionally identical to: + + $perl_scalar = JSON::PP->new->utf8->decode($json_text) + +=head2 JSON::PP::is_bool + + $is_boolean = JSON::PP::is_bool($scalar) + +Returns true if the passed scalar represents either JSON::PP::true or +JSON::PP::false, two constants that act like C<1> and C<0> respectively +and are also used to represent JSON C<true> and C<false> in Perl strings. + +=head2 JSON::PP::true + +Returns JSON true value which is blessed object. +It C<isa> JSON::PP::Boolean object. + +=head2 JSON::PP::false + +Returns JSON false value which is blessed object. +It C<isa> JSON::PP::Boolean object. + +=head2 JSON::PP::null + +Returns C<undef>. + +See L<MAPPING>, below, for more information on how JSON values are mapped to +Perl. + + +=head1 HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER + +This section supposes that your perl version is 5.8 or later. + +If you know a JSON text from an outer world - a network, a file content, and so on, +is encoded in UTF-8, you should use C<decode_json> or C<JSON> module object +with C<utf8> enable. And the decoded result will contain UNICODE characters. + + # from network + my $json = JSON::PP->new->utf8; + my $json_text = CGI->new->param( 'json_data' ); + my $perl_scalar = $json->decode( $json_text ); + + # from file content + local $/; + open( my $fh, '<', 'json.data' ); + $json_text = <$fh>; + $perl_scalar = decode_json( $json_text ); + +If an outer data is not encoded in UTF-8, firstly you should C<decode> it. + + use Encode; + local $/; + open( my $fh, '<', 'json.data' ); + my $encoding = 'cp932'; + my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE + + # or you can write the below code. + # + # open( my $fh, "<:encoding($encoding)", 'json.data' ); + # $unicode_json_text = <$fh>; + +In this case, C<$unicode_json_text> is of course UNICODE string. +So you B<cannot> use C<decode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable. + + $perl_scalar = $json->utf8(0)->decode( $unicode_json_text ); + +Or C<encode 'utf8'> and C<decode_json>: + + $perl_scalar = decode_json( encode( 'utf8', $unicode_json_text ) ); + # this way is not efficient. + +And now, you want to convert your C<$perl_scalar> into JSON data and +send it to an outer world - a network or a file content, and so on. + +Your data usually contains UNICODE strings and you want the converted data to be encoded +in UTF-8, you should use C<encode_json> or C<JSON> module object with C<utf8> enable. + + print encode_json( $perl_scalar ); # to a network? file? or display? + # or + print $json->utf8->encode( $perl_scalar ); + +If C<$perl_scalar> does not contain UNICODE but C<$encoding>-encoded strings +for some reason, then its characters are regarded as B<latin1> for perl +(because it does not concern with your $encoding). +You B<cannot> use C<encode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable. +Note that the resulted text is a UNICODE string but no problem to print it. + + # $perl_scalar contains $encoding encoded string values + $unicode_json_text = $json->utf8(0)->encode( $perl_scalar ); + # $unicode_json_text consists of characters less than 0x100 + print $unicode_json_text; + +Or C<decode $encoding> all string values and C<encode_json>: + + $perl_scalar->{ foo } = decode( $encoding, $perl_scalar->{ foo } ); + # ... do it to each string values, then encode_json + $json_text = encode_json( $perl_scalar ); + +This method is a proper way but probably not efficient. + +See to L<Encode>, L<perluniintro>. + + +=head1 METHODS + +Basically, check to L<JSON> or L<JSON::XS>. + +=head2 new + + $json = JSON::PP->new + +Returns a new JSON::PP object that can be used to de/encode JSON +strings. + +All boolean flags described below are by default I<disabled>. + +The mutators for flags all return the JSON object again and thus calls can +be chained: + + my $json = JSON::PP->new->utf8->space_after->encode({a => [1,2]}) + => {"a": [1, 2]} + +=head2 ascii + + $json = $json->ascii([$enable]) + + $enabled = $json->get_ascii + +If $enable is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627. +(See to L<JSON::XS/OBJECT-ORIENTED INTERFACE>). + +In Perl 5.005, there is no character having high value (more than 255). +See to L<UNICODE HANDLING ON PERLS>. + +If $enable is false, then the encode method will not escape Unicode characters unless +required by the JSON syntax or other flags. This results in a faster and more compact format. + + JSON::PP->new->ascii(1)->encode([chr 0x10401]) + => ["\ud801\udc01"] + +=head2 latin1 + + $json = $json->latin1([$enable]) + + $enabled = $json->get_latin1 + +If $enable is true (or missing), then the encode method will encode the resulting JSON +text as latin1 (or iso-8859-1), escaping any characters outside the code range 0..255. + +If $enable is false, then the encode method will not escape Unicode characters +unless required by the JSON syntax or other flags. + + JSON::XS->new->latin1->encode (["\x{89}\x{abc}"] + => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not) + +See to L<UNICODE HANDLING ON PERLS>. + +=head2 utf8 + + $json = $json->utf8([$enable]) + + $enabled = $json->get_utf8 + +If $enable is true (or missing), then the encode method will encode the JSON result +into UTF-8, as required by many protocols, while the decode method expects to be handled +an UTF-8-encoded string. Please note that UTF-8-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. + +(In Perl 5.005, any character outside the range 0..255 does not exist. +See to L<UNICODE HANDLING ON PERLS>.) + +In future versions, enabling this option might enable autodetection of the UTF-16 and UTF-32 +encoding families, as described in RFC4627. + +If $enable is false, then the encode method will return the JSON string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to UTF-8 or UTF-16) needs to be done yourself, e.g. using the Encode module. + +Example, output UTF-16BE-encoded JSON: + + use Encode; + $jsontext = encode "UTF-16BE", JSON::PP->new->encode ($object); + +Example, decode UTF-32LE-encoded JSON: + + use Encode; + $object = JSON::PP->new->decode (decode "UTF-32LE", $jsontext); + + +=head2 pretty + + $json = $json->pretty([$enable]) + +This enables (or disables) all of the C<indent>, C<space_before> and +C<space_after> flags in one call to generate the most readable +(or most compact) form possible. + +Equivalent to: + + $json->indent->space_before->space_after + +=head2 indent + + $json = $json->indent([$enable]) + + $enabled = $json->get_indent + +The default indent space length is three. +You can use C<indent_length> to change the length. + +=head2 space_before + + $json = $json->space_before([$enable]) + + $enabled = $json->get_space_before + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space before the C<:> separating keys from values in JSON objects. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before enabled, space_after and indent disabled: + + {"key" :"value"} + +=head2 space_after + + $json = $json->space_after([$enable]) + + $enabled = $json->get_space_after + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space after the C<:> separating keys from values in JSON objects +and extra whitespace after the C<,> separating key-value pairs and array +members. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before and indent disabled, space_after enabled: + + {"key": "value"} + +=head2 relaxed + + $json = $json->relaxed([$enable]) + + $enabled = $json->get_relaxed + +If C<$enable> is true (or missing), then C<decode> will accept some +extensions to normal JSON syntax (see below). C<encode> will not be +affected in anyway. I<Be aware that this option makes you accept invalid +JSON texts as if they were valid!>. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) + +If C<$enable> is false (the default), then C<decode> will only accept +valid JSON texts. + +Currently accepted extensions are: + +=over 4 + +=item * list items can have an end-comma + +JSON I<separates> array elements and key-value pairs with commas. This +can be annoying if you write JSON texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: + + [ + 1, + 2, <- this comma not normally allowed + ] + { + "k1": "v1", + "k2": "v2", <- this comma not normally allowed + } + +=item * shell-style '#'-comments + +Whenever JSON allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. + + [ + 1, # this comment not allowed in JSON + # neither this one... + ] + +=back + +=head2 canonical + + $json = $json->canonical([$enable]) + + $enabled = $json->get_canonical + +If C<$enable> is true (or missing), then the C<encode> method will output JSON objects +by sorting their keys. This is adding a comparatively high overhead. + +If C<$enable> is false, then the C<encode> method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). + +This option is useful if you want the same data structure to be encoded as +the same JSON text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. + +This setting has no effect when decoding JSON texts. + +If you want your own sorting routine, you can give a code reference +or a subroutine name to C<sort_by>. See to C<JSON::PP OWN METHODS>. + +=head2 allow_nonref + + $json = $json->allow_nonref([$enable]) + + $enabled = $json->get_allow_nonref + +If C<$enable> is true (or missing), then the C<encode> method can convert a +non-reference into its corresponding string, number or null JSON value, +which is an extension to RFC4627. Likewise, C<decode> will accept those JSON +values instead of croaking. + +If C<$enable> is false, then the C<encode> method will croak if it isn't +passed an arrayref or hashref, as JSON texts must either be an object +or array. Likewise, C<decode> will croak if given something that is not a +JSON object or array. + + JSON::PP->new->allow_nonref->encode ("Hello, World!") + => "Hello, World!" + +=head2 allow_unknown + + $json = $json->allow_unknown ([$enable]) + + $enabled = $json->get_allow_unknown + +If $enable is true (or missing), then "encode" will *not* throw an +exception when it encounters values it cannot represent in JSON (for +example, filehandles) but instead will encode a JSON "null" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. + +If $enable is false (the default), then "encode" will throw an +exception when it encounters anything it cannot encode as JSON. + +This option does not affect "decode" in any way, and it is +recommended to leave it off unless you know your communications +partner. + +=head2 allow_blessed + + $json = $json->allow_blessed([$enable]) + + $enabled = $json->get_allow_blessed + +If C<$enable> is true (or missing), then the C<encode> method will not +barf when it encounters a blessed reference. Instead, the value of the +B<convert_blessed> option will decide whether C<null> (C<convert_blessed> +disabled or no C<TO_JSON> method found) or a representation of the +object (C<convert_blessed> enabled and C<TO_JSON> method found) is being +encoded. Has no effect on C<decode>. + +If C<$enable> is false (the default), then C<encode> will throw an +exception when it encounters a blessed object. + +=head2 convert_blessed + + $json = $json->convert_blessed([$enable]) + + $enabled = $json->get_convert_blessed + +If C<$enable> is true (or missing), then C<encode>, upon encountering a +blessed object, will check for the availability of the C<TO_JSON> method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +C<TO_JSON> method is found, the value of C<allow_blessed> will decide what +to do. + +The C<TO_JSON> method may safely call die if it wants. If C<TO_JSON> +returns other blessed objects, those will be handled in the same +way. C<TO_JSON> must take care of not causing an endless recursion cycle +(== crash) in this case. The name of C<TO_JSON> was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the C<to_json> +function or method. + +This setting does not yet influence C<decode> in any way. + +If C<$enable> is false, then the C<allow_blessed> setting will decide what +to do when a blessed object is found. + +=head2 filter_json_object + + $json = $json->filter_json_object([$coderef]) + +When C<$coderef> is specified, it will be called from C<decode> each +time it decodes a JSON object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(NOTE: I<not> C<undef>, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. + +When C<$coderef> is omitted or undefined, any existing callback will +be removed and C<decode> will not change the deserialised hash in any +way. + +Example, convert all JSON objects into the integer 5: + + my $js = JSON::PP->new->filter_json_object (sub { 5 }); + # returns [5] + $js->decode ('[{}]'); # the given subroutine takes a hash reference. + # throw an exception because allow_nonref is not enabled + # so a lone 5 is not allowed. + $js->decode ('{"a":1, "b":2}'); + +=head2 filter_json_single_key_object + + $json = $json->filter_json_single_key_object($key [=> $coderef]) + +Works remotely similar to C<filter_json_object>, but is only called for +JSON objects having a single key named C<$key>. + +This C<$coderef> is called before the one specified via +C<filter_json_object>, if any. It gets passed the single value in the JSON +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even C<undef> but the empty list), +the callback from C<filter_json_object> will be called next, as if no +single-key callback were specified. + +If C<$coderef> is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. + +As this callback gets called less often then the C<filter_json_object> +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key JSON objects are as close to the type-tagged value concept +as JSON gets (it's basically an ID/VALUE tuple). Of course, JSON does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. + +Typical names for the single object key are C<__class_whatever__>, or +C<$__dollars_are_rarely_used__$> or C<}ugly_brace_placement>, or even +things like C<__class_md5sum(classname)__>, to reduce the risk of clashing +with real hashes. + +Example, decode JSON objects of the form C<< { "__widget__" => <id> } >> +into the corresponding C<< $WIDGET{<id>} >> object: + + # return whatever is in $WIDGET{5}: + JSON::PP + ->new + ->filter_json_single_key_object (__widget__ => sub { + $WIDGET{ $_[0] } + }) + ->decode ('{"__widget__": 5') + + # this can be used with a TO_JSON method in some "widget" class + # for serialisation to json: + sub WidgetBase::TO_JSON { + my ($self) = @_; + + unless ($self->{id}) { + $self->{id} = ..get..some..id..; + $WIDGET{$self->{id}} = $self; + } + + { __widget__ => $self->{id} } + } + +=head2 shrink + + $json = $json->shrink([$enable]) + + $enabled = $json->get_shrink + +In JSON::XS, this flag resizes strings generated by either +C<encode> or C<decode> to their minimum size possible. +It will also try to downgrade any strings to octet-form if possible. + +In JSON::PP, it is noop about resizing strings but tries +C<utf8::downgrade> to the returned string by C<encode>. +See to L<utf8>. + +See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> + +=head2 max_depth + + $json = $json->max_depth([$maximum_nesting_depth]) + + $max_depth = $json->get_max_depth + +Sets the maximum nesting level (default C<512>) accepted while encoding +or decoding. If a higher nesting level is detected in JSON text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. + +Nesting level is defined by number of hash- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of C<{> or C<[> +characters without their matching closing parenthesis crossed to reach a +given character in a string. + +If no argument is given, the highest possible setting will be used, which +is rarely useful. + +See L<JSON::XS/SSECURITY CONSIDERATIONS> for more info on why this is useful. + +When a large value (100 or more) was set and it de/encodes a deep nested object/text, +it may raise a warning 'Deep recursion on subroutine' at the perl runtime phase. + +=head2 max_size + + $json = $json->max_size([$maximum_string_size]) + + $max_size = $json->get_max_size + +Set the maximum length a JSON text may have (in bytes) where decoding is +being attempted. The default is C<0>, meaning no limit. When C<decode> +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on C<encode> (yet). + +If no argument is given, the limit check will be deactivated (same as when +C<0> is specified). + +See L<JSON::XS/SECURITY CONSIDERATIONS> for more info on why this is useful. + +=head2 encode + + $json_text = $json->encode($perl_scalar) + +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its JSON representation. Simple scalars will be +converted into JSON string or number sequences, while references to arrays +become JSON arrays and references to hashes become JSON objects. Undefined +Perl values (e.g. C<undef>) become JSON C<null> values. +References to the integers C<0> and C<1> are converted into C<true> and C<false>. + +=head2 decode + + $perl_scalar = $json->decode($json_text) + +The opposite of C<encode>: expects a JSON text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. + +JSON numbers and strings become simple Perl scalars. JSON arrays become +Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes +C<1> (C<JSON::true>), C<false> becomes C<0> (C<JSON::false>) and +C<null> becomes C<undef>. + +=head2 decode_prefix + + ($perl_scalar, $characters) = $json->decode_prefix($json_text) + +This works like the C<decode> method, but instead of raising an exception +when there is trailing garbage after the first JSON object, it will +silently stop parsing there and return the number of characters consumed +so far. + + JSON->new->decode_prefix ("[1] the tail") + => ([], 3) + +=head1 INCREMENTAL PARSING + +Most of this section are copied and modified from L<JSON::XS/INCREMENTAL PARSING>. + +In some cases, there is the need for incremental parsing of JSON texts. +This module does allow you to parse a JSON stream incrementally. +It does so by accumulating text until it has a full JSON object, which +it then can decode. This process is similar to using C<decode_prefix> +to see if a full JSON object is available, but is much more efficient +(and can be implemented with a minimum of method calls). + +This module will only attempt to parse the JSON text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid JSON text has been seen. This means you need +to set resource limits (e.g. C<max_size>) to ensure the parser will stop +parsing in the presence if syntax errors. + +The following methods implement this incremental parser. + +=head2 incr_parse + + $json->incr_parse( [$string] ) # void context + + $obj_or_undef = $json->incr_parse( [$string] ) # scalar context + + @obj_or_empty = $json->incr_parse( [$string] ) # list context + +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). + +If C<$string> is given, then this string is appended to the already +existing JSON fragment stored in the C<$json> object. + +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. + +If the method is called in scalar context, then it will try to extract +exactly I<one> JSON object. If that is successful, it will return this +object, otherwise it will return C<undef>. If there is a parse error, +this method will croak just as C<decode> would do (one can then use +C<incr_skip> to skip the erroneous part). This is the most common way of +using the method. + +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the JSON +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed JSON texts will be +lost. + +Example: Parse some JSON arrays/objects in a given string and return them. + + my @objs = JSON->new->incr_parse ("[5][7][1,2]"); + +=head2 incr_text + + $lvalue_string = $json->incr_text + +This method returns the currently stored JSON fragment as an lvalue, that +is, you can manipulate it. This I<only> works when a preceding call to +C<incr_parse> in I<scalar context> successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it I<will> fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. + +This function is useful in two cases: a) finding the trailing text after a +JSON object or b) parsing multiple JSON objects separated by non-JSON text +(such as commas). + + $json->incr_text =~ s/\s*,\s*//; + +In Perl 5.005, C<lvalue> attribute is not available. +You must write codes like the below: + + $string = $json->incr_text; + $string =~ s/\s*,\s*//; + $json->incr_text( $string ); + +=head2 incr_skip + + $json->incr_skip + +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after C<incr_parse> +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. + +=head2 incr_reset + + $json->incr_reset + +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. + +This is useful if you want to repeatedly parse JSON objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. + +See to L<JSON::XS/INCREMENTAL PARSING> for examples. + + +=head1 JSON::PP OWN METHODS + +=head2 allow_singlequote + + $json = $json->allow_singlequote([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +JSON strings quoted by single quotations that are invalid JSON +format. + + $json->allow_singlequote->decode({"foo":'bar'}); + $json->allow_singlequote->decode({'foo':"bar"}); + $json->allow_singlequote->decode({'foo':'bar'}); + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + + +=head2 allow_barekey + + $json = $json->allow_barekey([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +bare keys of JSON object that are invalid JSON format. + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + + $json->allow_barekey->decode('{foo:"bar"}'); + +=head2 allow_bignum + + $json = $json->allow_bignum([$enable]) + +If C<$enable> is true (or missing), then C<decode> will convert +the big integer Perl cannot handle as integer into a L<Math::BigInt> +object and convert a floating number (any) into a L<Math::BigFloat>. + +On the contrary, C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers with C<allow_blessed> enable. + + $json->allow_nonref->allow_blessed->allow_bignum; + $bigfloat = $json->decode('2.000000000000000000000000001'); + print $json->encode($bigfloat); + # => 2.000000000000000000000000001 + +See to L<JSON::XS/MAPPING> about the normal conversion of JSON number. + +=head2 loose + + $json = $json->loose([$enable]) + +The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON strings +and the module doesn't allow to C<decode> to these (except for \x2f). +If C<$enable> is true (or missing), then C<decode> will accept these +unescaped strings. + + $json->loose->decode(qq|["abc + def"]|); + +See L<JSON::XS/SSECURITY CONSIDERATIONS>. + +=head2 escape_slash + + $json = $json->escape_slash([$enable]) + +According to JSON Grammar, I<slash> (U+002F) is escaped. But default +JSON::PP (as same as JSON::XS) encodes strings without escaping slash. + +If C<$enable> is true (or missing), then C<encode> will escape slashes. + +=head2 indent_length + + $json = $json->indent_length($length) + +JSON::XS indent space length is 3 and cannot be changed. +JSON::PP set the indent space length with the given $length. +The default is 3. The acceptable range is 0 to 15. + +=head2 sort_by + + $json = $json->sort_by($function_name) + $json = $json->sort_by($subroutine_ref) + +If $function_name or $subroutine_ref are set, its sort routine are used +in encoding JSON objects. + + $js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + $js = $pc->sort_by('own_sort')->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } + +As the sorting routine runs in the JSON::PP scope, the given +subroutine name and the special variables C<$a>, C<$b> will begin +'JSON::PP::'. + +If $integer is set, then the effect is same as C<canonical> on. + +=head1 INTERNAL + +For developers. + +=over + +=item PP_encode_box + +Returns + + { + depth => $depth, + indent_count => $indent_count, + } + + +=item PP_decode_box + +Returns + + { + text => $text, + at => $at, + ch => $ch, + len => $len, + depth => $depth, + encoding => $encoding, + is_valid_utf8 => $is_valid_utf8, + }; + +=back + +=head1 MAPPING + +This section is copied from JSON::XS and modified to C<JSON::PP>. +JSON::XS and JSON::PP mapping mechanisms are almost equivalent. + +See to L<JSON::XS/MAPPING>. + +=head2 JSON -> PERL + +=over 4 + +=item object + +A JSON object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (JSON does not preserver object key ordering itself). + +=item array + +A JSON array becomes a reference to an array in Perl. + +=item string + +A JSON string becomes a string scalar in Perl - Unicode codepoints in JSON +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. + +=item number + +A JSON number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. + +If the number consists of digits only, C<JSON> will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the JSON number will be +re-encoded to a JSON string). + +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the JSON number will still be re-encoded as a JSON number). + +Note that precision is not accuracy - binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, C<JSON> only guarantees precision up to but not including +the least significant bit. + +When C<allow_bignum> is enable, the big integers +and the numeric can be optionally converted into L<Math::BigInt> and +L<Math::BigFloat> objects. + +=item true, false + +These JSON atoms become C<JSON::PP::true> and C<JSON::PP::false>, +respectively. They are overloaded to act almost exactly like the numbers +C<1> and C<0>. You can check whether a scalar is a JSON boolean by using +the C<JSON::is_bool> function. + + print JSON::PP::true . "\n"; + => true + print JSON::PP::true + 1; + => 1 + + ok(JSON::true eq '1'); + ok(JSON::true == 1); + +C<JSON> will install these missing overloading features to the backend modules. + + +=item null + +A JSON null atom becomes C<undef> in Perl. + +C<JSON::PP::null> returns C<undef>. + +=back + + +=head2 PERL -> JSON + +The mapping from Perl to JSON is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which JSON type is meant by +a Perl value. + +=over 4 + +=item hash references + +Perl hash references become JSON objects. As there is no inherent ordering +in hash keys (or JSON objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. C<JSON> +optionally sort the hash keys (determined by the I<canonical> flag), so +the same data structure will serialise to the same JSON text (given same +settings and version of JSON::XS), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some JSON text +against another for equality. + + +=item array references + +Perl array references become JSON arrays. + +=item other references + +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers C<0> and +C<1>, which get turned into C<false> and C<true> atoms in JSON. You can +also use C<JSON::false> and C<JSON::true> to improve readability. + + to_json [\0,JSON::PP::true] # yields [false,true] + +=item JSON::PP::true, JSON::PP::false, JSON::PP::null + +These special values become JSON true and JSON false values, +respectively. You can also use C<\1> and C<\0> directly if you want. + +JSON::PP::null returns C<undef>. + +=item blessed objects + +Blessed objects are not directly representable in JSON. See the +C<allow_blessed> and C<convert_blessed> methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. + +See to L<convert_blessed>. + +=item simple scalars + +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: JSON::XS and JSON::PP will encode undefined scalars as +JSON C<null> values, scalars that have last been used in a string context +before encoding as JSON strings, and anything else as number value: + + # dump as number + encode_json [2] # yields [2] + encode_json [-3.0e17] # yields [-3e+17] + my $value = 5; encode_json [$value] # yields [5] + + # used as string, so dump as string + print $value; + encode_json [$value] # yields ["5"] + + # undef becomes null + encode_json [undef] # yields [null] + +You can force the type to be a string by stringifying it: + + my $x = 3.1; # some variable containing a number + "$x"; # stringified + $x .= ""; # another, more awkward way to stringify + print $x; # perl does it for you, too, quite often + +You can force the type to be a number by numifying it: + + my $x = "3"; # some variable containing a string + $x += 0; # numify it, ensuring it will be dumped as a number + $x *= 1; # same thing, the choice is yours. + +You can not currently force the type in other, less obscure, ways. + +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's - these cannot be represented in JSON, and it is an +error to pass those in. + +=item Big Number + +When C<allow_bignum> is enable, +C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers. + + +=back + +=head1 UNICODE HANDLING ON PERLS + +If you do not know about Unicode on Perl well, +please check L<JSON::XS/A FEW NOTES ON UNICODE AND PERL>. + +=head2 Perl 5.8 and later + +Perl can handle Unicode and the JSON::PP de/encode methods also work properly. + + $json->allow_nonref->encode(chr hex 3042); + $json->allow_nonref->encode(chr hex 12345); + +Returns C<"\u3042"> and C<"\ud808\udf45"> respectively. + + $json->allow_nonref->decode('"\u3042"'); + $json->allow_nonref->decode('"\ud808\udf45"'); + +Returns UTF-8 encoded strings with UTF8 flag, regarded as C<U+3042> and C<U+12345>. + +Note that the versions from Perl 5.8.0 to 5.8.2, Perl built-in C<join> was broken, +so JSON::PP wraps the C<join> with a subroutine. Thus JSON::PP works slow in the versions. + + +=head2 Perl 5.6 + +Perl can handle Unicode and the JSON::PP de/encode methods also work. + +=head2 Perl 5.005 + +Perl 5.005 is a byte semantics world -- all strings are sequences of bytes. +That means the unicode handling is not available. + +In encoding, + + $json->allow_nonref->encode(chr hex 3042); # hex 3042 is 12354. + $json->allow_nonref->encode(chr hex 12345); # hex 12345 is 74565. + +Returns C<B> and C<E>, as C<chr> takes a value more than 255, it treats +as C<$value % 256>, so the above codes are equivalent to : + + $json->allow_nonref->encode(chr 66); + $json->allow_nonref->encode(chr 69); + +In decoding, + + $json->decode('"\u00e3\u0081\u0082"'); + +The returned is a byte sequence C<0xE3 0x81 0x82> for UTF-8 encoded +japanese character (C<HIRAGANA LETTER A>). +And if it is represented in Unicode code point, C<U+3042>. + +Next, + + $json->decode('"\u3042"'); + +We ordinary expect the returned value is a Unicode character C<U+3042>. +But here is 5.005 world. This is C<0xE3 0x81 0x82>. + + $json->decode('"\ud808\udf45"'); + +This is not a character C<U+12345> but bytes - C<0xf0 0x92 0x8d 0x85>. + + +=head1 TODO + +=over + +=item speed + +=item memory saving + +=back + + +=head1 SEE ALSO + +Most of the document are copied and modified from JSON::XS doc. + +L<JSON::XS> + +RFC4627 (L<http://www.ietf.org/rfc/rfc4627.txt>) + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2007-2012 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut diff --git a/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Boolean.pm b/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Boolean.pm new file mode 100644 index 0000000..38be6a3 --- /dev/null +++ b/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Boolean.pm @@ -0,0 +1,27 @@ +=head1 NAME + +JSON::PP::Boolean - dummy module providing JSON::PP::Boolean + +=head1 SYNOPSIS + + # do not "use" yourself + +=head1 DESCRIPTION + +This module exists only to provide overload resolution for Storable +and similar modules. See L<JSON::PP> for more info about this class. + +=cut + +use JSON::backportPP (); +use strict; + +1; + +=head1 AUTHOR + +This idea is from L<JSON::XS::Boolean> written by +Marc Lehmann <schmorp[at]schmorp.de> + +=cut + diff --git a/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5005.pm b/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5005.pm new file mode 100644 index 0000000..139990e --- /dev/null +++ b/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5005.pm @@ -0,0 +1,131 @@ +package # This is JSON::backportPP + JSON::backportPP5005; + +use 5.005; +use strict; + +my @properties; + +$JSON::PP5005::VERSION = '1.10'; + +BEGIN { + + sub utf8::is_utf8 { + 0; # It is considered that UTF8 flag off for Perl 5.005. + } + + sub utf8::upgrade { + } + + sub utf8::downgrade { + 1; # must always return true. + } + + sub utf8::encode { + } + + sub utf8::decode { + } + + *JSON::PP::JSON_PP_encode_ascii = \&_encode_ascii; + *JSON::PP::JSON_PP_encode_latin1 = \&_encode_latin1; + *JSON::PP::JSON_PP_decode_surrogates = \&_decode_surrogates; + *JSON::PP::JSON_PP_decode_unicode = \&_decode_unicode; + + # missing in B module. + sub B::SVp_IOK () { 0x01000000; } + sub B::SVp_NOK () { 0x02000000; } + sub B::SVp_POK () { 0x04000000; } + + $INC{'bytes.pm'} = 1; # dummy +} + + + +sub _encode_ascii { + join('', map { $_ <= 127 ? chr($_) : sprintf('\u%04x', $_) } unpack('C*', $_[0]) ); +} + + +sub _encode_latin1 { + join('', map { chr($_) } unpack('C*', $_[0]) ); +} + + +sub _decode_surrogates { # from http://homepage1.nifty.com/nomenclator/unicode/ucs_utf.htm + my $uni = 0x10000 + (hex($_[0]) - 0xD800) * 0x400 + (hex($_[1]) - 0xDC00); # from perlunicode + my $bit = unpack('B32', pack('N', $uni)); + + if ( $bit =~ /^00000000000(...)(......)(......)(......)$/ ) { + my ($w, $x, $y, $z) = ($1, $2, $3, $4); + return pack('B*', sprintf('11110%s10%s10%s10%s', $w, $x, $y, $z)); + } + else { + Carp::croak("Invalid surrogate pair"); + } +} + + +sub _decode_unicode { + my ($u) = @_; + my ($utf8bit); + + if ( $u =~ /^00([89a-f][0-9a-f])$/i ) { # 0x80-0xff + return pack( 'H2', $1 ); + } + + my $bit = unpack("B*", pack("H*", $u)); + + if ( $bit =~ /^00000(.....)(......)$/ ) { + $utf8bit = sprintf('110%s10%s', $1, $2); + } + elsif ( $bit =~ /^(....)(......)(......)$/ ) { + $utf8bit = sprintf('1110%s10%s10%s', $1, $2, $3); + } + else { + Carp::croak("Invalid escaped unicode"); + } + + return pack('B*', $utf8bit); +} + + +sub JSON::PP::incr_text { + $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new; + + if ( $_[0]->{_incr_parser}->{incr_parsing} ) { + Carp::croak("incr_text can not be called when the incremental parser already started parsing"); + } + + $_[0]->{_incr_parser}->{incr_text} = $_[1] if ( @_ > 1 ); + $_[0]->{_incr_parser}->{incr_text}; +} + + +1; +__END__ + +=pod + +=head1 NAME + +JSON::PP5005 - Helper module in using JSON::PP in Perl 5.005 + +=head1 DESCRIPTION + +JSON::PP calls internally. + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2007-2012 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5006.pm b/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5006.pm new file mode 100644 index 0000000..7736fd8 --- /dev/null +++ b/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5006.pm @@ -0,0 +1,173 @@ +package # This is JSON::backportPP + JSON::backportPP56; + +use 5.006; +use strict; + +my @properties; + +$JSON::PP56::VERSION = '1.08'; + +BEGIN { + + sub utf8::is_utf8 { + my $len = length $_[0]; # char length + { + use bytes; # byte length; + return $len != length $_[0]; # if !=, UTF8-flagged on. + } + } + + + sub utf8::upgrade { + ; # noop; + } + + + sub utf8::downgrade ($;$) { + return 1 unless ( utf8::is_utf8( $_[0] ) ); + + if ( _is_valid_utf8( $_[0] ) ) { + my $downgrade; + for my $c ( unpack( "U*", $_[0] ) ) { + if ( $c < 256 ) { + $downgrade .= pack("C", $c); + } + else { + $downgrade .= pack("U", $c); + } + } + $_[0] = $downgrade; + return 1; + } + else { + Carp::croak("Wide character in subroutine entry") unless ( $_[1] ); + 0; + } + } + + + sub utf8::encode ($) { # UTF8 flag off + if ( utf8::is_utf8( $_[0] ) ) { + $_[0] = pack( "C*", unpack( "C*", $_[0] ) ); + } + else { + $_[0] = pack( "U*", unpack( "C*", $_[0] ) ); + $_[0] = pack( "C*", unpack( "C*", $_[0] ) ); + } + } + + + sub utf8::decode ($) { # UTF8 flag on + if ( _is_valid_utf8( $_[0] ) ) { + utf8::downgrade( $_[0] ); + $_[0] = pack( "U*", unpack( "U*", $_[0] ) ); + } + } + + + *JSON::PP::JSON_PP_encode_ascii = \&_encode_ascii; + *JSON::PP::JSON_PP_encode_latin1 = \&_encode_latin1; + *JSON::PP::JSON_PP_decode_surrogates = \&JSON::PP::_decode_surrogates; + *JSON::PP::JSON_PP_decode_unicode = \&JSON::PP::_decode_unicode; + + unless ( defined &B::SVp_NOK ) { # missing in B module. + eval q{ sub B::SVp_NOK () { 0x02000000; } }; + } + +} + + + +sub _encode_ascii { + join('', + map { + $_ <= 127 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', JSON::PP::_encode_surrogates($_)); + } _unpack_emu($_[0]) + ); +} + + +sub _encode_latin1 { + join('', + map { + $_ <= 255 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', JSON::PP::_encode_surrogates($_)); + } _unpack_emu($_[0]) + ); +} + + +sub _unpack_emu { # for Perl 5.6 unpack warnings + return !utf8::is_utf8($_[0]) ? unpack('C*', $_[0]) + : _is_valid_utf8($_[0]) ? unpack('U*', $_[0]) + : unpack('C*', $_[0]); +} + + +sub _is_valid_utf8 { + my $str = $_[0]; + my $is_utf8; + + while ($str =~ /(?: + ( + [\x00-\x7F] + |[\xC2-\xDF][\x80-\xBF] + |[\xE0][\xA0-\xBF][\x80-\xBF] + |[\xE1-\xEC][\x80-\xBF][\x80-\xBF] + |[\xED][\x80-\x9F][\x80-\xBF] + |[\xEE-\xEF][\x80-\xBF][\x80-\xBF] + |[\xF0][\x90-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF4][\x80-\x8F][\x80-\xBF][\x80-\xBF] + ) + | (.) + )/xg) + { + if (defined $1) { + $is_utf8 = 1 if (!defined $is_utf8); + } + else { + $is_utf8 = 0 if (!defined $is_utf8); + if ($is_utf8) { # eventually, not utf8 + return; + } + } + } + + return $is_utf8; +} + + +1; +__END__ + +=pod + +=head1 NAME + +JSON::PP56 - Helper module in using JSON::PP in Perl 5.6 + +=head1 DESCRIPTION + +JSON::PP calls internally. + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2007-2012 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/JSON-2.59/pm_to_blib b/third_party/JSON/JSON-2.59/pm_to_blib new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/third_party/JSON/JSON-2.59/pm_to_blib diff --git a/third_party/JSON/JSON-2.59/t/00_load.t b/third_party/JSON/JSON-2.59/t/00_load.t new file mode 100644 index 0000000..916c826 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/00_load.t @@ -0,0 +1,15 @@ +use Test::More; +use strict; +BEGIN { plan tests => 5 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +BEGIN { + use_ok('JSON'); +} + +ok( exists $INC{ 'JSON/backportPP.pm' }, 'load backportPP' ); +ok( ! exists $INC{ 'JSON/PP.pm' }, q/didn't load PP/ ); + +is( JSON->backend, 'JSON::PP' ); +ok( JSON->backend->is_pp ); diff --git a/third_party/JSON/JSON-2.59/t/00_pod.t b/third_party/JSON/JSON-2.59/t/00_pod.t new file mode 100644 index 0000000..e8e3082 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/00_pod.t @@ -0,0 +1,8 @@ +use strict; +$^W = 1; + +use Test::More; + +eval "use Test::Pod 1.00"; +plan skip_all => "Test::Pod 1.00 required for testing POD" if $@; +all_pod_files_ok (); diff --git a/third_party/JSON/JSON-2.59/t/01_utf8.t b/third_party/JSON/JSON-2.59/t/01_utf8.t new file mode 100644 index 0000000..442fc40 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/01_utf8.t @@ -0,0 +1,36 @@ +# copied over from JSON::XS and modified to use JSON + +use strict; +use Test::More; +BEGIN { plan tests => 9 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + + +use utf8; +use JSON; + + +ok (JSON->new->allow_nonref (1)->utf8 (1)->encode ("ü") eq "\"\xc3\xbc\""); +ok (JSON->new->allow_nonref (1)->encode ("ü") eq "\"ü\""); + +SKIP: { + skip "UNICODE handling is disabale.", 7 unless $JSON::can_handle_UTF16_and_utf8; + +ok (JSON->new->allow_nonref (1)->ascii (1)->utf8 (1)->encode (chr 0x8000) eq '"\u8000"'); +ok (JSON->new->allow_nonref (1)->ascii (1)->utf8 (1)->pretty (1)->encode (chr 0x10402) eq "\"\\ud801\\udc02\"\n"); + +eval { JSON->new->allow_nonref (1)->utf8 (1)->decode ('"ü"') }; +ok $@ =~ /malformed UTF-8/; + +ok (JSON->new->allow_nonref (1)->decode ('"ü"') eq "ü"); +ok (JSON->new->allow_nonref (1)->decode ('"\u00fc"') eq "ü"); +ok (JSON->new->allow_nonref (1)->decode ('"\ud801\udc02' . "\x{10204}\"") eq "\x{10402}\x{10204}"); +ok (JSON->new->allow_nonref (1)->decode ('"\"\n\\\\\r\t\f\b"') eq "\"\012\\\015\011\014\010"); + +} diff --git a/third_party/JSON/JSON-2.59/t/02_error.t b/third_party/JSON/JSON-2.59/t/02_error.t new file mode 100644 index 0000000..0c757d3 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/02_error.t @@ -0,0 +1,51 @@ +# copied over from JSON::XS and modified to use JSON + +use strict; +use Test::More; +BEGIN { plan tests => 31 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +use utf8; +use JSON; + + +eval { JSON->new->encode ([\-1]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\undef]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\2]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\{}]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\[]]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\\1]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->allow_nonref (1)->decode ('"\u1234\udc00"') }; ok $@ =~ /missing high /; +eval { JSON->new->allow_nonref->decode ('"\ud800"') }; ok $@ =~ /missing low /; +eval { JSON->new->allow_nonref (1)->decode ('"\ud800\u1234"') }; ok $@ =~ /surrogate pair /; +eval { JSON->new->decode ('null') }; ok $@ =~ /allow_nonref/; +eval { JSON->new->allow_nonref (1)->decode ('+0') }; ok $@ =~ /malformed/; +eval { JSON->new->allow_nonref->decode ('.2') }; ok $@ =~ /malformed/; +eval { JSON->new->allow_nonref (1)->decode ('bare') }; ok $@ =~ /malformed/; +eval { JSON->new->allow_nonref->decode ('naughty') }; ok $@ =~ /null/; +eval { JSON->new->allow_nonref (1)->decode ('01') }; ok $@ =~ /leading zero/; +eval { JSON->new->allow_nonref->decode ('00') }; ok $@ =~ /leading zero/; +eval { JSON->new->allow_nonref (1)->decode ('-0.') }; ok $@ =~ /decimal point/; +eval { JSON->new->allow_nonref->decode ('-0e') }; ok $@ =~ /exp sign/; +eval { JSON->new->allow_nonref (1)->decode ('-e+1') }; ok $@ =~ /initial minus/; +eval { JSON->new->allow_nonref->decode ("\"\n\"") }; ok $@ =~ /invalid character/; +eval { JSON->new->allow_nonref (1)->decode ("\"\x01\"") }; ok $@ =~ /invalid character/; +eval { JSON->new->decode ('[5') }; ok $@ =~ /parsing array/; +eval { JSON->new->decode ('{"5"') }; ok $@ =~ /':' expected/; +eval { JSON->new->decode ('{"5":null') }; ok $@ =~ /parsing object/; + +eval { JSON->new->decode (undef) }; ok $@ =~ /malformed/; +eval { JSON->new->decode (\5) }; ok !!$@; # Can't coerce readonly +eval { JSON->new->decode ([]) }; ok $@ =~ /malformed/; +eval { JSON->new->decode (\*STDERR) }; ok $@ =~ /malformed/; +eval { JSON->new->decode (*STDERR) }; ok !!$@; # cannot coerce GLOB + +eval { decode_json ("\"\xa0") }; ok $@ =~ /malformed.*character/; +eval { decode_json ("\"\xa0\"") }; ok $@ =~ /malformed.*character/; + diff --git a/third_party/JSON/JSON-2.59/t/03_types.t b/third_party/JSON/JSON-2.59/t/03_types.t new file mode 100644 index 0000000..f22c09bc --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/03_types.t @@ -0,0 +1,60 @@ +# copied over from JSON::XS and modified to use JSON +use strict; +use Test::More; + +BEGIN { plan tests => 76 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + + +ok (!defined JSON->new->allow_nonref (1)->decode ('null')); +ok (JSON->new->allow_nonref (1)->decode ('true') == 1); +ok (JSON->new->allow_nonref (1)->decode ('false') == 0); + +my $true = JSON->new->allow_nonref (1)->decode ('true'); +ok ($true eq 1); +ok (JSON::is_bool $true); +my $false = JSON->new->allow_nonref (1)->decode ('false'); +ok ($false == !$true); +ok (JSON::is_bool $false); +ok (++$false == 1); +ok (!JSON::is_bool $false); + +ok (JSON->new->allow_nonref (1)->decode ('5') == 5); +ok (JSON->new->allow_nonref (1)->decode ('-5') == -5); +ok (JSON->new->allow_nonref (1)->decode ('5e1') == 50); +ok (JSON->new->allow_nonref (1)->decode ('-333e+0') == -333); +ok (JSON->new->allow_nonref (1)->decode ('2.5') == 2.5); + +ok (JSON->new->allow_nonref (1)->decode ('""') eq ""); +ok ('[1,2,3,4]' eq encode_json decode_json ('[1,2, 3,4]')); +ok ('[{},[],[],{}]' eq encode_json decode_json ('[{},[], [ ] ,{ }]')); +ok ('[{"1":[5]}]' eq encode_json [{1 => [5]}]); +ok ('{"1":2,"3":4}' eq JSON->new->canonical (1)->encode (decode_json '{ "1" : 2, "3" : 4 }')); +ok ('{"1":2,"3":1.2}' eq JSON->new->canonical (1)->encode (decode_json '{ "1" : 2, "3" : 1.2 }')); + +ok ('[true]' eq encode_json [JSON::true]); +ok ('[false]' eq encode_json [JSON::false]); +ok ('[true]' eq encode_json [\1]); +ok ('[false]' eq encode_json [\0]); +ok ('[null]' eq encode_json [undef]); +ok ('[true]' eq encode_json [JSON::true]); +ok ('[false]' eq encode_json [JSON::false]); + +for my $v (1, 2, 3, 5, -1, -2, -3, -4, 100, 1000, 10000, -999, -88, -7, 7, 88, 999, -1e5, 1e6, 1e7, 1e8) { + ok ($v == ((decode_json "[$v]")->[0])); + ok ($v == ((decode_json encode_json [$v])->[0])); +} + +ok (30123 == ((decode_json encode_json [30123])->[0])); +ok (32123 == ((decode_json encode_json [32123])->[0])); +ok (32456 == ((decode_json encode_json [32456])->[0])); +ok (32789 == ((decode_json encode_json [32789])->[0])); +ok (32767 == ((decode_json encode_json [32767])->[0])); +ok (32768 == ((decode_json encode_json [32768])->[0])); + +my @sparse; @sparse[0,3] = (1, 4); +ok ("[1,null,null,4]" eq encode_json \@sparse); + diff --git a/third_party/JSON/JSON-2.59/t/06_pc_pretty.t b/third_party/JSON/JSON-2.59/t/06_pc_pretty.t new file mode 100644 index 0000000..8c90e28 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/06_pc_pretty.t @@ -0,0 +1,68 @@ + +# copied over from JSON::PC and modified to use JSON +# copied over from JSON::XS and modified to use JSON + +use strict; +use Test::More; +BEGIN { plan tests => 9 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +my ($js,$obj,$json); +my $pc = new JSON; + +$obj = {foo => "bar"}; +$js = $pc->encode($obj); +is($js,q|{"foo":"bar"}|); + +$obj = [10, "hoge", {foo => "bar"}]; +$pc->pretty (1); +$js = $pc->encode($obj); +is($js,q|[ + 10, + "hoge", + { + "foo" : "bar" + } +] +|); + +$obj = { foo => [ {a=>"b"}, 0, 1, 2 ] }; +$pc->pretty(0); +$js = $pc->encode($obj); +is($js,q|{"foo":[{"a":"b"},0,1,2]}|); + + +$obj = { foo => [ {a=>"b"}, 0, 1, 2 ] }; +$pc->pretty(1); +$js = $pc->encode($obj); +is($js,q|{ + "foo" : [ + { + "a" : "b" + }, + 0, + 1, + 2 + ] +} +|); + +$obj = { foo => [ {a=>"b"}, 0, 1, 2 ] }; +$pc->pretty(0); +$js = $pc->encode($obj); +is($js,q|{"foo":[{"a":"b"},0,1,2]}|); + + +$obj = {foo => "bar"}; +$pc->indent(3); # original -- $pc->indent(1); +is($pc->encode($obj), qq|{\n "foo":"bar"\n}\n|, "nospace"); +$pc->space_after(1); +is($pc->encode($obj), qq|{\n "foo": "bar"\n}\n|, "after"); +$pc->space_before(1); +is($pc->encode($obj), qq|{\n "foo" : "bar"\n}\n|, "both"); +$pc->space_after(0); +is($pc->encode($obj), qq|{\n "foo" :"bar"\n}\n|, "before"); + diff --git a/third_party/JSON/JSON-2.59/t/07_pc_esc.t b/third_party/JSON/JSON-2.59/t/07_pc_esc.t new file mode 100644 index 0000000..d515801 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/07_pc_esc.t @@ -0,0 +1,93 @@ +# +# このファイルのエンコーディングはUTF-8 +# + +# copied over from JSON::PC and modified to use JSON +# copied over from JSON::XS and modified to use JSON + +use Test::More; +use strict; + +BEGIN { plan tests => 17 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + + +use utf8; +use JSON; + +######################### +my ($js,$obj,$str); + +my $pc = new JSON; + +$obj = {test => qq|abc"def|}; +$str = $pc->encode($obj); +is($str,q|{"test":"abc\"def"}|); + +$obj = {qq|te"st| => qq|abc"def|}; +$str = $pc->encode($obj); +is($str,q|{"te\"st":"abc\"def"}|); + +$obj = {test => qq|abc/def|}; # / => \/ +$str = $pc->encode($obj); # but since version 0.99 +is($str,q|{"test":"abc/def"}|); # this handling is deleted. +$obj = $pc->decode($str); +is($obj->{test},q|abc/def|); + +$obj = {test => q|abc\def|}; +$str = $pc->encode($obj); +is($str,q|{"test":"abc\\\\def"}|); + +$obj = {test => "abc\bdef"}; +$str = $pc->encode($obj); +is($str,q|{"test":"abc\bdef"}|); + +$obj = {test => "abc\fdef"}; +$str = $pc->encode($obj); +is($str,q|{"test":"abc\fdef"}|); + +$obj = {test => "abc\ndef"}; +$str = $pc->encode($obj); +is($str,q|{"test":"abc\ndef"}|); + +$obj = {test => "abc\rdef"}; +$str = $pc->encode($obj); +is($str,q|{"test":"abc\rdef"}|); + +$obj = {test => "abc-def"}; +$str = $pc->encode($obj); +is($str,q|{"test":"abc-def"}|); + +$obj = {test => "abc(def"}; +$str = $pc->encode($obj); +is($str,q|{"test":"abc(def"}|); + +$obj = {test => "abc\\def"}; +$str = $pc->encode($obj); +is($str,q|{"test":"abc\\\\def"}|); + + +$obj = {test => "あいうえお"}; +$str = $pc->encode($obj); +is($str,q|{"test":"あいうえお"}|); + +$obj = {"あいうえお" => "かきくけこ"}; +$str = $pc->encode($obj); +is($str,q|{"あいうえお":"かきくけこ"}|); + + +$obj = $pc->decode(q|{"id":"abc\ndef"}|); +is($obj->{id},"abc\ndef",q|{"id":"abc\ndef"}|); + +$obj = $pc->decode(q|{"id":"abc\\\ndef"}|); +is($obj->{id},"abc\\ndef",q|{"id":"abc\\\ndef"}|); + +$obj = $pc->decode(q|{"id":"abc\\\\\ndef"}|); +is($obj->{id},"abc\\\ndef",q|{"id":"abc\\\\\ndef"}|); + diff --git a/third_party/JSON/JSON-2.59/t/08_pc_base.t b/third_party/JSON/JSON-2.59/t/08_pc_base.t new file mode 100644 index 0000000..ca06092 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/08_pc_base.t @@ -0,0 +1,99 @@ +use Test::More; + +# copied over from JSON::PC and modified to use JSON +# copied over from JSON::XS and modified to use JSON + +use strict; +BEGIN { plan tests => 20 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +my ($js,$obj); + +my $pc = new JSON; + +$js = q|{}|; + +$obj = $pc->decode($js); +$js = $pc->encode($obj); +is($js,'{}', '{}'); + +$js = q|[]|; +$obj = $pc->decode($js); +$js = $pc->encode($obj); +is($js,'[]', '[]'); + + +$js = q|{"foo":"bar"}|; +$obj = $pc->decode($js); +is($obj->{foo},'bar'); +$js = $pc->encode($obj); +is($js,'{"foo":"bar"}', '{"foo":"bar"}'); + +$js = q|{"foo":""}|; +$obj = $pc->decode($js); +$js = $pc->encode($obj); +is($js,'{"foo":""}', '{"foo":""}'); + +$js = q|{"foo":" "}|; +$obj = $pc->decode($js); +$js = $pc->encode($obj); +is($js,'{"foo":" "}' ,'{"foo":" "}'); + +$js = q|{"foo":"0"}|; +$obj = $pc->decode($js); +$js = $pc->encode($obj); +is($js,'{"foo":"0"}',q|{"foo":"0"} - autoencode (default)|); + + +$js = q|{"foo":"0 0"}|; +$obj = $pc->decode($js); +$js = $pc->encode($obj); +is($js,'{"foo":"0 0"}','{"foo":"0 0"}'); + +$js = q|[1,2,3]|; +$obj = $pc->decode($js); +is($obj->[1],2); +$js = $pc->encode($obj); +is($js,'[1,2,3]'); + +$js = q|{"foo":{"bar":"hoge"}}|; +$obj = $pc->decode($js); +is($obj->{foo}->{bar},'hoge'); +$js = $pc->encode($obj); +is($js,q|{"foo":{"bar":"hoge"}}|); + +$js = q|[{"foo":[1,2,3]},-0.12,{"a":"b"}]|; +$obj = $pc->decode($js); +$js = $pc->encode($obj); +is($js,q|[{"foo":[1,2,3]},-0.12,{"a":"b"}]|); + + +$obj = ["\x01"]; +is($js = $pc->encode($obj),'["\\u0001"]'); +$obj = $pc->decode($js); +is($obj->[0],"\x01"); + +$obj = ["\e"]; +is($js = $pc->encode($obj),'["\\u001b"]'); +$obj = $pc->decode($js); +is($obj->[0],"\e"); + +$js = '{"id":"}'; +eval q{ $pc->decode($js) }; +like($@, qr/unexpected end/i); + +$obj = { foo => sub { "bar" } }; +eval q{ $js = $pc->encode($obj) }; +like($@, qr/JSON can only/i, 'invalid value (coderef)'); + +#$obj = { foo => bless {}, "Hoge" }; +#eval q{ $js = $pc->encode($obj) }; +#like($@, qr/JSON can only/i, 'invalid value (blessd object)'); + +$obj = { foo => \$js }; +eval q{ $js = $pc->encode($obj) }; +like($@, qr/cannot encode reference/i, 'invalid value (ref)'); + diff --git a/third_party/JSON/JSON-2.59/t/09_pc_extra_number.t b/third_party/JSON/JSON-2.59/t/09_pc_extra_number.t new file mode 100644 index 0000000..ce60ee5 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/09_pc_extra_number.t @@ -0,0 +1,39 @@ +# copied over from JSON::PC and modified to use JSON +# copied over from JSON::XS and modified to use JSON + +use Test::More; +use strict; +BEGIN { plan tests => 6 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + + +######################### +my ($js,$obj); +my $pc = new JSON; + +$js = '{"foo":0}'; +$obj = $pc->decode($js); +is($obj->{foo}, 0, "normal 0"); + +$js = '{"foo":0.1}'; +$obj = $pc->decode($js); +is($obj->{foo}, 0.1, "normal 0.1"); + + +$js = '{"foo":10}'; +$obj = $pc->decode($js); +is($obj->{foo}, 10, "normal 10"); + +$js = '{"foo":-10}'; +$obj = $pc->decode($js); +is($obj->{foo}, -10, "normal -10"); + + +$js = '{"foo":0, "bar":0.1}'; +$obj = $pc->decode($js); +is($obj->{foo},0, "normal 0"); +is($obj->{bar},0.1,"normal 0.1"); + diff --git a/third_party/JSON/JSON-2.59/t/10_pc_keysort.t b/third_party/JSON/JSON-2.59/t/10_pc_keysort.t new file mode 100644 index 0000000..823e5a6 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/10_pc_keysort.t @@ -0,0 +1,20 @@ +# copied over from JSON::PC and modified to use JSON +# copied over from JSON::XS and modified to use JSON + +use Test::More; +use strict; +BEGIN { plan tests => 1 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; +######################### + +my ($js,$obj); +my $pc = JSON->new->canonical(1); + +$obj = {a=>1, b=>2, c=>3, d=>4, e=>5, f=>6, g=>7, h=>8, i=>9}; + +$js = $pc->encode($obj); +is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + diff --git a/third_party/JSON/JSON-2.59/t/11_pc_expo.t b/third_party/JSON/JSON-2.59/t/11_pc_expo.t new file mode 100644 index 0000000..5e587d8 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/11_pc_expo.t @@ -0,0 +1,47 @@ +# copied over from JSON::PC and modified to use JSON +# copied over from JSON::XS and modified to use JSON + +use Test::More; +use strict; +BEGIN { plan tests => 8 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +######################### +my ($js,$obj); +my $pc = new JSON; + +$js = q|[-12.34]|; +$obj = $pc->decode($js); +is($obj->[0], -12.34, 'digit -12.34'); +$js = $pc->encode($obj); +is($js,'[-12.34]', 'digit -12.34'); + +$js = q|[-1.234e5]|; +$obj = $pc->decode($js); +is($obj->[0], -123400, 'digit -1.234e5'); +$js = $pc->encode($obj); +is($js,'[-123400]', 'digit -1.234e5'); + +$js = q|[1.23E-4]|; +$obj = $pc->decode($js); +is($obj->[0], 0.000123, 'digit 1.23E-4'); +$js = $pc->encode($obj); + +if ( $js =~ /\[1/ ) { # for 5.6.2 on Darwin 8.10.0 + like($js, qr/[1.23[eE]-04]/, 'digit 1.23E-4'); +} +else { + is($js,'[0.000123]', 'digit 1.23E-4'); +} + + + +$js = q|[1.01e+67]|; # 30 -> 67 ... patched by H.Merijn Brand +$obj = $pc->decode($js); +is($obj->[0], 1.01e+67, 'digit 1.01e+67'); +$js = $pc->encode($obj); +like($js,qr/\[1.01[Ee]\+0?67\]/, 'digit 1.01e+67'); + diff --git a/third_party/JSON/JSON-2.59/t/12_blessed.t b/third_party/JSON/JSON-2.59/t/12_blessed.t new file mode 100644 index 0000000..ddd7907 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/12_blessed.t @@ -0,0 +1,53 @@ +# copied over from JSON::XS and modified to use JSON + +use strict; +use Test::More; +BEGIN { plan tests => 16 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + + +my $o1 = bless { a => 3 }, "XX"; +my $o2 = bless \(my $dummy = 1), "YY"; + +sub XX::TO_JSON { + {'__',""} +} + +my $js = JSON->new; + +eval { $js->encode ($o1) }; ok ($@ =~ /allow_blessed/); +eval { $js->encode ($o2) }; ok ($@ =~ /allow_blessed/); +$js->allow_blessed; +ok ($js->encode ($o1) eq "null"); +ok ($js->encode ($o2) eq "null"); +$js->convert_blessed; +ok ($js->encode ($o1) eq '{"__":""}'); + +ok ($js->encode ($o2) eq "null"); + +$js->filter_json_object (sub { 5 }); +$js->filter_json_single_key_object (a => sub { shift }); +$js->filter_json_single_key_object (b => sub { 7 }); + +ok ("ARRAY" eq ref $js->decode ("[]")); +ok (5 eq join ":", @{ $js->decode ('[{}]') }); +ok (6 eq join ":", @{ $js->decode ('[{"a":6}]') }); +ok (5 eq join ":", @{ $js->decode ('[{"a":4,"b":7}]') }); + +$js->filter_json_object; +ok (7 == $js->decode ('[{"a":4,"b":7}]')->[0]{b}); +ok (3 eq join ":", @{ $js->decode ('[{"a":3}]') }); + +$js->filter_json_object (sub { }); +ok (7 == $js->decode ('[{"a":4,"b":7}]')->[0]{b}); +ok (9 eq join ":", @{ $js->decode ('[{"a":9}]') }); + +$js->filter_json_single_key_object ("a"); +ok (4 == $js->decode ('[{"a":4}]')->[0]{a}); + +#$js->filter_json_single_key_object (a => sub {}); +$js->filter_json_single_key_object (a => sub { return; }); # sub {} is not suitable for Perl 5.6 +ok (4 == $js->decode ('[{"a":4}]')->[0]{a}); diff --git a/third_party/JSON/JSON-2.59/t/13_limit.t b/third_party/JSON/JSON-2.59/t/13_limit.t new file mode 100644 index 0000000..4ca8b0c --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/13_limit.t @@ -0,0 +1,34 @@ +use strict; +use Test::More; + +BEGIN { plan tests => 11 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + + +my $def = 512; + +my $js = JSON->new; + +{ + local $^W = undef; # avoid for warning 'Deep recursion on subroutin' + +ok (!eval { $js->decode (("[" x ($def + 1)) . ("]" x ($def + 1))) }); +ok (ref $js->decode (("[" x $def) . ("]" x $def))); +ok (ref $js->decode (("{\"\":" x ($def - 1)) . "[]" . ("}" x ($def - 1)))); +ok (!eval { $js->decode (("{\"\":" x $def) . "[]" . ("}" x $def)) }); + +ok (ref $js->max_depth (32)->decode (("[" x 32) . ("]" x 32))); + +ok ($js->max_depth(1)->encode ([])); +ok (!eval { $js->encode ([[]]), 1 }); + +ok ($js->max_depth(2)->encode ([{}])); +ok (!eval { $js->encode ([[{}]]), 1 }); + +ok (eval { ref $js->max_size (8)->decode ("[ ]") }); +eval { $js->max_size (8)->decode ("[ ]") }; ok ($@ =~ /max_size/); + +} diff --git a/third_party/JSON/JSON-2.59/t/14_latin1.t b/third_party/JSON/JSON-2.59/t/14_latin1.t new file mode 100644 index 0000000..238a88b --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/14_latin1.t @@ -0,0 +1,27 @@ +# copied over from JSON::XS and modified to use JSON + +use Test::More; +use strict; +BEGIN { plan tests => 4 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +use JSON; + +SKIP: { + skip "UNICODE handling is disabale.", 4 unless $JSON::can_handle_UTF16_and_utf8; + +my $xs = JSON->new->latin1->allow_nonref; + +ok $xs->encode ("\x{12}\x{89} ") eq "\"\\u0012\x{89} \""; +ok $xs->encode ("\x{12}\x{89}\x{abc}") eq "\"\\u0012\x{89}\\u0abc\""; + +ok $xs->decode ("\"\\u0012\x{89}\"" ) eq "\x{12}\x{89}"; +ok $xs->decode ("\"\\u0012\x{89}\\u0abc\"") eq "\x{12}\x{89}\x{abc}"; + +} diff --git a/third_party/JSON/JSON-2.59/t/15_prefix.t b/third_party/JSON/JSON-2.59/t/15_prefix.t new file mode 100644 index 0000000..3071be2 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/15_prefix.t @@ -0,0 +1,16 @@ +# copied over from JSON::XS and modified to use JSON + +BEGIN { $| = 1; print "1..4\n"; } +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +my $xs = JSON->new->allow_nonref; + +eval { $xs->decode ("[] ") }; +print $@ ? "not " : "", "ok 1\n"; +eval { $xs->decode ("[] x") }; +print $@ ? "" : "not ", "ok 2\n"; +print 2 == ($xs->decode_prefix ("[][]"))[1] ? "" : "not ", "ok 3\n"; +print 3 == ($xs->decode_prefix ("[1] t"))[1] ? "" : "not ", "ok 4\n"; + diff --git a/third_party/JSON/JSON-2.59/t/16_tied.t b/third_party/JSON/JSON-2.59/t/16_tied.t new file mode 100644 index 0000000..50d7272 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/16_tied.t @@ -0,0 +1,23 @@ +# copied over from JSON::XS and modified to use JSON + +use strict; +use Test::More; +BEGIN { plan tests => 2 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; +use Tie::Hash; +use Tie::Array; + +my $js = JSON->new; + +tie my %h, 'Tie::StdHash'; +%h = (a => 1); + +ok ($js->encode (\%h) eq '{"a":1}'); + +tie my @a, 'Tie::StdArray'; +@a = (1, 2); + +ok ($js->encode (\@a) eq '[1,2]'); diff --git a/third_party/JSON/JSON-2.59/t/17_relaxed.t b/third_party/JSON/JSON-2.59/t/17_relaxed.t new file mode 100644 index 0000000..e87a966 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/17_relaxed.t @@ -0,0 +1,30 @@ +# copied over from JSON::XS and modified to use JSON + +use Test::More; +use strict; + +BEGIN { plan tests => 8 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +use utf8; +use JSON; + + +my $json = JSON->new->relaxed; + +ok ('[1,2,3]' eq encode_json $json->decode (' [1,2, 3]')); +ok ('[1,2,4]' eq encode_json $json->decode ('[1,2, 4 , ]')); +ok (!eval { $json->decode ('[1,2, 3,4,,]') }); +ok (!eval { $json->decode ('[,1]') }); + +ok ('{"1":2}' eq encode_json $json->decode (' {"1":2}')); +ok ('{"1":2}' eq encode_json $json->decode ('{"1":2,}')); +ok (!eval { $json->decode ('{,}') }); + +ok ('[1,2]' eq encode_json $json->decode ("[1#,2\n ,2,# ] \n\t]")); diff --git a/third_party/JSON/JSON-2.59/t/18_json_checker.t b/third_party/JSON/JSON-2.59/t/18_json_checker.t new file mode 100644 index 0000000..5b9945a --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/18_json_checker.t @@ -0,0 +1,174 @@ + +# use the testsuite from http://www.json.org/JSON_checker/ +# except for fail18.json, as we do not support a depth of 20 (but 16 and 32). + +# copied over from JSON::XS and modified to use JSON + +use strict; +#no warnings; +local $^W = undef; +use Test::More; +BEGIN { plan tests => 39 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +my $json = JSON->new->utf8->max_depth(32)->canonical; + +binmode DATA; +my $num = 1; +for (;;) { + + $/ = "\n# "; + chomp (my $test = <DATA>) + or last; + $/ = "\n"; + my $name = <DATA>; + if (my $perl = eval { $json->decode ($test) }) { + ok ($name =~ /^pass/, $name); +#print $json->encode ($perl), "\n"; + is ($json->encode ($json->decode ($json->encode ($perl))), $json->encode ($perl)); + } else { + ok ($name =~ /^fail/, "$name ($@)"); + } + +} + +__DATA__ +"A JSON payload should be an object or array, not a string." +# fail1.json +{"Extra value after close": true} "misplaced quoted value" +# fail10.json +{"Illegal expression": 1 + 2} +# fail11.json +{"Illegal invocation": alert()} +# fail12.json +{"Numbers cannot have leading zeroes": 013} +# fail13.json +{"Numbers cannot be hex": 0x14} +# fail14.json +["Illegal backslash escape: \x15"] +# fail15.json +[\naked] +# fail16.json +["Illegal backslash escape: \017"] +# fail17.json +[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] +# fail18.json +{"Missing colon" null} +# fail19.json +["Unclosed array" +# fail2.json +{"Double colon":: null} +# fail20.json +{"Comma instead of colon", null} +# fail21.json +["Colon instead of comma": false] +# fail22.json +["Bad value", truth] +# fail23.json +['single quote'] +# fail24.json +[" tab character in string "] +# fail25.json +["tab\ character\ in\ string\ "] +# fail26.json +["line +break"] +# fail27.json +["line\ +break"] +# fail28.json +[0e] +# fail29.json +{unquoted_key: "keys must be quoted"} +# fail3.json +[0e+] +# fail30.json +[0e+-1] +# fail31.json +{"Comma instead if closing brace": true, +# fail32.json +["mismatch"} +# fail33.json +["extra comma",] +# fail4.json +["double extra comma",,] +# fail5.json +[ , "<-- missing value"] +# fail6.json +["Comma after the close"], +# fail7.json +["Extra close"]] +# fail8.json +{"Extra comma": true,} +# fail9.json +[ + "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, + "": 23456789012E66, + "zero": 0, + "one": 1, + "space": " ", + "quote": "\"", + "backslash": "\\", + "controls": "\b\f\n\r\t", + "slash": "/ & \/", + "alpha": "abcdefghijklmnopqrstuvwyz", + "ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ", + "digit": "0123456789", + "0123456789": "digit", + "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": "" \u0022 %22 0x22 034 "", + "\/\\\"\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, +1e1, +0.1e1, +1e-1, +1e00,2e+00,2e-00 +,"rosebud"] +# pass1.json +[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]] +# pass2.json +{ + "JSON Test Pattern pass3": { + "The outermost value": "must be an object or array.", + "In this test": "It is an object." + } +} + +# pass3.json diff --git a/third_party/JSON/JSON-2.59/t/19_incr.t b/third_party/JSON/JSON-2.59/t/19_incr.t new file mode 100644 index 0000000..771a01a --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/19_incr.t @@ -0,0 +1,182 @@ + +# copied over from JSON::XS and modified to use JSON + +use strict; + +use Test::More; +BEGIN { plan tests => 697 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + + +use JSON; + +if ( $] >= 5.006 ) { + +eval <<'TEST' or die "Failed to eval test code for version $]: $@"; + +sub splitter { + my ($coder, $text) = @_; + + $coder->canonical(1) if $] >= 5.017009; + + for (0 .. length $text) { + my $a = substr $text, 0, $_; + my $b = substr $text, $_; + + $coder->incr_parse ($a); + $coder->incr_parse ($b); + + my $data = $coder->incr_parse; + ok ($data); + is ($coder->encode ($data), $coder->encode ($coder->decode ($text)), "data"); + ok ($coder->incr_text =~ /^\s*$/, "tailws"); + } +} + + + +splitter +JSON->new , ' ["x\\"","\\u1000\\\\n\\nx",1,{"\\\\" :5 , "": "x"}]'; +splitter +JSON->new , '[ "x\\"","\\u1000\\\\n\\nx" , 1,{"\\\\ " :5 , "": " x"} ] '; +splitter +JSON->new->allow_nonref, '"test"'; +splitter +JSON->new->allow_nonref, ' "5" '; + + + +{ + my $text = '[5],{"":1} , [ 1,2, 3], {"3":null}'; + my $coder = new JSON; + for (0 .. length $text) { + my $a = substr $text, 0, $_; + my $b = substr $text, $_; + + $coder->incr_parse ($a); + $coder->incr_parse ($b); + + my $j1 = $coder->incr_parse; ok ($coder->incr_text =~ s/^\s*,//, "cskip1"); + my $j2 = $coder->incr_parse; ok ($coder->incr_text =~ s/^\s*,//, "cskip2"); + my $j3 = $coder->incr_parse; ok ($coder->incr_text =~ s/^\s*,//, "cskip3"); + my $j4 = $coder->incr_parse; ok ($coder->incr_text !~ s/^\s*,//, "cskip4"); + my $j5 = $coder->incr_parse; ok ($coder->incr_text !~ s/^\s*,//, "cskip5"); + + ok ('[5]' eq encode_json $j1, "cjson1"); + ok ('{"":1}' eq encode_json $j2, "cjson2"); + ok ('[1,2,3]' eq encode_json $j3, "cjson3"); + ok ('{"3":null}' eq encode_json $j4, "cjson4"); + ok (!defined $j5, "cjson5"); + } +} + +{ + my $text = '[x][5]'; + my $coder = new JSON; + $coder->incr_parse ($text); + ok (!eval { $coder->incr_parse }, "sparse1"); + ok (!eval { $coder->incr_parse }, "sparse2"); + $coder->incr_skip; + ok ('[5]' eq $coder->encode (scalar $coder->incr_parse), "sparse3"); +} + + +TEST + + +} +else { + + +eval <<'TEST' or die "Failed to eval test code for version $]: $@"; + +my $incr_text; + +sub splitter { + my ($coder, $text) = @_; + + for (0 .. length $text) { + my $a = substr $text, 0, $_; + my $b = substr $text, $_; + + $coder->incr_parse ($a); + $coder->incr_parse ($b); + + my $data = $coder->incr_parse; + ok ($data); + ok ($coder->encode ($data) eq $coder->encode ($coder->decode ($text)), "data"); + ok (($incr_text = $coder->incr_text) =~ /^\s*$/, "tailws"); + } +} + +splitter +JSON->new , ' ["x\\"","\\u1000\\\\n\\nx",1,{"\\\\" :5 , "": "x"}]'; +splitter +JSON->new , '[ "x\\"","\\u1000\\\\n\\nx" , 1,{"\\\\ " :5 , "": " x"} ] '; +splitter +JSON->new->allow_nonref, '"test"'; +splitter +JSON->new->allow_nonref, ' "5" '; + + +{ + my $text = '[5],{"":1} , [ 1,2, 3], {"3":null}'; + my $coder = new JSON; + for (0 .. length $text) { + my $a = substr $text, 0, $_; + my $b = substr $text, $_; + + $coder->incr_parse ($a); + $coder->incr_parse ($b); + + my $j1 = $coder->incr_parse; ok ( $coder->incr_text( ($incr_text = $coder->incr_text) =~ s/^\s*,// and $incr_text ), "cskip1"); + my $j2 = $coder->incr_parse; ok ( $coder->incr_text( ($incr_text = $coder->incr_text) =~ s/^\s*,// and $incr_text ), "cskip2"); + my $j3 = $coder->incr_parse; ok ( $coder->incr_text( ($incr_text = $coder->incr_text) =~ s/^\s*,// and $incr_text ), "cskip3"); + my $j4 = $coder->incr_parse; ok (($incr_text = $coder->incr_text) !~ s/^\s*,//, "cskip4"); + my $j5 = $coder->incr_parse; ok (($incr_text = $coder->incr_text) !~ s/^\s*,//, "cskip5"); + + ok ('[5]' eq encode_json $j1, "cjson1"); + ok ('{"":1}' eq encode_json $j2, "cjson2"); + ok ('[1,2,3]' eq encode_json $j3, "cjson3"); + ok ('{"3":null}' eq encode_json $j4, "cjson4"); + ok (!defined $j5, "cjson5"); + } +} + +{ + my $text = '[x][5]'; + my $coder = new JSON; + $coder->incr_parse ($text); + ok (!eval { $coder->incr_parse }, "sparse1"); + ok (!eval { $coder->incr_parse }, "sparse2"); + $coder->incr_skip; + ok ('[5]' eq $coder->encode (scalar $coder->incr_parse), "sparse3"); +} + + +TEST + +} # for 5.005 + + + + +{ + my $coder = JSON->new->max_size (5); + ok (!$coder->incr_parse ("[ "), "incsize1"); + eval q{ !$coder->incr_parse ("] ") }; ok ($@ =~ /6 bytes/, "incsize2 $@"); +} + +{ + my $coder = JSON->new->max_depth (3); + ok (!$coder->incr_parse ("[[["), "incdepth1"); + eval q{ !$coder->incr_parse (" [] ") }; ok ($@ =~ /maximum nesting/, "incdepth2 $@"); +} + +{ + my $coder = JSON->new; + + my $res = eval { $coder->incr_parse("]") }; + my $e = $@; # test more clobbers $@, we need it twice + + ok(!$res, "unbalanced bracket" ); + ok($e, "got error"); + like( $e, qr/malformed/, "malformed json string error" ); + + $coder->incr_skip; + + is_deeply(eval { $coder->incr_parse("[42]") }, [42], "valid data after incr_skip"); +} + diff --git a/third_party/JSON/JSON-2.59/t/20_unknown.t b/third_party/JSON/JSON-2.59/t/20_unknown.t new file mode 100644 index 0000000..7686929e --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/20_unknown.t @@ -0,0 +1,54 @@ + +use strict; + +use Test::More; +BEGIN { plan tests => 10 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + + +use strict; +use JSON; + +my $json = JSON->new; + +eval q| $json->encode( [ sub {} ] ) |; +ok( $@ =~ /encountered CODE/, $@ ); + +eval q| $json->encode( [ \-1 ] ) |; +ok( $@ =~ /cannot encode reference to scalar/, $@ ); + +eval q| $json->encode( [ \undef ] ) |; +ok( $@ =~ /cannot encode reference to scalar/, $@ ); + +eval q| $json->encode( [ \{} ] ) |; +ok( $@ =~ /cannot encode reference to scalar/, $@ ); + +$json->allow_unknown; + +is( $json->encode( [ sub {} ] ), '[null]' ); +is( $json->encode( [ \-1 ] ), '[null]' ); +is( $json->encode( [ \undef ] ), '[null]' ); +is( $json->encode( [ \{} ] ), '[null]' ); + + +SKIP: { + + skip "this test is for Perl 5.8 or later", 2 if( $] < 5.008 ); + +$json->allow_unknown(0); + +my $fh; +open( $fh, '>hoge.txt' ) or die $!; + +eval q| $json->encode( [ $fh ] ) |; +ok( $@ =~ /encountered GLOB/, $@ ); + +$json->allow_unknown(1); + +is( $json->encode( [ $fh ] ), '[null]' ); + +close $fh; + +unlink('hoge.txt'); + +} diff --git a/third_party/JSON/JSON-2.59/t/21_evans_bugrep.t b/third_party/JSON/JSON-2.59/t/21_evans_bugrep.t new file mode 100644 index 0000000..2e6200d --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/21_evans_bugrep.t @@ -0,0 +1,50 @@ +use strict; +use Test::More; + +BEGIN { plan tests => 6 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + + +use JSON; + +print JSON->backend, "\t", JSON->backend->VERSION, "\n"; + +my $data = ["\x{3042}\x{3044}\x{3046}\x{3048}\x{304a}", + "\x{304b}\x{304d}\x{304f}\x{3051}\x{3053}"]; + +my $j = new JSON; +my $js = $j->encode($data); +$j = undef; + +my @parts = (substr($js, 0, int(length($js) / 2)), + substr($js, int(length($js) / 2))); +$j = JSON->new; +my $object = $j->incr_parse($parts[0]); + +ok( !defined $object ); + +eval { + $j->incr_text; +}; + +like( $@, qr/incr_text can not be called when the incremental parser already started parsing/ ); + +$object = $j->incr_parse($parts[1]); + +ok( defined $object ); + +is( $object->[0], $data->[0] ); +is( $object->[1], $data->[1] ); + +eval { + $j->incr_text; +}; + +ok( !$@ ); + diff --git a/third_party/JSON/JSON-2.59/t/22_comment_at_eof.t b/third_party/JSON/JSON-2.59/t/22_comment_at_eof.t new file mode 100644 index 0000000..a388a78 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/22_comment_at_eof.t @@ -0,0 +1,47 @@ +# the oritinal test case was provided by IKEGAMI@cpan.org + +use strict; + +use Test::More tests => 13; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +use Data::Dumper qw( Dumper ); + +sub decoder { + my ($str) = @_; + + my $json = JSON->new->relaxed; + + $json->incr_parse($_[0]); + + my $rv; + if (!eval { $rv = $json->incr_parse(); 1 }) { + $rv = "died with $@"; + } + + local $Data::Dumper::Useqq = 1; + local $Data::Dumper::Terse = 1; + local $Data::Dumper::Indent = 0; + + return Dumper($rv); +} + + +is( decoder( "[]" ), '[]', 'array baseline' ); +is( decoder( " []" ), '[]', 'space ignored before array' ); +is( decoder( "\n[]" ), '[]', 'newline ignored before array' ); +is( decoder( "# foo\n[]" ), '[]', 'comment ignored before array' ); +is( decoder( "# fo[o\n[]"), '[]', 'comment ignored before array' ); +is( decoder( "# fo]o\n[]"), '[]', 'comment ignored before array' ); +is( decoder( "[# fo]o\n]"), '[]', 'comment ignored inside array' ); + +is( decoder( "" ), 'undef', 'eof baseline' ); +is( decoder( " " ), 'undef', 'space ignored before eof' ); +is( decoder( "\n" ), 'undef', 'newline ignored before eof' ); +is( decoder( "#,foo\n" ), 'undef', 'comment ignored before eof' ); +is( decoder( "# []o\n" ), 'undef', 'comment ignored before eof' ); + +is( decoder( qq/#\n[#foo\n"#\\n"#\n]/), '["#\n"]', 'array and string in multiple lines' ); diff --git a/third_party/JSON/JSON-2.59/t/99_binary.t b/third_party/JSON/JSON-2.59/t/99_binary.t new file mode 100644 index 0000000..254b08e --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/99_binary.t @@ -0,0 +1,53 @@ +# copied over from JSON::XS and modified to use JSON + +use Test::More; +use strict; +BEGIN { plan tests => 2432 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +use JSON; + +SKIP: { + skip "UNICODE handling is disabale.", 2432 unless $JSON::can_handle_UTF16_and_utf8; + +sub test($) { + my $js; + + $js = JSON->new->allow_nonref(0)->utf8->ascii->shrink->encode ([$_[0]]); + ok ($_[0] eq ((decode_json $js)->[0])); + $js = JSON->new->allow_nonref(0)->utf8->ascii->encode ([$_[0]]); + ok ($_[0] eq (JSON->new->utf8->shrink->decode($js))->[0]); + + $js = JSON->new->allow_nonref(0)->utf8->shrink->encode ([$_[0]]); + ok ($_[0] eq ((decode_json $js)->[0])); + $js = JSON->new->allow_nonref(1)->utf8->encode ([$_[0]]); + ok ($_[0] eq (JSON->new->utf8->shrink->decode($js))->[0]); + + $js = JSON->new->allow_nonref(1)->ascii->encode ([$_[0]]); + ok ($_[0] eq JSON->new->decode ($js)->[0]); + $js = JSON->new->allow_nonref(0)->ascii->encode ([$_[0]]); + ok ($_[0] eq JSON->new->shrink->decode ($js)->[0]); + + $js = JSON->new->allow_nonref(1)->shrink->encode ([$_[0]]); + ok ($_[0] eq JSON->new->decode ($js)->[0]); + $js = JSON->new->allow_nonref(0)->encode ([$_[0]]); + ok ($_[0] eq JSON->new->shrink->decode ($js)->[0]); +} + +srand 0; # doesn't help too much, but its at least more deterministic + +#for (1..768) { +for (1..64, 125..129, 255..257, 512, 704, 736, 768) { + test join "", map chr ($_ & 255), 0..$_; + test join "", map chr rand 255, 0..$_; + test join "", map chr ($_ * 97 & ~0x4000), 0..$_; + test join "", map chr (rand (2**20) & ~0x800), 0..$_; +} + +} diff --git a/third_party/JSON/JSON-2.59/t/_unicode_handling.pm b/third_party/JSON/JSON-2.59/t/_unicode_handling.pm new file mode 100644 index 0000000..28e0861 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/_unicode_handling.pm @@ -0,0 +1,28 @@ +#package utf8; +package _unicode_handling; + +# this is a dummy pragma for 5.005. + + if ($] < 5.006) { + $INC{'utf8.pm'} = './utf8.pm'; + + eval q| + sub utf8::import { } + sub utf8::unimport { } + |; + + $JSON::can_handle_UTF16_and_utf8 = 0; + } + else { + $JSON::can_handle_UTF16_and_utf8 = 1; + + if ($] > 5.007 and $] < 5.008003) { +# $JSON::can_handle_UTF16_and_utf8 = 0; + } + + } + + + + +1; diff --git a/third_party/JSON/JSON-2.59/t/e00_func.t b/third_party/JSON/JSON-2.59/t/e00_func.t new file mode 100644 index 0000000..c291d05 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e00_func.t @@ -0,0 +1,17 @@ + +use Test::More; +use strict; +BEGIN { plan tests => 2 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } +use JSON; +######################### + +my $json = JSON->new; + +my $js = 'abc'; + + +is(to_json($js, {allow_nonref => 1}), '"abc"'); + +is(from_json('"abc"', {allow_nonref => 1}), 'abc'); + diff --git a/third_party/JSON/JSON-2.59/t/e01_property.t b/third_party/JSON/JSON-2.59/t/e01_property.t new file mode 100644 index 0000000..2418ff3 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e01_property.t @@ -0,0 +1,67 @@ + +use Test::More; +use strict; + +BEGIN { plan tests => 90 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +use JSON; + +my @simples = + qw/utf8 indent canonical space_before space_after allow_nonref shrink allow_blessed + convert_blessed relaxed + /; + +if ($JSON::can_handle_UTF16_and_utf8) { + unshift @simples, 'ascii'; + unshift @simples, 'latin1'; +} + +SKIP: { + skip "UNICODE handling is disabale.", 14 unless $JSON::can_handle_UTF16_and_utf8; +} + +my $json = new JSON; + +for my $name (@simples) { + my $method = 'get_' . $name; + ok(! $json->$method(), $method . ' default'); + $json->$name(); + ok($json->$method(), $method . ' set true'); + $json->$name(0); + ok(! $json->$method(), $method . ' set false'); + $json->$name(); + ok($json->$method(), $method . ' set true again'); +} + + +ok($json->get_max_depth == 512, 'get_max_depth default'); +$json->max_depth(7); +ok($json->get_max_depth == 7, 'get_max_depth set 7 => 7'); +$json->max_depth(); +ok($json->get_max_depth != 0, 'get_max_depth no arg'); + + +ok($json->get_max_size == 0, 'get_max_size default'); +$json->max_size(7); +ok($json->get_max_size == 7, 'get_max_size set 7 => 7'); +$json->max_size(); +ok($json->get_max_size == 0, 'get_max_size no arg'); + + +for my $name (@simples) { + $json->$name(); + ok($json->property($name), $name); + $json->$name(0); + ok(! $json->property($name), $name); + $json->$name(); + ok($json->property($name), $name); +} + + diff --git a/third_party/JSON/JSON-2.59/t/e02_bool.t b/third_party/JSON/JSON-2.59/t/e02_bool.t new file mode 100644 index 0000000..12b7eb0 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e02_bool.t @@ -0,0 +1,32 @@ + +use strict; + +use Test::More; +use strict; + +BEGIN { plan tests => 11 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +my $json = new JSON; + + +is($json->encode([!1]), '[""]'); +is($json->encode([!!2]), '["1"]'); + +is($json->encode([ 'a' eq 'b' ]), '[""]'); +is($json->encode([ 'a' eq 'a' ]), '["1"]'); + +is($json->encode([ ('a' eq 'b') + 1 ]), '[1]'); +is($json->encode([ ('a' eq 'a') + 1 ]), '[2]'); + +ok(JSON::true eq 'true'); +ok(JSON::true eq '1'); +ok(JSON::true == 1); +isa_ok(JSON::true, JSON->backend . '::Boolean'); +isa_ok(JSON::true, 'JSON::Boolean'); + + + diff --git a/third_party/JSON/JSON-2.59/t/e03_bool2.t b/third_party/JSON/JSON-2.59/t/e03_bool2.t new file mode 100644 index 0000000..9daee6b --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e03_bool2.t @@ -0,0 +1,43 @@ +use Test::More; + +BEGIN { plan tests => 26 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } +use JSON; + +is(to_json([JSON::true]), q|[true]|); +is(to_json([JSON::false]), q|[false]|); +is(to_json([JSON::null]), q|[null]|); + +my $jsontext = q|[true,false,null]|; +my $obj = from_json($jsontext); + +isa_ok($obj->[0], 'JSON::Boolean'); +isa_ok($obj->[1], 'JSON::Boolean'); +ok(!defined $obj->[2], 'null is undef'); + +ok($obj->[0] == 1); +ok($obj->[0] != 0); +ok($obj->[1] == 0); +ok($obj->[1] != 1); + +ok($obj->[0] eq 'true', 'eq true'); +ok($obj->[0] ne 'false', 'ne false'); +ok($obj->[1] eq 'false', 'eq false'); +ok($obj->[1] ne 'true', 'ne true'); + +ok($obj->[0] eq $obj->[0]); +ok($obj->[0] ne $obj->[1]); + +ok(JSON::true eq 'true'); +ok(JSON::true ne 'false'); +ok(JSON::true ne 'null'); +ok(JSON::false eq 'false'); +ok(JSON::false ne 'true'); +ok(JSON::false ne 'null'); +ok(!defined JSON::null); + +is(from_json('[true]' )->[0], JSON::true); +is(from_json('[false]')->[0], JSON::false); +is(from_json('[null]' )->[0], JSON::null); + diff --git a/third_party/JSON/JSON-2.59/t/e04_sortby.t b/third_party/JSON/JSON-2.59/t/e04_sortby.t new file mode 100644 index 0000000..853b260 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e04_sortby.t @@ -0,0 +1,24 @@ + +use Test::More; +use strict; +BEGIN { plan tests => 3 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } +use JSON; +######################### + +my ($js,$obj); +my $pc = JSON->new; + +$obj = {a=>1, b=>2, c=>3, d=>4, e=>5, f=>6, g=>7, h=>8, i=>9}; + +$js = $pc->sort_by(1)->encode($obj); +is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + +$js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); +is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + +$js = $pc->sort_by('hoge')->encode($obj); +is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + +sub JSON::PP::hoge { $JSON::PP::a cmp $JSON::PP::b } diff --git a/third_party/JSON/JSON-2.59/t/e05_esc_slash.t b/third_party/JSON/JSON-2.59/t/e05_esc_slash.t new file mode 100644 index 0000000..6e50cb0 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e05_esc_slash.t @@ -0,0 +1,15 @@ + +use Test::More; +use strict; +BEGIN { plan tests => 2 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } +use JSON; +######################### + +my $json = JSON->new->allow_nonref; + +my $js = '/'; + +is($json->encode($js), '"/"'); +is($json->escape_slash->encode($js), '"\/"'); + diff --git a/third_party/JSON/JSON-2.59/t/e06_allow_barekey.t b/third_party/JSON/JSON-2.59/t/e06_allow_barekey.t new file mode 100644 index 0000000..3aad65d --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e06_allow_barekey.t @@ -0,0 +1,19 @@ + +use Test::More; +use strict; +BEGIN { plan tests => 2 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } +use JSON; +######################### + +my $json = JSON->new->allow_nonref; + +eval q| $json->decode('{foo:"bar"}') |; + +ok($@); # in XS and PP, the error message differs. + +$json->allow_barekey; + +is($json->decode('{foo:"bar"}')->{foo}, 'bar'); + + diff --git a/third_party/JSON/JSON-2.59/t/e07_allow_singlequote.t b/third_party/JSON/JSON-2.59/t/e07_allow_singlequote.t new file mode 100644 index 0000000..5591fc4 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e07_allow_singlequote.t @@ -0,0 +1,20 @@ + +use Test::More; +use strict; +BEGIN { plan tests => 4 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } +use JSON; +######################### + +my $json = JSON->new->allow_nonref; + +eval q| $json->decode("{'foo':'bar'}") |; + +ok($@); # in XS and PP, the error message differs. + +$json->allow_singlequote; + +is($json->decode(q|{'foo':"bar"}|)->{foo}, 'bar'); +is($json->decode(q|{'foo':'bar'}|)->{foo}, 'bar'); +is($json->allow_barekey->decode(q|{foo:'bar'}|)->{foo}, 'bar'); + diff --git a/third_party/JSON/JSON-2.59/t/e08_decode.t b/third_party/JSON/JSON-2.59/t/e08_decode.t new file mode 100644 index 0000000..3782dfd --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e08_decode.t @@ -0,0 +1,41 @@ +# +# decode on Perl 5.005, 5.6, 5.8 or later +# +use strict; +use Test::More; + +BEGIN { plan tests => 6 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +no utf8; + +my $json = JSON->new->allow_nonref; + + +is($json->decode(q|"ü"|), "ü"); # utf8 +is($json->decode(q|"\u00fc"|), "\xfc"); # latin1 +is($json->decode(q|"\u00c3\u00bc"|), "\xc3\xbc"); # utf8 + +my $str = 'あ'; # Japanese 'a' in utf8 + +is($json->decode(q|"\u00e3\u0081\u0082"|), $str); + +utf8::decode($str); # usually UTF-8 flagged on, but no-op for 5.005. + +is($json->decode(q|"\u3042"|), $str); + + +my $utf8 = $json->decode(q|"\ud808\udf45"|); # chr 12345 + +utf8::encode($utf8); # UTf-8 flaged off + +is($utf8, "\xf0\x92\x8d\x85"); + diff --git a/third_party/JSON/JSON-2.59/t/e09_encode.t b/third_party/JSON/JSON-2.59/t/e09_encode.t new file mode 100644 index 0000000..05acb15 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e09_encode.t @@ -0,0 +1,39 @@ +# +# decode on Perl 5.005, 5.6, 5.8 or later +# +use strict; +use Test::More; + +BEGIN { plan tests => 7 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +no utf8; + +my $json = JSON->new->allow_nonref; + +is($json->encode("ü"), q|"ü"|); # as is + +$json->ascii; + +is($json->encode("\xfc"), q|"\u00fc"|); # latin1 +is($json->encode("\xc3\xbc"), q|"\u00c3\u00bc"|); # utf8 +is($json->encode("ü"), q|"\u00c3\u00bc"|); # utf8 +is($json->encode('あ'), q|"\u00e3\u0081\u0082"|); + +if ($] >= 5.006) { + is($json->encode(chr hex 3042 ), q|"\u3042"|); + is($json->encode(chr hex 12345 ), q|"\ud808\udf45"|); +} +else { + is($json->encode(chr hex 3042 ), $json->encode(chr 66)); + is($json->encode(chr hex 12345 ), $json->encode(chr 69)); +} + diff --git a/third_party/JSON/JSON-2.59/t/e10_bignum.t b/third_party/JSON/JSON-2.59/t/e10_bignum.t new file mode 100644 index 0000000..5774f7d --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e10_bignum.t @@ -0,0 +1,41 @@ + +use strict; +use Test::More; +BEGIN { plan tests => 6 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON -support_by_pp; + +eval q| require Math::BigInt |; + +SKIP: { + skip "Can't load Math::BigInt.", 6 if ($@); + + my $v = Math::BigInt->VERSION; + $v =~ s/_.+$// if $v; + +my $fix = !$v ? '+' + : $v < 1.6 ? '+' + : ''; + + +my $json = new JSON; + +$json->allow_nonref->allow_bignum(1); +$json->convert_blessed->allow_blessed; + +my $num = $json->decode(q|100000000000000000000000000000000000000|); + +isa_ok($num, 'Math::BigInt'); +is("$num", $fix . '100000000000000000000000000000000000000'); +is($json->encode($num), $fix . '100000000000000000000000000000000000000'); + +$num = $json->decode(q|2.0000000000000000001|); + +isa_ok($num, 'Math::BigFloat'); +is("$num", '2.0000000000000000001'); +is($json->encode($num), '2.0000000000000000001'); + + +} diff --git a/third_party/JSON/JSON-2.59/t/e11_conv_blessed_univ.t b/third_party/JSON/JSON-2.59/t/e11_conv_blessed_univ.t new file mode 100644 index 0000000..18d09d4 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e11_conv_blessed_univ.t @@ -0,0 +1,45 @@ + +use strict; +use Test::More; +BEGIN { plan tests => 3 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON -convert_blessed_universally; + + +my $obj = Test->new( [ 1, 2, {foo => 'bar'} ] ); + +$obj->[3] = Test2->new( { a => 'b' } ); + +my $json = JSON->new->allow_blessed->convert_blessed; + +is( $json->encode( $obj ), '[1,2,{"foo":"bar"},"hoge"]' ); + +$json->convert_blessed(0); + +is( $json->encode( $obj ), 'null' ); + +$json->allow_blessed(0)->convert_blessed(1); + +is( $json->encode( $obj ), '[1,2,{"foo":"bar"},"hoge"]' ); + + +package Test; + +sub new { + bless $_[1], $_[0]; +} + + + +package Test2; + +sub new { + bless $_[1], $_[0]; +} + +sub TO_JSON { + "hoge"; +} + diff --git a/third_party/JSON/JSON-2.59/t/e12_upgrade.t b/third_party/JSON/JSON-2.59/t/e12_upgrade.t new file mode 100644 index 0000000..820eed8 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e12_upgrade.t @@ -0,0 +1,32 @@ +use strict; +use Test::More; + +BEGIN { plan tests => 3 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +my $json = JSON->new->allow_nonref->utf8; +my $str = '\\u00c8'; + +my $value = $json->decode( '"\\u00c8"' ); + +#use Devel::Peek; +#Dump( $value ); + +is( $value, chr 0xc8 ); + +SKIP: { + skip "UNICODE handling is disabale.", 1 unless $JSON::can_handle_UTF16_and_utf8; + ok( utf8::is_utf8( $value ) ); +} + +eval { $json->decode( '"' . chr(0xc8) . '"' ) }; +ok( $@ =~ /malformed UTF-8 character in JSON string/ ); + diff --git a/third_party/JSON/JSON-2.59/t/e13_overloaded_eq.t b/third_party/JSON/JSON-2.59/t/e13_overloaded_eq.t new file mode 100644 index 0000000..2956aac --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e13_overloaded_eq.t @@ -0,0 +1,65 @@ + +use strict; +use Test::More tests => 4; + +BEGIN { + $ENV{ PERL_JSON_BACKEND } = "JSON::backportPP"; +} + +use JSON; + +my $json = JSON->new->convert_blessed; + +my $obj = OverloadedObject->new( 'foo' ); +ok( $obj eq 'foo' ); +is( $json->encode( [ $obj ] ), q{["foo"]} ); + +# rt.cpan.org #64783 +my $foo = bless {}, 'Foo'; +my $bar = bless {}, 'Bar'; + +eval q{ $json->encode( $foo ) }; +ok($@); +eval q{ $json->encode( $bar ) }; +ok(!$@); + + +package Foo; + +use strict; +use overload ( + 'eq' => sub { 0 }, + '""' => sub { $_[0] }, + fallback => 1, +); + +sub TO_JSON { + return $_[0]; +} + +package Bar; + +use strict; +use overload ( + 'eq' => sub { 0 }, + '""' => sub { $_[0] }, + fallback => 1, +); + +sub TO_JSON { + return overload::StrVal($_[0]); +} + + +package OverloadedObject; + +use overload 'eq' => sub { $_[0]->{v} eq $_[1] }, '""' => sub { $_[0]->{v} }, fallback => 1; + + +sub new { + bless { v => $_[1] }, $_[0]; +} + + +sub TO_JSON { "$_[0]"; } + diff --git a/third_party/JSON/JSON-2.59/t/e14_decode_prefix.t b/third_party/JSON/JSON-2.59/t/e14_decode_prefix.t new file mode 100644 index 0000000..4ba39ab --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e14_decode_prefix.t @@ -0,0 +1,28 @@ + +use strict; +use Test::More tests => 8; + +BEGIN { + $ENV{ PERL_JSON_BACKEND } = "JSON::backportPP"; +} + +use JSON; + +my $json = JSON->new; + +my $complete_text = qq/{"foo":"bar"}/; +my $garbaged_text = qq/{"foo":"bar"}\n/; +my $garbaged_text2 = qq/{"foo":"bar"}\n\n/; +my $garbaged_text3 = qq/{"foo":"bar"}\n----/; + +is( ( $json->decode_prefix( $complete_text ) ) [1], 13 ); +is( ( $json->decode_prefix( $garbaged_text ) ) [1], 13 ); +is( ( $json->decode_prefix( $garbaged_text2 ) ) [1], 13 ); +is( ( $json->decode_prefix( $garbaged_text3 ) ) [1], 13 ); + +eval { $json->decode( "\n" ) }; ok( $@ =~ /malformed JSON/ ); +eval { $json->decode('null') }; ok $@ =~ /allow_nonref/; + +eval { $json->decode_prefix( "\n" ) }; ok( $@ =~ /malformed JSON/ ); +eval { $json->decode_prefix('null') }; ok $@ =~ /allow_nonref/; + diff --git a/third_party/JSON/JSON-2.59/t/e15_tie_ixhash.t b/third_party/JSON/JSON-2.59/t/e15_tie_ixhash.t new file mode 100644 index 0000000..9e8991d --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e15_tie_ixhash.t @@ -0,0 +1,44 @@ + +use strict; +use Test::More; +BEGIN { plan tests => 2 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = "JSON::backportPP"; } + +use JSON; + +# from https://rt.cpan.org/Ticket/Display.html?id=25162 + +SKIP: { + eval {require Tie::IxHash}; + skip "Can't load Tie::IxHash.", 2 if ($@); + + my %columns; + tie %columns, 'Tie::IxHash'; + + %columns = ( + id => 'int', + 1 => 'a', + 2 => 'b', + 3 => 'c', + 4 => 'd', + 5 => 'e', + ); + + my $js = to_json(\%columns); + is( $js, q/{"id":"int","1":"a","2":"b","3":"c","4":"d","5":"e"}/ ); + + $js = to_json(\%columns, {pretty => 1}); + is( $js, <<'STR' ); +{ + "id" : "int", + "1" : "a", + "2" : "b", + "3" : "c", + "4" : "d", + "5" : "e" +} +STR + +} + diff --git a/third_party/JSON/JSON-2.59/t/e16_incr_parse_fixed.t b/third_party/JSON/JSON-2.59/t/e16_incr_parse_fixed.t new file mode 100644 index 0000000..d148552 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e16_incr_parse_fixed.t @@ -0,0 +1,28 @@ + +BEGIN { + $ENV{ PERL_JSON_BACKEND } = $ARGV[0] || 'JSON::backportPP'; +} + +use strict; +use Test::More tests => 4; + +use JSON; + +my $json = JSON->new->allow_nonref(); + +my @vs = $json->incr_parse('"a\"bc'); + +ok( not scalar(@vs) ); + +@vs = $json->incr_parse('"'); + +is( $vs[0], "a\"bc" ); + + +$json = JSON->new; + +@vs = $json->incr_parse('"a\"bc'); +ok( not scalar(@vs) ); +@vs = eval { $json->incr_parse('"') }; +ok($@ =~ qr/JSON text must be an object or array/); + diff --git a/third_party/JSON/JSON-2.59/t/e90_misc.t b/third_party/JSON/JSON-2.59/t/e90_misc.t new file mode 100644 index 0000000..a5a6818 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/e90_misc.t @@ -0,0 +1,18 @@ + +use strict; +use Test::More tests => 4; + +BEGIN { + $ENV{ PERL_JSON_BACKEND } = $ARGV[0] || 'JSON::backportPP'; +} + +use JSON; + +# reported by https://rt.cpan.org/Public/Bug/Display.html?id=68359 + +eval { JSON->to_json( 5, { allow_nonref => 1 } ) }; +ok($@); + +is( q{"5"}, JSON::to_json( "5", { allow_nonref => 1 } ) ); +is( q{5}, JSON::to_json( 5, { allow_nonref => 1 } ) ); +is( q{"JSON"}, JSON::to_json( 'JSON', { allow_nonref => 1 } ) ); diff --git a/third_party/JSON/JSON-2.59/t/x00_load.t b/third_party/JSON/JSON-2.59/t/x00_load.t new file mode 100644 index 0000000..bb870f3b --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/x00_load.t @@ -0,0 +1,14 @@ + +use strict; +use Test::More; +BEGIN { plan tests => 1 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON; + +SKIP: { + skip "can't use JSON::XS.", 1, unless( JSON->backend->is_xs ); + ok(1, "load JSON::XS"); +} + diff --git a/third_party/JSON/JSON-2.59/t/x02_error.t b/third_party/JSON/JSON-2.59/t/x02_error.t new file mode 100644 index 0000000..b4f9a80 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/x02_error.t @@ -0,0 +1,61 @@ +use strict; +use Test::More; +BEGIN { plan tests => 31 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +local $^W; + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +use utf8; +use JSON; + +SKIP: { + skip "can't use JSON::XS.", 31, unless( JSON->backend->is_xs ); + +eval { JSON->new->encode ([\-1]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\undef]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\2]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\{}]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\[]]) }; ok $@ =~ /cannot encode reference/; +eval { JSON->new->encode ([\\1]) }; ok $@ =~ /cannot encode reference/; + +eval { JSON->new->allow_nonref (1)->decode ('"\u1234\udc00"') }; ok $@ =~ /missing high /; +eval { JSON->new->allow_nonref->decode ('"\ud800"') }; ok $@ =~ /missing low /; +eval { JSON->new->allow_nonref (1)->decode ('"\ud800\u1234"') }; ok $@ =~ /surrogate pair /; + +eval { JSON->new->decode ('null') }; ok $@ =~ /allow_nonref/; +eval { JSON->new->allow_nonref (1)->decode ('+0') }; ok $@ =~ /malformed/; +eval { JSON->new->allow_nonref->decode ('.2') }; ok $@ =~ /malformed/; +eval { JSON->new->allow_nonref (1)->decode ('bare') }; ok $@ =~ /malformed/; +eval { JSON->new->allow_nonref->decode ('naughty') }; ok $@ =~ /null/; +eval { JSON->new->allow_nonref (1)->decode ('01') }; ok $@ =~ /leading zero/; +eval { JSON->new->allow_nonref->decode ('00') }; ok $@ =~ /leading zero/; +eval { JSON->new->allow_nonref (1)->decode ('-0.') }; ok $@ =~ /decimal point/; +eval { JSON->new->allow_nonref->decode ('-0e') }; ok $@ =~ /exp sign/; +eval { JSON->new->allow_nonref (1)->decode ('-e+1') }; ok $@ =~ /initial minus/; +eval { JSON->new->allow_nonref->decode ("\"\n\"") }; ok $@ =~ /invalid character/; +eval { JSON->new->allow_nonref (1)->decode ("\"\x01\"") }; ok $@ =~ /invalid character/; +eval { JSON->new->decode ('[5') }; ok $@ =~ /parsing array/; +eval { JSON->new->decode ('{"5"') }; ok $@ =~ /':' expected/; +eval { JSON->new->decode ('{"5":null') }; ok $@ =~ /parsing object/; + +eval { JSON->new->decode (undef) }; ok $@ =~ /malformed/; +eval { JSON->new->decode (\5) }; ok !!$@; # Can't coerce readonly +eval { JSON->new->decode ([]) }; ok $@ =~ /malformed/; +eval { JSON->new->decode (\*STDERR) }; ok $@ =~ /malformed/; +eval { JSON->new->decode (*STDERR) }; ok !!$@; # cannot coerce GLOB + +# differences between JSON::XS and JSON::PP + +eval { decode_json ("\"\xa0") }; ok $@ =~ /malformed.*character/; +eval { decode_json ("\"\xa0\"") }; ok $@ =~ /malformed.*character/; + +#eval { decode_json ("\"\xa0") }; ok $@ =~ /JSON text must be an object or array/; +#eval { decode_json ("\"\xa0\"") }; ok $@ =~ /JSON text must be an object or array/; + +} diff --git a/third_party/JSON/JSON-2.59/t/x12_blessed.t b/third_party/JSON/JSON-2.59/t/x12_blessed.t new file mode 100644 index 0000000..b6df13a --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/x12_blessed.t @@ -0,0 +1,54 @@ +use strict; +use Test::More; +BEGIN { plan tests => 16 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON; + +SKIP: { + skip "can't use JSON::XS.", 16, unless( JSON->backend->is_xs ); + +my $o1 = bless { a => 3 }, "XX"; +my $o2 = bless \(my $dummy = 1), "YY"; + +sub XX::TO_JSON { + {'__',""} +} + +my $js = JSON->new; + +eval { $js->encode ($o1) }; ok ($@ =~ /allow_blessed/); +eval { $js->encode ($o2) }; ok ($@ =~ /allow_blessed/); +$js->allow_blessed; +ok ($js->encode ($o1) eq "null"); +ok ($js->encode ($o2) eq "null"); +$js->convert_blessed; +ok ($js->encode ($o1) eq '{"__":""}'); + +ok ($js->encode ($o2) eq "null"); + +$js->filter_json_object (sub { 5 }); +$js->filter_json_single_key_object (a => sub { shift }); +$js->filter_json_single_key_object (b => sub { 7 }); + +ok ("ARRAY" eq ref $js->decode ("[]")); +ok (5 eq join ":", @{ $js->decode ('[{}]') }); +ok (6 eq join ":", @{ $js->decode ('[{"a":6}]') }); +ok (5 eq join ":", @{ $js->decode ('[{"a":4,"b":7}]') }); + +$js->filter_json_object; +ok (7 == $js->decode ('[{"a":4,"b":7}]')->[0]{b}); +ok (3 eq join ":", @{ $js->decode ('[{"a":3}]') }); + +$js->filter_json_object (sub { }); +ok (7 == $js->decode ('[{"a":4,"b":7}]')->[0]{b}); +ok (9 eq join ":", @{ $js->decode ('[{"a":9}]') }); + +$js->filter_json_single_key_object ("a"); +ok (4 == $js->decode ('[{"a":4}]')->[0]{a}); + +$js->filter_json_single_key_object (a => sub {}); +ok (4 == $js->decode ('[{"a":4}]')->[0]{a}); + +} diff --git a/third_party/JSON/JSON-2.59/t/x16_tied.t b/third_party/JSON/JSON-2.59/t/x16_tied.t new file mode 100644 index 0000000..f219fc2 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/x16_tied.t @@ -0,0 +1,26 @@ +use strict; +use Test::More; +BEGIN { plan tests => 2 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON; +use Tie::Hash; +use Tie::Array; + +SKIP: { + skip "can't use JSON::XS.", 2, unless( JSON->backend->is_xs ); + +my $js = JSON->new; + +tie my %h, 'Tie::StdHash'; +%h = (a => 1); + +ok ($js->encode (\%h) eq '{"a":1}'); + +tie my @a, 'Tie::StdArray'; +@a = (1, 2); + +ok ($js->encode (\@a) eq '[1,2]'); + +} diff --git a/third_party/JSON/JSON-2.59/t/x17_strange_overload.t b/third_party/JSON/JSON-2.59/t/x17_strange_overload.t new file mode 100644 index 0000000..440bfe2 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/x17_strange_overload.t @@ -0,0 +1,20 @@ +use strict; +use Test::More; +BEGIN { plan tests => 2 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +SKIP: { + eval q{ + use JSON::XS; + use JSON (); + }; + + skip "can't use JSON::XS.", 2, if $@; + skip "JSON::XS version < " . JSON->require_xs_version, 2 + if JSON::XS->VERSION < JSON->require_xs_version; + + is("" . JSON::XS::true(), 'true'); + is("" . JSON::true(), 'true'); +} + diff --git a/third_party/JSON/JSON-2.59/t/xe01_property.t b/third_party/JSON/JSON-2.59/t/xe01_property.t new file mode 100644 index 0000000..6b894cd --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe01_property.t @@ -0,0 +1,56 @@ + +use Test::More; +use strict; + +BEGIN { plan tests => 90 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + + +use JSON; + +SKIP: { + skip "can't use JSON::XS.", 90, unless( JSON->backend->is_xs ); + +my @simples = + qw/ascii latin1 utf8 indent canonical space_before space_after allow_nonref shrink allow_blessed + convert_blessed relaxed + /; + +my $json = new JSON; + +for my $name (@simples) { + my $method = 'get_' . $name; + ok(! $json->$method(), $method . ' default'); + $json->$name(); + ok($json->$method(), $method . ' set true'); + $json->$name(0); + ok(! $json->$method(), $method . ' set false'); + $json->$name(); + ok($json->$method(), $method . ' set true again'); +} + + +ok($json->get_max_depth == 512, 'get_max_depth default'); +$json->max_depth(7); +ok($json->get_max_depth == 7, 'get_max_depth set 7 => 7'); +$json->max_depth(); +ok($json->get_max_depth != 0, 'get_max_depth no arg'); + +ok($json->get_max_size == 0, 'get_max_size default'); +$json->max_size(7); +ok($json->get_max_size == 7, 'get_max_size set 7 => 7'); +$json->max_size(); +ok($json->get_max_size == 0, 'get_max_size no arg'); + + +for my $name (@simples) { + $json->$name(); + ok($json->property($name), $name); + $json->$name(0); + ok(! $json->property($name), $name); + $json->$name(); + ok($json->property($name), $name); +} + +} diff --git a/third_party/JSON/JSON-2.59/t/xe02_bool.t b/third_party/JSON/JSON-2.59/t/xe02_bool.t new file mode 100644 index 0000000..04eacd7 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe02_bool.t @@ -0,0 +1,33 @@ + +use strict; + +use Test::More; +use strict; + +BEGIN { plan tests => 11 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON; + +SKIP: { + skip "can't use JSON::XS.", 11, unless( JSON->backend->is_xs ); + +my $json = new JSON; + +is($json->encode([!1]), '[""]'); +is($json->encode([!!2]), '["1"]'); + +is($json->encode([ 'a' eq 'b' ]), '[""]'); +is($json->encode([ 'a' eq 'a' ]), '["1"]'); + +is($json->encode([ ('a' eq 'b') + 1 ]), '[1]'); +is($json->encode([ ('a' eq 'a') + 1 ]), '[2]'); + +ok(JSON::true eq 'true'); +ok(JSON::true eq '1'); +ok(JSON::true == 1); +isa_ok(JSON::true, JSON->backend . '::Boolean'); +isa_ok(JSON::true, 'JSON::Boolean'); + +} diff --git a/third_party/JSON/JSON-2.59/t/xe03_bool2.t b/third_party/JSON/JSON-2.59/t/xe03_bool2.t new file mode 100644 index 0000000..7d68b32 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe03_bool2.t @@ -0,0 +1,47 @@ +use Test::More; + +BEGIN { plan tests => 26 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } +use JSON; + +SKIP: { + skip "can't use JSON::XS.", 26, unless( JSON->backend->is_xs ); + +is(to_json([JSON::true]), q|[true]|); +is(to_json([JSON::false]), q|[false]|); +is(to_json([JSON::null]), q|[null]|); + +my $jsontext = q|[true,false,null]|; +my $obj = from_json($jsontext); + +isa_ok($obj->[0], 'JSON::Boolean'); +isa_ok($obj->[1], 'JSON::Boolean'); +ok(!defined $obj->[2], 'null is undef'); + +ok($obj->[0] == 1); +ok($obj->[0] != 0); +ok($obj->[1] == 0); +ok($obj->[1] != 1); + +ok($obj->[0] eq 'true', 'eq true'); +ok($obj->[0] ne 'false', 'ne false'); +ok($obj->[1] eq 'false', 'eq false'); +ok($obj->[1] ne 'true', 'ne true'); + +ok($obj->[0] eq $obj->[0]); +ok($obj->[0] ne $obj->[1]); + +ok(JSON::true eq 'true'); +ok(JSON::true ne 'false'); +ok(JSON::true ne 'null'); +ok(JSON::false eq 'false'); +ok(JSON::false ne 'true'); +ok(JSON::false ne 'null'); +ok(!defined JSON::null); + +is(from_json('[true]' )->[0], JSON::true); +is(from_json('[false]')->[0], JSON::false); +is(from_json('[null]' )->[0], JSON::null); + +} diff --git a/third_party/JSON/JSON-2.59/t/xe04support_by_pp.t b/third_party/JSON/JSON-2.59/t/xe04support_by_pp.t new file mode 100644 index 0000000..f8c8873 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe04support_by_pp.t @@ -0,0 +1,22 @@ +use strict; +use Test::More; +BEGIN { plan tests => 3 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON -support_by_pp; + +SKIP: { + skip "can't use JSON::XS.", 3, unless( JSON->backend->is_xs ); + +my $json = new JSON; + + +is($json->escape_slash(0)->allow_nonref->encode("/"), '"/"'); +is($json->escape_slash(1)->allow_nonref->encode("/"), '"\/"'); +is($json->escape_slash(0)->allow_nonref->encode("/"), '"/"'); + + +} +__END__ + diff --git a/third_party/JSON/JSON-2.59/t/xe05_indent_length.t b/third_party/JSON/JSON-2.59/t/xe05_indent_length.t new file mode 100644 index 0000000..fc28fa3 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe05_indent_length.t @@ -0,0 +1,76 @@ +use strict; +use Test::More; +BEGIN { plan tests => 7 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON -support_by_pp; + +SKIP: { + skip "can't use JSON::XS.", 7, unless( JSON->backend->is_xs ); + +my $json = new JSON; + + +is($json->indent_length(2)->encode([1,{foo => 'bar'}, "1", "/"]), qq|[1,{"foo":"bar"},"1","/"]|); + +is($json->indent->encode([1,{foo => 'bar'}, "1", "/"]), qq|[ + 1, + { + "foo":"bar" + }, + "1", + "/" +] +|); + + +is($json->escape_slash(1)->pretty->indent_length(2)->encode([1,{foo => 'bar'}, "1", "/"]), qq|[ + 1, + { + "foo" : "bar" + }, + "1", + "\\/" +] +|); + + +is($json->escape_slash(1)->pretty->indent_length(3)->encode([1,{foo => 'bar'}, "1", "/"]), qq|[ + 1, + { + "foo" : "bar" + }, + "1", + "\\/" +] +|); + +is($json->escape_slash(1)->pretty->indent_length(15)->encode([1,{foo => 'bar'}, "1", "/"]), qq|[ + 1, + { + "foo" : "bar" + }, + "1", + "\\/" +] +|); + + +is($json->indent_length(0)->encode([1,{foo => 'bar'}, "1", "/"]), qq|[ +1, +{ +"foo" : "bar" +}, +"1", +"\\/" +] +|); + +is($json->indent(0)->space_before(0)->space_after(0)->escape_slash(0) + ->encode([1,{foo => 'bar'}, "1", "/"]), qq|[1,{"foo":"bar"},"1","/"]|); + + +} + + diff --git a/third_party/JSON/JSON-2.59/t/xe08_decode.t b/third_party/JSON/JSON-2.59/t/xe08_decode.t new file mode 100644 index 0000000..ed78fbb --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe08_decode.t @@ -0,0 +1,45 @@ +# +# decode on Perl 5.005, 5.6, 5.8 or later +# +use strict; +use Test::More; + +BEGIN { plan tests => 6 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON; + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + +no utf8; + +SKIP: { + skip "can't use JSON::XS.", 6, unless( JSON->backend->is_xs ); + +my $json = JSON->new->allow_nonref; + + +is($json->decode(q|"ü"|), "ü"); # utf8 +is($json->decode(q|"\u00fc"|), "\xfc"); # latin1 +is($json->decode(q|"\u00c3\u00bc"|), "\xc3\xbc"); # utf8 + +my $str = 'あ'; # Japanese 'a' in utf8 + +is($json->decode(q|"\u00e3\u0081\u0082"|), $str); + +utf8::decode($str); # usually UTF-8 flagged on, but no-op for 5.005. + +is($json->decode(q|"\u3042"|), $str); + + +my $utf8 = $json->decode(q|"\ud808\udf45"|); # chr 12345 + +utf8::encode($utf8); # UTf-8 flaged off + +is($utf8, "\xf0\x92\x8d\x85"); + +} diff --git a/third_party/JSON/JSON-2.59/t/xe10_bignum.t b/third_party/JSON/JSON-2.59/t/xe10_bignum.t new file mode 100644 index 0000000..d72b8ad --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe10_bignum.t @@ -0,0 +1,36 @@ + +use strict; +use Test::More; +BEGIN { plan tests => 6 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON -support_by_pp; + +eval q| require Math::BigInt |; + + +SKIP: { + skip "can't use JSON::XS.", 6, unless( JSON->backend->is_xs ); + skip "Can't load Math::BigInt.", 6 if ($@); + +my $json = new JSON; +print $json->backend, "\n"; + +$json->allow_nonref->allow_bignum(1); +$json->convert_blessed->allow_blessed; + +my $num = $json->decode(q|100000000000000000000000000000000000000|); + +isa_ok($num, 'Math::BigInt'); +is($num, '100000000000000000000000000000000000000'); +is($json->encode($num), '100000000000000000000000000000000000000'); + +$num = $json->decode(q|2.0000000000000000001|); + +isa_ok($num, 'Math::BigFloat'); +is($num, '2.0000000000000000001'); +is($json->encode($num), '2.0000000000000000001'); + + +} diff --git a/third_party/JSON/JSON-2.59/t/xe11_conv_blessed_univ.t b/third_party/JSON/JSON-2.59/t/xe11_conv_blessed_univ.t new file mode 100644 index 0000000..8ccc0c1 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe11_conv_blessed_univ.t @@ -0,0 +1,48 @@ + +use strict; +use Test::More; +BEGIN { plan tests => 3 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON -convert_blessed_universally; + +SKIP: { + skip "can't use JSON::XS.", 3, unless( JSON->backend->is_xs ); + +my $obj = Test->new( [ 1, 2, {foo => 'bar'} ] ); + +$obj->[3] = Test2->new( { a => 'b' } ); + +my $json = JSON->new->allow_blessed->convert_blessed; + +is( $json->encode( $obj ), '[1,2,{"foo":"bar"},"hoge"]' ); + +$json->convert_blessed(0); + +is( $json->encode( $obj ), 'null' ); + +$json->allow_blessed(0)->convert_blessed(1); + +is( $json->encode( $obj ), '[1,2,{"foo":"bar"},"hoge"]' ); + +} + +package Test; + +sub new { + bless $_[1], $_[0]; +} + + + +package Test2; + +sub new { + bless $_[1], $_[0]; +} + +sub TO_JSON { + "hoge"; +} + diff --git a/third_party/JSON/JSON-2.59/t/xe12_boolean.t b/third_party/JSON/JSON-2.59/t/xe12_boolean.t new file mode 100644 index 0000000..1d790d5 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe12_boolean.t @@ -0,0 +1,35 @@ + +use strict; +use Test::More; + +BEGIN { plan tests => 4 }; + +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON -support_by_pp; + +BEGIN { + use lib qw(t); + use _unicode_handling; +} + + +SKIP: { + skip "can't use JSON::XS.", 4, unless( JSON->backend->is_xs ); + +my $json = new JSON; +my $bool = $json->allow_nonref->decode('true'); + +# it's normal +isa_ok( $bool, 'JSON::Boolean' ); +is( $json->encode([ JSON::true ]), '[true]' ); + +# make XS non support flag enable! +$bool = $json->allow_singlequote->decode('true'); + +isa_ok( $bool, 'JSON::Boolean' ); +is( $json->encode([ JSON::true ]), '[true]' ); + +} + +__END__ diff --git a/third_party/JSON/JSON-2.59/t/xe19_xs_and_suportbypp.t b/third_party/JSON/JSON-2.59/t/xe19_xs_and_suportbypp.t new file mode 100644 index 0000000..1c9e2f5 --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe19_xs_and_suportbypp.t @@ -0,0 +1,33 @@ + +# https://rt.cpan.org/Public/Bug/Display.html?id=52847 + +use strict; +use Test::More; + +BEGIN { plan tests => 2 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON -support_by_pp; + +SKIP: { + skip "can't use JSON::XS.", 2, unless( JSON->backend->is_xs ); + + my $json = JSON->new->allow_barekey; + + for (1..2) { + is_deeply( test($json, q!{foo:"foo"}! ), {foo=>'foo'} ); + JSON->new->allow_singlequote(0); + } +} + + +sub test { + my ($coder, $str) = @_; + my $rv; + return $rv if eval { $rv = $coder->decode($str); 1 }; + chomp( my $e = $@ ); + return "died with \"$e\""; +}; + + + diff --git a/third_party/JSON/JSON-2.59/t/xe20_croak_message.t b/third_party/JSON/JSON-2.59/t/xe20_croak_message.t new file mode 100644 index 0000000..1af44dd --- /dev/null +++ b/third_party/JSON/JSON-2.59/t/xe20_croak_message.t @@ -0,0 +1,21 @@ + +# https://rt.cpan.org/Public/Bug/Display.html?id=61708 + +use strict; +use Test::More; + +BEGIN { plan tests => 1 }; +BEGIN { $ENV{PERL_JSON_BACKEND} = 1; } + +use JSON; # currently it can't pass with -support_by_pp; + + +SKIP: { + skip "can't use JSON::XS.", 1, unless( JSON->backend->is_xs ); + + my $json = JSON->new; + + eval q{ $json->encode( undef ) }; + like( $@, qr/line 1\./ ); +} + diff --git a/third_party/JSON/LICENSE b/third_party/JSON/LICENSE new file mode 100644 index 0000000..ed4ee19 --- /dev/null +++ b/third_party/JSON/LICENSE @@ -0,0 +1,1092 @@ +JSON.pm is licensed under the same terms as Perl itself, +namely GPL v1+/Artistic License. +Included below are exact text of JSON.pm and Perl licenses, +together with full texts of GPL v1, GPL v3 (latest version), and +Artistic License. + + +JSON.pm: +http://search.cpan.org/~makamaka/JSON-2.58/lib/JSON.pm#COPYRIGHT_AND_LICENSE +COPYRIGHT AND LICENSE + +Copyright 2005-2013 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself. + + +Perl: +http://dev.perl.org/licenses/ + +Perl5 is Copyright (C) 1993-2005, by Larry Wall and others. + +It is free software; you can redistribute it and/or modify it under the terms of either: + +a) the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version, or + +b) the "Artistic License". + + +GPL v1 +http://www.gnu.org/licenses/gpl-1.0.txt + + GNU GENERAL PUBLIC LICENSE + Version 1, February 1989 + + Copyright (C) 1989 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The license agreements of most software companies try to keep users +at the mercy of those companies. By contrast, our General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. The +General Public License applies to the Free Software Foundation's +software and to any other program whose authors commit to using it. +You can use it for your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Specifically, the General Public License is designed to make +sure that you have the freedom to give away or sell copies of free +software, that you receive source code or can get it if you want it, +that you can change the software or use pieces of it in new free +programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of a such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must tell them their rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any program or other work which +contains a notice placed by the copyright holder saying it may be +distributed under the terms of this General Public License. The +"Program", below, refers to any such program or work, and a "work based +on the Program" means either the Program or any work containing the +Program or a portion of it, either verbatim or with modifications. Each +licensee is addressed as "you". + + 1. You may copy and distribute verbatim copies of the Program's source +code as you receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice and +disclaimer of warranty; keep intact all the notices that refer to this +General Public License and to the absence of any warranty; and give any +other recipients of the Program a copy of this General Public License +along with the Program. You may charge a fee for the physical act of +transferring a copy. + + 2. You may modify your copy or copies of the Program or any portion of +it, and copy and distribute such modifications under the terms of Paragraph +1 above, provided that you also do the following: + + a) cause the modified files to carry prominent notices stating that + you changed the files and the date of any change; and + + b) cause the whole of any work that you distribute or publish, that + in whole or in part contains the Program or any part thereof, either + with or without modifications, to be licensed at no charge to all + third parties under the terms of this General Public License (except + that you may choose to grant warranty protection to some or all + third parties, at your option). + + c) If the modified program normally reads commands interactively when + run, you must cause it, when started running for such interactive use + in the simplest and most usual way, to print or display an + announcement including an appropriate copyright notice and a notice + that there is no warranty (or else, saying that you provide a + warranty) and that users may redistribute the program under these + conditions, and telling the user how to view a copy of this General + Public License. + + d) You may charge a fee for the physical act of transferring a + copy, and you may at your option offer warranty protection in + exchange for a fee. + +Mere aggregation of another independent work with the Program (or its +derivative) on a volume of a storage or distribution medium does not bring +the other work under the scope of these terms. + + 3. You may copy and distribute the Program (or a portion or derivative of +it, under Paragraph 2) in object code or executable form under the terms of +Paragraphs 1 and 2 above provided that you also do one of the following: + + a) accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of + Paragraphs 1 and 2 above; or, + + b) accompany it with a written offer, valid for at least three + years, to give any third party free (except for a nominal charge + for the cost of distribution) a complete machine-readable copy of the + corresponding source code, to be distributed under the terms of + Paragraphs 1 and 2 above; or, + + c) accompany it with the information you received as to where the + corresponding source code may be obtained. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form alone.) + +Source code for a work means the preferred form of the work for making +modifications to it. For an executable file, complete source code means +all the source code for all modules it contains; but, as a special +exception, it need not include source code for modules which are standard +libraries that accompany the operating system on which the executable +file runs, or for standard header files or definitions files that +accompany that operating system. + + 4. You may not copy, modify, sublicense, distribute or transfer the +Program except as expressly provided under this General Public License. +Any attempt otherwise to copy, modify, sublicense, distribute or transfer +the Program is void, and will automatically terminate your rights to use +the Program under this License. However, parties who have received +copies, or rights to use copies, from you under this General Public +License will not have their licenses terminated so long as such parties +remain in full compliance. + + 5. By copying, distributing or modifying the Program (or any work based +on the Program) you indicate your acceptance of this license to do so, +and all its terms and conditions. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the original +licensor to copy, distribute or modify the Program subject to these +terms and conditions. You may not impose any further restrictions on the +recipients' exercise of the rights granted herein. + + 7. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of the license which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +the license, you may choose any version ever published by the Free Software +Foundation. + + 8. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + Appendix: How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to humanity, the best way to achieve this is to make it +free software which everyone can redistribute and change under these +terms. + + To do so, attach the following notices to the program. It is safest to +attach them to the start of each source file to most effectively convey +the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) 19yy <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19xx name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the +appropriate parts of the General Public License. Of course, the +commands you use may be called something other than `show w' and `show +c'; they could even be mouse-clicks or menu items--whatever suits your +program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + program `Gnomovision' (a program to direct compilers to make passes + at assemblers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +That's all there is to it! + + +GPL v3 +http://www.gnu.org/licenses/gpl-3.0.txt + + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + <program> Copyright (C) <year> <name of author> + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +<http://www.gnu.org/licenses/>. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +<http://www.gnu.org/philosophy/why-not-lgpl.html>. + + +Artistic License +http://dev.perl.org/licenses/artistic.html + + The "Artistic License" + + Preamble + +The intent of this document is to state the conditions under which a +Package may be copied, such that the Copyright Holder maintains some +semblance of artistic control over the development of the package, +while giving the users of the package the right to use and distribute +the Package in a more-or-less customary fashion, plus the right to make +reasonable modifications. + +Definitions: + + "Package" refers to the collection of files distributed by the + Copyright Holder, and derivatives of that collection of files + created through textual modification. + + "Standard Version" refers to such a Package if it has not been + modified, or has been modified in accordance with the wishes + of the Copyright Holder as specified below. + + "Copyright Holder" is whoever is named in the copyright or + copyrights for the package. + + "You" is you, if you're thinking about copying or distributing + this Package. + + "Reasonable copying fee" is whatever you can justify on the + basis of media cost, duplication charges, time of people involved, + and so on. (You will not be required to justify it to the + Copyright Holder, but only to the computing community at large + as a market that must bear the fee.) + + "Freely Available" means that no fee is charged for the item + itself, though there may be fees involved in handling the item. + It also means that recipients of the item may redistribute it + under the same conditions they received it. + +1. You may make and give away verbatim copies of the source form of the +Standard Version of this Package without restriction, provided that you +duplicate all of the original copyright notices and associated disclaimers. + +2. You may apply bug fixes, portability fixes and other modifications +derived from the Public Domain or from the Copyright Holder. A Package +modified in such a way shall still be considered the Standard Version. + +3. You may otherwise modify your copy of this Package in any way, provided +that you insert a prominent notice in each changed file stating how and +when you changed that file, and provided that you do at least ONE of the +following: + + a) place your modifications in the Public Domain or otherwise make them + Freely Available, such as by posting said modifications to Usenet or + an equivalent medium, or placing the modifications on a major archive + site such as uunet.uu.net, or by allowing the Copyright Holder to include + your modifications in the Standard Version of the Package. + + b) use the modified Package only within your corporation or organization. + + c) rename any non-standard executables so the names do not conflict + with standard executables, which must also be provided, and provide + a separate manual page for each non-standard executable that clearly + documents how it differs from the Standard Version. + + d) make other distribution arrangements with the Copyright Holder. + +4. You may distribute the programs of this Package in object code or +executable form, provided that you do at least ONE of the following: + + a) distribute a Standard Version of the executables and library files, + together with instructions (in the manual page or equivalent) on where + to get the Standard Version. + + b) accompany the distribution with the machine-readable source of + the Package with your modifications. + + c) give non-standard executables non-standard names, and clearly + document the differences in manual pages (or equivalent), together + with instructions on where to get the Standard Version. + + d) make other distribution arrangements with the Copyright Holder. + +5. You may charge a reasonable copying fee for any distribution of this +Package. You may charge any fee you choose for support of this +Package. You may not charge a fee for this Package itself. However, +you may distribute this Package in aggregate with other (possibly +commercial) programs as part of a larger (possibly commercial) software +distribution provided that you do not advertise this Package as a +product of your own. You may embed this Package's interpreter within +an executable of yours (by linking); this shall be construed as a mere +form of aggregation, provided that the complete Standard Version of the +interpreter is so embedded. + +6. The scripts and library files supplied as input to or produced as +output from the programs of this Package do not automatically fall +under the copyright of this Package, but belong to whoever generated +them, and may be sold commercially, and may be aggregated with this +Package. If such scripts or library files are aggregated with this +Package via the so-called "undump" or "unexec" methods of producing a +binary executable image, then distribution of such an image shall +neither be construed as a distribution of this Package nor shall it +fall under the restrictions of Paragraphs 3 and 4, provided that you do +not represent such an executable image as a Standard Version of this +Package. + +7. C subroutines (or comparably compiled subroutines in other +languages) supplied by you and linked into this Package in order to +emulate subroutines and variables of the language defined by this +Package shall not be considered part of this Package, but are the +equivalent of input as in Paragraph 6, provided these subroutines do +not change the language in any way that would cause it to fail the +regression tests for the language. + +8. Aggregation of this Package with a commercial distribution is always +permitted provided that the use of this Package is embedded; that is, +when no overt attempt is made to make this Package's interfaces visible +to the end user of the commercial distribution. Such use shall not be +construed as a distribution of this Package. + +9. The name of the Copyright Holder may not be used to endorse or promote +products derived from this software without specific prior written permission. + +10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED +WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + + The End diff --git a/third_party/JSON/OWNERS b/third_party/JSON/OWNERS new file mode 100644 index 0000000..c8840a3 --- /dev/null +++ b/third_party/JSON/OWNERS @@ -0,0 +1,2 @@ +haraken@chromium.org +nbarth@chromium.org diff --git a/third_party/JSON/README.chromium b/third_party/JSON/README.chromium new file mode 100644 index 0000000..72abe99 --- /dev/null +++ b/third_party/JSON/README.chromium @@ -0,0 +1,20 @@ +Name: JSON - JSON (JavaScript Object Notation) encoder/decoder +Short Name: JSON.pm +URL: http://search.cpan.org/~makamaka/JSON-2.59/lib/JSON.pm +Version: 2.59 +License: GPL v1 or later / Artistic License +License File: NOT_SHIPPED +Security Critical: no + +Description: +This directory contains JSON.pm, used by Perl scripts at build time +to read and write data in the JSON format. +JSON.pm is included in Perl 5.14+ as a core module, but not in earlier +versions, hence needed as separate module. + +Source: http://www.cpan.org/authors/id/M/MA/MAKAMAKA/JSON-2.59.tar.gz +SHA-1: 8a82c442088ffa0d605747fd5e65f51e037aad94 + +Local modifications: +Contains both source and built module, together with a script to download +archive, check SHA-1 hash, then (if ok) unarchive and build it. diff --git a/third_party/JSON/get_and_build_json_pm.sh b/third_party/JSON/get_and_build_json_pm.sh new file mode 100755 index 0000000..9f86967 --- /dev/null +++ b/third_party/JSON/get_and_build_json_pm.sh @@ -0,0 +1,80 @@ +#!/bin/bash +# Download and build JSON.pm +# Homepage: +# http://search.cpan.org/~makamaka/JSON-2.58/lib/JSON.pm +# SRC_URL='http://www.cpan.org/authors/id/M/MA/MAKAMAKA/JSON-2.58.tar.gz' +PACKAGE='JSON' +VERSION='2.59' +SRC_URL="http://www.cpan.org/authors/id/M/MA/MAKAMAKA/$PACKAGE-$VERSION.tar.gz" +FILENAME="$(basename $SRC_URL)" +SHA1_FILENAME="$FILENAME.sha1" +BUILD_DIR="$PACKAGE-$VERSION" +INSTALL_DIR="$(pwd)/out" + +curl --remote-name "$SRC_URL" + +# Check hash +# SHA-1 hash generated via: +# shasum JSON-2.59.tar.gz > JSON-2.59.tar.gz.sha1 +if ! [ -f "$SHA1_FILENAME" ] +then + echo "SHA-1 hash file $SHA1_FILENAME not found, could not verify archive" + exit 1 +fi + +# Check that hash file contains hash for archive +HASHFILE_REGEX="^[0-9a-f]{40} $FILENAME" # 40-digit hash, followed by filename +if ! grep --extended-regex --line-regex --silent \ + "$HASHFILE_REGEX" "$SHA1_FILENAME" +then + echo "SHA-1 hash file $SHA1_FILENAME does not contain hash for $FILENAME," \ + 'could not verify archive' + echo 'Hash file contents are:' + cat "$SHA1_FILENAME" + exit 1 +fi + +if ! shasum --check "$SHA1_FILENAME" +then + echo 'SHA-1 hash does not match,' \ + "archive file $FILENAME corrupt or compromised!" + exit 1 +fi + +# Extract and build +tar xvzf "$FILENAME" +cd "$BUILD_DIR" +perl Makefile.PL INSTALL_BASE="$INSTALL_DIR" +make +make test +make install +cd .. +rm "$FILENAME" + +# Rename :: to __ because : is reserved in Windows filenames +# (only occurs in man pages, which aren't necessary) +for i in $(find . -name '*::*') +do + mv -f "$i" `echo "$i" | sed s/::/__/g` +done + +# Fix permissions and shebangs +# https://rt.cpan.org/Public/Bug/Display.html?id=85917 +# Make examples executable +cd "$BUILD_DIR" +chmod +x eg/*.pl +cd t + +# Strip shebangs from test files that have them +for i in *.t +do + if head -1 "$i" | grep --quiet '^#!' + then + ed -s "$i" <<END +# Delete line 1 +1d +# Write and Quit +wq +END + fi +done diff --git a/third_party/JSON/out/lib/perl5/JSON.pm b/third_party/JSON/out/lib/perl5/JSON.pm new file mode 100644 index 0000000..bd39cd8 --- /dev/null +++ b/third_party/JSON/out/lib/perl5/JSON.pm @@ -0,0 +1,2292 @@ +package JSON; + + +use strict; +use Carp (); +use base qw(Exporter); +@JSON::EXPORT = qw(from_json to_json jsonToObj objToJson encode_json decode_json); + +BEGIN { + $JSON::VERSION = '2.59'; + $JSON::DEBUG = 0 unless (defined $JSON::DEBUG); + $JSON::DEBUG = $ENV{ PERL_JSON_DEBUG } if exists $ENV{ PERL_JSON_DEBUG }; +} + +my $Module_XS = 'JSON::XS'; +my $Module_PP = 'JSON::PP'; +my $Module_bp = 'JSON::backportPP'; # included in JSON distribution +my $PP_Version = '2.27200'; +my $XS_Version = '2.34'; + + +# XS and PP common methods + +my @PublicMethods = qw/ + ascii latin1 utf8 pretty indent space_before space_after relaxed canonical allow_nonref + allow_blessed convert_blessed filter_json_object filter_json_single_key_object + shrink max_depth max_size encode decode decode_prefix allow_unknown +/; + +my @Properties = qw/ + ascii latin1 utf8 indent space_before space_after relaxed canonical allow_nonref + allow_blessed convert_blessed shrink max_depth max_size allow_unknown +/; + +my @XSOnlyMethods = qw//; # Currently nothing + +my @PPOnlyMethods = qw/ + indent_length sort_by + allow_singlequote allow_bignum loose allow_barekey escape_slash as_nonblessed +/; # JSON::PP specific + + +# used in _load_xs and _load_pp ($INSTALL_ONLY is not used currently) +my $_INSTALL_DONT_DIE = 1; # When _load_xs fails to load XS, don't die. +my $_INSTALL_ONLY = 2; # Don't call _set_methods() +my $_ALLOW_UNSUPPORTED = 0; +my $_UNIV_CONV_BLESSED = 0; +my $_USSING_bpPP = 0; + + +# Check the environment variable to decide worker module. + +unless ($JSON::Backend) { + $JSON::DEBUG and Carp::carp("Check used worker module..."); + + my $backend = exists $ENV{PERL_JSON_BACKEND} ? $ENV{PERL_JSON_BACKEND} : 1; + + if ($backend eq '1' or $backend =~ /JSON::XS\s*,\s*JSON::PP/) { + _load_xs($_INSTALL_DONT_DIE) or _load_pp(); + } + elsif ($backend eq '0' or $backend eq 'JSON::PP') { + _load_pp(); + } + elsif ($backend eq '2' or $backend eq 'JSON::XS') { + _load_xs(); + } + elsif ($backend eq 'JSON::backportPP') { + $_USSING_bpPP = 1; + _load_pp(); + } + else { + Carp::croak "The value of environmental variable 'PERL_JSON_BACKEND' is invalid."; + } +} + + +sub import { + my $pkg = shift; + my @what_to_export; + my $no_export; + + for my $tag (@_) { + if ($tag eq '-support_by_pp') { + if (!$_ALLOW_UNSUPPORTED++) { + JSON::Backend::XS + ->support_by_pp(@PPOnlyMethods) if ($JSON::Backend eq $Module_XS); + } + next; + } + elsif ($tag eq '-no_export') { + $no_export++, next; + } + elsif ( $tag eq '-convert_blessed_universally' ) { + eval q| + require B; + *UNIVERSAL::TO_JSON = sub { + my $b_obj = B::svref_2object( $_[0] ); + return $b_obj->isa('B::HV') ? { %{ $_[0] } } + : $b_obj->isa('B::AV') ? [ @{ $_[0] } ] + : undef + ; + } + | if ( !$_UNIV_CONV_BLESSED++ ); + next; + } + push @what_to_export, $tag; + } + + return if ($no_export); + + __PACKAGE__->export_to_level(1, $pkg, @what_to_export); +} + + +# OBSOLETED + +sub jsonToObj { + my $alternative = 'from_json'; + if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) { + shift @_; $alternative = 'decode'; + } + Carp::carp "'jsonToObj' will be obsoleted. Please use '$alternative' instead."; + return JSON::from_json(@_); +}; + +sub objToJson { + my $alternative = 'to_json'; + if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) { + shift @_; $alternative = 'encode'; + } + Carp::carp "'objToJson' will be obsoleted. Please use '$alternative' instead."; + JSON::to_json(@_); +}; + + +# INTERFACES + +sub to_json ($@) { + if ( + ref($_[0]) eq 'JSON' + or (@_ > 2 and $_[0] eq 'JSON') + ) { + Carp::croak "to_json should not be called as a method."; + } + my $json = JSON->new; + + if (@_ == 2 and ref $_[1] eq 'HASH') { + my $opt = $_[1]; + for my $method (keys %$opt) { + $json->$method( $opt->{$method} ); + } + } + + $json->encode($_[0]); +} + + +sub from_json ($@) { + if ( ref($_[0]) eq 'JSON' or $_[0] eq 'JSON' ) { + Carp::croak "from_json should not be called as a method."; + } + my $json = JSON->new; + + if (@_ == 2 and ref $_[1] eq 'HASH') { + my $opt = $_[1]; + for my $method (keys %$opt) { + $json->$method( $opt->{$method} ); + } + } + + return $json->decode( $_[0] ); +} + + +sub true { $JSON::true } + +sub false { $JSON::false } + +sub null { undef; } + + +sub require_xs_version { $XS_Version; } + +sub backend { + my $proto = shift; + $JSON::Backend; +} + +#*module = *backend; + + +sub is_xs { + return $_[0]->module eq $Module_XS; +} + + +sub is_pp { + return not $_[0]->xs; +} + + +sub pureperl_only_methods { @PPOnlyMethods; } + + +sub property { + my ($self, $name, $value) = @_; + + if (@_ == 1) { + my %props; + for $name (@Properties) { + my $method = 'get_' . $name; + if ($name eq 'max_size') { + my $value = $self->$method(); + $props{$name} = $value == 1 ? 0 : $value; + next; + } + $props{$name} = $self->$method(); + } + return \%props; + } + elsif (@_ > 3) { + Carp::croak('property() can take only the option within 2 arguments.'); + } + elsif (@_ == 2) { + if ( my $method = $self->can('get_' . $name) ) { + if ($name eq 'max_size') { + my $value = $self->$method(); + return $value == 1 ? 0 : $value; + } + $self->$method(); + } + } + else { + $self->$name($value); + } + +} + + + +# INTERNAL + +sub _load_xs { + my $opt = shift; + + $JSON::DEBUG and Carp::carp "Load $Module_XS."; + + # if called after install module, overload is disable.... why? + JSON::Boolean::_overrride_overload($Module_XS); + JSON::Boolean::_overrride_overload($Module_PP); + + eval qq| + use $Module_XS $XS_Version (); + |; + + if ($@) { + if (defined $opt and $opt & $_INSTALL_DONT_DIE) { + $JSON::DEBUG and Carp::carp "Can't load $Module_XS...($@)"; + return 0; + } + Carp::croak $@; + } + + unless (defined $opt and $opt & $_INSTALL_ONLY) { + _set_module( $JSON::Backend = $Module_XS ); + my $data = join("", <DATA>); # this code is from Jcode 2.xx. + close(DATA); + eval $data; + JSON::Backend::XS->init; + } + + return 1; +}; + + +sub _load_pp { + my $opt = shift; + my $backend = $_USSING_bpPP ? $Module_bp : $Module_PP; + + $JSON::DEBUG and Carp::carp "Load $backend."; + + # if called after install module, overload is disable.... why? + JSON::Boolean::_overrride_overload($Module_XS); + JSON::Boolean::_overrride_overload($backend); + + if ( $_USSING_bpPP ) { + eval qq| require $backend |; + } + else { + eval qq| use $backend $PP_Version () |; + } + + if ($@) { + if ( $backend eq $Module_PP ) { + $JSON::DEBUG and Carp::carp "Can't load $Module_PP ($@), so try to load $Module_bp"; + $_USSING_bpPP++; + $backend = $Module_bp; + JSON::Boolean::_overrride_overload($backend); + local $^W; # if PP installed but invalid version, backportPP redefines methods. + eval qq| require $Module_bp |; + } + Carp::croak $@ if $@; + } + + unless (defined $opt and $opt & $_INSTALL_ONLY) { + _set_module( $JSON::Backend = $Module_PP ); # even if backportPP, set $Backend with 'JSON::PP' + JSON::Backend::PP->init; + } +}; + + +sub _set_module { + return if defined $JSON::true; + + my $module = shift; + + local $^W; + no strict qw(refs); + + $JSON::true = ${"$module\::true"}; + $JSON::false = ${"$module\::false"}; + + push @JSON::ISA, $module; + push @{"$module\::Boolean::ISA"}, qw(JSON::Boolean); + + *{"JSON::is_bool"} = \&{"$module\::is_bool"}; + + for my $method ($module eq $Module_XS ? @PPOnlyMethods : @XSOnlyMethods) { + *{"JSON::$method"} = sub { + Carp::carp("$method is not supported in $module."); + $_[0]; + }; + } + + return 1; +} + + + +# +# JSON Boolean +# + +package JSON::Boolean; + +my %Installed; + +sub _overrride_overload { + return if ($Installed{ $_[0] }++); + + my $boolean = $_[0] . '::Boolean'; + + eval sprintf(q| + package %s; + use overload ( + '""' => sub { ${$_[0]} == 1 ? 'true' : 'false' }, + 'eq' => sub { + my ($obj, $op) = ref ($_[0]) ? ($_[0], $_[1]) : ($_[1], $_[0]); + if ($op eq 'true' or $op eq 'false') { + return "$obj" eq 'true' ? 'true' eq $op : 'false' eq $op; + } + else { + return $obj ? 1 == $op : 0 == $op; + } + }, + ); + |, $boolean); + + if ($@) { Carp::croak $@; } + + if ( exists $INC{'JSON/XS.pm'} and $boolean eq 'JSON::XS::Boolean' ) { + local $^W; + my $true = do { bless \(my $dummy = 1), $boolean }; + my $false = do { bless \(my $dummy = 0), $boolean }; + *JSON::XS::true = sub () { $true }; + *JSON::XS::false = sub () { $false }; + } + elsif ( exists $INC{'JSON/PP.pm'} and $boolean eq 'JSON::PP::Boolean' ) { + local $^W; + my $true = do { bless \(my $dummy = 1), $boolean }; + my $false = do { bless \(my $dummy = 0), $boolean }; + *JSON::PP::true = sub { $true }; + *JSON::PP::false = sub { $false }; + } + + return 1; +} + + +# +# Helper classes for Backend Module (PP) +# + +package JSON::Backend::PP; + +sub init { + local $^W; + no strict qw(refs); # this routine may be called after JSON::Backend::XS init was called. + *{"JSON::decode_json"} = \&{"JSON::PP::decode_json"}; + *{"JSON::encode_json"} = \&{"JSON::PP::encode_json"}; + *{"JSON::PP::is_xs"} = sub { 0 }; + *{"JSON::PP::is_pp"} = sub { 1 }; + return 1; +} + +# +# To save memory, the below lines are read only when XS backend is used. +# + +package JSON; + +1; +__DATA__ + + +# +# Helper classes for Backend Module (XS) +# + +package JSON::Backend::XS; + +use constant INDENT_LENGTH_FLAG => 15 << 12; + +use constant UNSUPPORTED_ENCODE_FLAG => { + ESCAPE_SLASH => 0x00000010, + ALLOW_BIGNUM => 0x00000020, + AS_NONBLESSED => 0x00000040, + EXPANDED => 0x10000000, # for developer's +}; + +use constant UNSUPPORTED_DECODE_FLAG => { + LOOSE => 0x00000001, + ALLOW_BIGNUM => 0x00000002, + ALLOW_BAREKEY => 0x00000004, + ALLOW_SINGLEQUOTE => 0x00000008, + EXPANDED => 0x20000000, # for developer's +}; + + +sub init { + local $^W; + no strict qw(refs); + *{"JSON::decode_json"} = \&{"JSON::XS::decode_json"}; + *{"JSON::encode_json"} = \&{"JSON::XS::encode_json"}; + *{"JSON::XS::is_xs"} = sub { 1 }; + *{"JSON::XS::is_pp"} = sub { 0 }; + return 1; +} + + +sub support_by_pp { + my ($class, @methods) = @_; + + local $^W; + no strict qw(refs); + + my $JSON_XS_encode_orignal = \&JSON::XS::encode; + my $JSON_XS_decode_orignal = \&JSON::XS::decode; + my $JSON_XS_incr_parse_orignal = \&JSON::XS::incr_parse; + + *JSON::XS::decode = \&JSON::Backend::XS::Supportable::_decode; + *JSON::XS::encode = \&JSON::Backend::XS::Supportable::_encode; + *JSON::XS::incr_parse = \&JSON::Backend::XS::Supportable::_incr_parse; + + *{JSON::XS::_original_decode} = $JSON_XS_decode_orignal; + *{JSON::XS::_original_encode} = $JSON_XS_encode_orignal; + *{JSON::XS::_original_incr_parse} = $JSON_XS_incr_parse_orignal; + + push @JSON::Backend::XS::Supportable::ISA, 'JSON'; + + my $pkg = 'JSON::Backend::XS::Supportable'; + + *{JSON::new} = sub { + my $proto = JSON::XS->new; $$proto = 0; + bless $proto, $pkg; + }; + + + for my $method (@methods) { + my $flag = uc($method); + my $type |= (UNSUPPORTED_ENCODE_FLAG->{$flag} || 0); + $type |= (UNSUPPORTED_DECODE_FLAG->{$flag} || 0); + + next unless($type); + + $pkg->_make_unsupported_method($method => $type); + } + + push @{"JSON::XS::Boolean::ISA"}, qw(JSON::PP::Boolean); + push @{"JSON::PP::Boolean::ISA"}, qw(JSON::Boolean); + + $JSON::DEBUG and Carp::carp("set -support_by_pp mode."); + + return 1; +} + + + + +# +# Helper classes for XS +# + +package JSON::Backend::XS::Supportable; + +$Carp::Internal{'JSON::Backend::XS::Supportable'} = 1; + +sub _make_unsupported_method { + my ($pkg, $method, $type) = @_; + + local $^W; + no strict qw(refs); + + *{"$pkg\::$method"} = sub { + local $^W; + if (defined $_[1] ? $_[1] : 1) { + ${$_[0]} |= $type; + } + else { + ${$_[0]} &= ~$type; + } + $_[0]; + }; + + *{"$pkg\::get_$method"} = sub { + ${$_[0]} & $type ? 1 : ''; + }; + +} + + +sub _set_for_pp { + JSON::_load_pp( $_INSTALL_ONLY ); + + my $type = shift; + my $pp = JSON::PP->new; + my $prop = $_[0]->property; + + for my $name (keys %$prop) { + $pp->$name( $prop->{$name} ? $prop->{$name} : 0 ); + } + + my $unsupported = $type eq 'encode' ? JSON::Backend::XS::UNSUPPORTED_ENCODE_FLAG + : JSON::Backend::XS::UNSUPPORTED_DECODE_FLAG; + my $flags = ${$_[0]} || 0; + + for my $name (keys %$unsupported) { + next if ($name eq 'EXPANDED'); # for developer's + my $enable = ($flags & $unsupported->{$name}) ? 1 : 0; + my $method = lc $name; + $pp->$method($enable); + } + + $pp->indent_length( $_[0]->get_indent_length ); + + return $pp; +} + +sub _encode { # using with PP encode + if (${$_[0]}) { + _set_for_pp('encode' => @_)->encode($_[1]); + } + else { + $_[0]->_original_encode( $_[1] ); + } +} + + +sub _decode { # if unsupported-flag is set, use PP + if (${$_[0]}) { + _set_for_pp('decode' => @_)->decode($_[1]); + } + else { + $_[0]->_original_decode( $_[1] ); + } +} + + +sub decode_prefix { # if unsupported-flag is set, use PP + _set_for_pp('decode' => @_)->decode_prefix($_[1]); +} + + +sub _incr_parse { + if (${$_[0]}) { + _set_for_pp('decode' => @_)->incr_parse($_[1]); + } + else { + $_[0]->_original_incr_parse( $_[1] ); + } +} + + +sub get_indent_length { + ${$_[0]} << 4 >> 16; +} + + +sub indent_length { + my $length = $_[1]; + + if (!defined $length or $length > 15 or $length < 0) { + Carp::carp "The acceptable range of indent_length() is 0 to 15."; + } + else { + local $^W; + $length <<= 12; + ${$_[0]} &= ~ JSON::Backend::XS::INDENT_LENGTH_FLAG; + ${$_[0]} |= $length; + *JSON::XS::encode = \&JSON::Backend::XS::Supportable::_encode; + } + + $_[0]; +} + + +1; +__END__ + +=head1 NAME + +JSON - JSON (JavaScript Object Notation) encoder/decoder + +=head1 SYNOPSIS + + use JSON; # imports encode_json, decode_json, to_json and from_json. + + # simple and fast interfaces (expect/generate UTF-8) + + $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; + $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; + + # OO-interface + + $json = JSON->new->allow_nonref; + + $json_text = $json->encode( $perl_scalar ); + $perl_scalar = $json->decode( $json_text ); + + $pretty_printed = $json->pretty->encode( $perl_scalar ); # pretty-printing + + # If you want to use PP only support features, call with '-support_by_pp' + # When XS unsupported feature is enable, using PP (de|en)code instead of XS ones. + + use JSON -support_by_pp; + + # option-acceptable interfaces (expect/generate UNICODE by default) + + $json_text = to_json( $perl_scalar, { ascii => 1, pretty => 1 } ); + $perl_scalar = from_json( $json_text, { utf8 => 1 } ); + + # Between (en|de)code_json and (to|from)_json, if you want to write + # a code which communicates to an outer world (encoded in UTF-8), + # recommend to use (en|de)code_json. + +=head1 VERSION + + 2.59 + +This version is compatible with JSON::XS B<2.34> and later. + + +=head1 NOTE + +JSON::PP was earlier included in the C<JSON> distribution, but +has since Perl 5.14 been a core module. For this reason, +L<JSON::PP> was removed from the JSON distribution and can now +be found also in the Perl5 repository at + +=over + +=item * L<http://perl5.git.perl.org/perl.git> + +=back + +(The newest JSON::PP version still exists in CPAN.) + +Instead, the C<JSON> distribution will include JSON::backportPP +for backwards computability. JSON.pm should thus work as it did +before. + +=head1 DESCRIPTION + + ************************** CAUTION ******************************** + * This is 'JSON module version 2' and there are many differences * + * to version 1.xx * + * Please check your applications using old version. * + * See to 'INCOMPATIBLE CHANGES TO OLD VERSION' * + ******************************************************************* + +JSON (JavaScript Object Notation) is a simple data format. +See to L<http://www.json.org/> and C<RFC4627>(L<http://www.ietf.org/rfc/rfc4627.txt>). + +This module converts Perl data structures to JSON and vice versa using either +L<JSON::XS> or L<JSON::PP>. + +JSON::XS is the fastest and most proper JSON module on CPAN which must be +compiled and installed in your environment. +JSON::PP is a pure-Perl module which is bundled in this distribution and +has a strong compatibility to JSON::XS. + +This module try to use JSON::XS by default and fail to it, use JSON::PP instead. +So its features completely depend on JSON::XS or JSON::PP. + +See to L<BACKEND MODULE DECISION>. + +To distinguish the module name 'JSON' and the format type JSON, +the former is quoted by CE<lt>E<gt> (its results vary with your using media), +and the latter is left just as it is. + +Module name : C<JSON> + +Format type : JSON + +=head2 FEATURES + +=over + +=item * correct unicode handling + +This module (i.e. backend modules) knows how to handle Unicode, documents +how and when it does so, and even documents what "correct" means. + +Even though there are limitations, this feature is available since Perl version 5.6. + +JSON::XS requires Perl 5.8.2 (but works correctly in 5.8.8 or later), so in older versions +C<JSON> should call JSON::PP as the backend which can be used since Perl 5.005. + +With Perl 5.8.x JSON::PP works, but from 5.8.0 to 5.8.2, because of a Perl side problem, +JSON::PP works slower in the versions. And in 5.005, the Unicode handling is not available. +See to L<JSON::PP/UNICODE HANDLING ON PERLS> for more information. + +See also to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL> +and L<JSON::XS/ENCODING/CODESET_FLAG_NOTES>. + + +=item * round-trip integrity + +When you serialise a perl data structure using only data types supported +by JSON and Perl, the deserialised data structure is identical on the Perl +level. (e.g. the string "2.0" doesn't suddenly become "2" just because +it looks like a number). There I<are> minor exceptions to this, read the +L</MAPPING> section below to learn about those. + + +=item * strict checking of JSON correctness + +There is no guessing, no generating of illegal JSON texts by default, +and only JSON is accepted as input by default (the latter is a security +feature). + +See to L<JSON::XS/FEATURES> and L<JSON::PP/FEATURES>. + +=item * fast + +This module returns a JSON::XS object itself if available. +Compared to other JSON modules and other serialisers such as Storable, +JSON::XS usually compares favorably in terms of speed, too. + +If not available, C<JSON> returns a JSON::PP object instead of JSON::XS and +it is very slow as pure-Perl. + +=item * simple to use + +This module has both a simple functional interface as well as an +object oriented interface interface. + +=item * reasonably versatile output formats + +You can choose between the most compact guaranteed-single-line format possible +(nice for simple line-based protocols), a pure-ASCII format (for when your transport +is not 8-bit clean, still supports the whole Unicode range), or a pretty-printed +format (for when you want to read that stuff). Or you can combine those features +in whatever way you like. + +=back + +=head1 FUNCTIONAL INTERFACE + +Some documents are copied and modified from L<JSON::XS/FUNCTIONAL INTERFACE>. +C<to_json> and C<from_json> are additional functions. + +=head2 encode_json + + $json_text = encode_json $perl_scalar + +Converts the given Perl data structure to a UTF-8 encoded, binary string. + +This function call is functionally identical to: + + $json_text = JSON->new->utf8->encode($perl_scalar) + +=head2 decode_json + + $perl_scalar = decode_json $json_text + +The opposite of C<encode_json>: expects an UTF-8 (binary) string and tries +to parse that as an UTF-8 encoded JSON text, returning the resulting +reference. + +This function call is functionally identical to: + + $perl_scalar = JSON->new->utf8->decode($json_text) + + +=head2 to_json + + $json_text = to_json($perl_scalar) + +Converts the given Perl data structure to a json string. + +This function call is functionally identical to: + + $json_text = JSON->new->encode($perl_scalar) + +Takes a hash reference as the second. + + $json_text = to_json($perl_scalar, $flag_hashref) + +So, + + $json_text = to_json($perl_scalar, {utf8 => 1, pretty => 1}) + +equivalent to: + + $json_text = JSON->new->utf8(1)->pretty(1)->encode($perl_scalar) + +If you want to write a modern perl code which communicates to outer world, +you should use C<encode_json> (supposed that JSON data are encoded in UTF-8). + +=head2 from_json + + $perl_scalar = from_json($json_text) + +The opposite of C<to_json>: expects a json string and tries +to parse it, returning the resulting reference. + +This function call is functionally identical to: + + $perl_scalar = JSON->decode($json_text) + +Takes a hash reference as the second. + + $perl_scalar = from_json($json_text, $flag_hashref) + +So, + + $perl_scalar = from_json($json_text, {utf8 => 1}) + +equivalent to: + + $perl_scalar = JSON->new->utf8(1)->decode($json_text) + +If you want to write a modern perl code which communicates to outer world, +you should use C<decode_json> (supposed that JSON data are encoded in UTF-8). + +=head2 JSON::is_bool + + $is_boolean = JSON::is_bool($scalar) + +Returns true if the passed scalar represents either JSON::true or +JSON::false, two constants that act like C<1> and C<0> respectively +and are also used to represent JSON C<true> and C<false> in Perl strings. + +=head2 JSON::true + +Returns JSON true value which is blessed object. +It C<isa> JSON::Boolean object. + +=head2 JSON::false + +Returns JSON false value which is blessed object. +It C<isa> JSON::Boolean object. + +=head2 JSON::null + +Returns C<undef>. + +See L<MAPPING>, below, for more information on how JSON values are mapped to +Perl. + +=head1 HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER + +This section supposes that your perl version is 5.8 or later. + +If you know a JSON text from an outer world - a network, a file content, and so on, +is encoded in UTF-8, you should use C<decode_json> or C<JSON> module object +with C<utf8> enable. And the decoded result will contain UNICODE characters. + + # from network + my $json = JSON->new->utf8; + my $json_text = CGI->new->param( 'json_data' ); + my $perl_scalar = $json->decode( $json_text ); + + # from file content + local $/; + open( my $fh, '<', 'json.data' ); + $json_text = <$fh>; + $perl_scalar = decode_json( $json_text ); + +If an outer data is not encoded in UTF-8, firstly you should C<decode> it. + + use Encode; + local $/; + open( my $fh, '<', 'json.data' ); + my $encoding = 'cp932'; + my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE + + # or you can write the below code. + # + # open( my $fh, "<:encoding($encoding)", 'json.data' ); + # $unicode_json_text = <$fh>; + +In this case, C<$unicode_json_text> is of course UNICODE string. +So you B<cannot> use C<decode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable or C<from_json>. + + $perl_scalar = $json->utf8(0)->decode( $unicode_json_text ); + # or + $perl_scalar = from_json( $unicode_json_text ); + +Or C<encode 'utf8'> and C<decode_json>: + + $perl_scalar = decode_json( encode( 'utf8', $unicode_json_text ) ); + # this way is not efficient. + +And now, you want to convert your C<$perl_scalar> into JSON data and +send it to an outer world - a network or a file content, and so on. + +Your data usually contains UNICODE strings and you want the converted data to be encoded +in UTF-8, you should use C<encode_json> or C<JSON> module object with C<utf8> enable. + + print encode_json( $perl_scalar ); # to a network? file? or display? + # or + print $json->utf8->encode( $perl_scalar ); + +If C<$perl_scalar> does not contain UNICODE but C<$encoding>-encoded strings +for some reason, then its characters are regarded as B<latin1> for perl +(because it does not concern with your $encoding). +You B<cannot> use C<encode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable or C<to_json>. +Note that the resulted text is a UNICODE string but no problem to print it. + + # $perl_scalar contains $encoding encoded string values + $unicode_json_text = $json->utf8(0)->encode( $perl_scalar ); + # or + $unicode_json_text = to_json( $perl_scalar ); + # $unicode_json_text consists of characters less than 0x100 + print $unicode_json_text; + +Or C<decode $encoding> all string values and C<encode_json>: + + $perl_scalar->{ foo } = decode( $encoding, $perl_scalar->{ foo } ); + # ... do it to each string values, then encode_json + $json_text = encode_json( $perl_scalar ); + +This method is a proper way but probably not efficient. + +See to L<Encode>, L<perluniintro>. + + +=head1 COMMON OBJECT-ORIENTED INTERFACE + +=head2 new + + $json = JSON->new + +Returns a new C<JSON> object inherited from either JSON::XS or JSON::PP +that can be used to de/encode JSON strings. + +All boolean flags described below are by default I<disabled>. + +The mutators for flags all return the JSON object again and thus calls can +be chained: + + my $json = JSON->new->utf8->space_after->encode({a => [1,2]}) + => {"a": [1, 2]} + +=head2 ascii + + $json = $json->ascii([$enable]) + + $enabled = $json->get_ascii + +If $enable is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627. + +If $enable is false, then the encode method will not escape Unicode characters unless +required by the JSON syntax or other flags. This results in a faster and more compact format. + +This feature depends on the used Perl version and environment. + +See to L<JSON::PP/UNICODE HANDLING ON PERLS> if the backend is PP. + + JSON->new->ascii(1)->encode([chr 0x10401]) + => ["\ud801\udc01"] + +=head2 latin1 + + $json = $json->latin1([$enable]) + + $enabled = $json->get_latin1 + +If $enable is true (or missing), then the encode method will encode the resulting JSON +text as latin1 (or iso-8859-1), escaping any characters outside the code range 0..255. + +If $enable is false, then the encode method will not escape Unicode characters +unless required by the JSON syntax or other flags. + + JSON->new->latin1->encode (["\x{89}\x{abc}"] + => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not) + +=head2 utf8 + + $json = $json->utf8([$enable]) + + $enabled = $json->get_utf8 + +If $enable is true (or missing), then the encode method will encode the JSON result +into UTF-8, as required by many protocols, while the decode method expects to be handled +an UTF-8-encoded string. Please note that UTF-8-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. + +In future versions, enabling this option might enable autodetection of the UTF-16 and UTF-32 +encoding families, as described in RFC4627. + +If $enable is false, then the encode method will return the JSON string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to UTF-8 or UTF-16) needs to be done yourself, e.g. using the Encode module. + + +Example, output UTF-16BE-encoded JSON: + + use Encode; + $jsontext = encode "UTF-16BE", JSON::XS->new->encode ($object); + +Example, decode UTF-32LE-encoded JSON: + + use Encode; + $object = JSON::XS->new->decode (decode "UTF-32LE", $jsontext); + +See to L<JSON::PP/UNICODE HANDLING ON PERLS> if the backend is PP. + + +=head2 pretty + + $json = $json->pretty([$enable]) + +This enables (or disables) all of the C<indent>, C<space_before> and +C<space_after> (and in the future possibly more) flags in one call to +generate the most readable (or most compact) form possible. + +Equivalent to: + + $json->indent->space_before->space_after + +The indent space length is three and JSON::XS cannot change the indent +space length. + +=head2 indent + + $json = $json->indent([$enable]) + + $enabled = $json->get_indent + +If C<$enable> is true (or missing), then the C<encode> method will use a multiline +format as output, putting every array member or object/hash key-value pair +into its own line, identifying them properly. + +If C<$enable> is false, no newlines or indenting will be produced, and the +resulting JSON text is guaranteed not to contain any C<newlines>. + +This setting has no effect when decoding JSON texts. + +The indent space length is three. +With JSON::PP, you can also access C<indent_length> to change indent space length. + + +=head2 space_before + + $json = $json->space_before([$enable]) + + $enabled = $json->get_space_before + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space before the C<:> separating keys from values in JSON objects. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before enabled, space_after and indent disabled: + + {"key" :"value"} + + +=head2 space_after + + $json = $json->space_after([$enable]) + + $enabled = $json->get_space_after + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space after the C<:> separating keys from values in JSON objects +and extra whitespace after the C<,> separating key-value pairs and array +members. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before and indent disabled, space_after enabled: + + {"key": "value"} + + +=head2 relaxed + + $json = $json->relaxed([$enable]) + + $enabled = $json->get_relaxed + +If C<$enable> is true (or missing), then C<decode> will accept some +extensions to normal JSON syntax (see below). C<encode> will not be +affected in anyway. I<Be aware that this option makes you accept invalid +JSON texts as if they were valid!>. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) + +If C<$enable> is false (the default), then C<decode> will only accept +valid JSON texts. + +Currently accepted extensions are: + +=over 4 + +=item * list items can have an end-comma + +JSON I<separates> array elements and key-value pairs with commas. This +can be annoying if you write JSON texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: + + [ + 1, + 2, <- this comma not normally allowed + ] + { + "k1": "v1", + "k2": "v2", <- this comma not normally allowed + } + +=item * shell-style '#'-comments + +Whenever JSON allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. + + [ + 1, # this comment not allowed in JSON + # neither this one... + ] + +=back + + +=head2 canonical + + $json = $json->canonical([$enable]) + + $enabled = $json->get_canonical + +If C<$enable> is true (or missing), then the C<encode> method will output JSON objects +by sorting their keys. This is adding a comparatively high overhead. + +If C<$enable> is false, then the C<encode> method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). + +This option is useful if you want the same data structure to be encoded as +the same JSON text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. + +This setting has no effect when decoding JSON texts. + +=head2 allow_nonref + + $json = $json->allow_nonref([$enable]) + + $enabled = $json->get_allow_nonref + +If C<$enable> is true (or missing), then the C<encode> method can convert a +non-reference into its corresponding string, number or null JSON value, +which is an extension to RFC4627. Likewise, C<decode> will accept those JSON +values instead of croaking. + +If C<$enable> is false, then the C<encode> method will croak if it isn't +passed an arrayref or hashref, as JSON texts must either be an object +or array. Likewise, C<decode> will croak if given something that is not a +JSON object or array. + + JSON->new->allow_nonref->encode ("Hello, World!") + => "Hello, World!" + +=head2 allow_unknown + + $json = $json->allow_unknown ([$enable]) + + $enabled = $json->get_allow_unknown + +If $enable is true (or missing), then "encode" will *not* throw an +exception when it encounters values it cannot represent in JSON (for +example, filehandles) but instead will encode a JSON "null" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. + +If $enable is false (the default), then "encode" will throw an +exception when it encounters anything it cannot encode as JSON. + +This option does not affect "decode" in any way, and it is +recommended to leave it off unless you know your communications +partner. + +=head2 allow_blessed + + $json = $json->allow_blessed([$enable]) + + $enabled = $json->get_allow_blessed + +If C<$enable> is true (or missing), then the C<encode> method will not +barf when it encounters a blessed reference. Instead, the value of the +B<convert_blessed> option will decide whether C<null> (C<convert_blessed> +disabled or no C<TO_JSON> method found) or a representation of the +object (C<convert_blessed> enabled and C<TO_JSON> method found) is being +encoded. Has no effect on C<decode>. + +If C<$enable> is false (the default), then C<encode> will throw an +exception when it encounters a blessed object. + + +=head2 convert_blessed + + $json = $json->convert_blessed([$enable]) + + $enabled = $json->get_convert_blessed + +If C<$enable> is true (or missing), then C<encode>, upon encountering a +blessed object, will check for the availability of the C<TO_JSON> method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +C<TO_JSON> method is found, the value of C<allow_blessed> will decide what +to do. + +The C<TO_JSON> method may safely call die if it wants. If C<TO_JSON> +returns other blessed objects, those will be handled in the same +way. C<TO_JSON> must take care of not causing an endless recursion cycle +(== crash) in this case. The name of C<TO_JSON> was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the C<to_json> +function or method. + +This setting does not yet influence C<decode> in any way. + +If C<$enable> is false, then the C<allow_blessed> setting will decide what +to do when a blessed object is found. + +=over + +=item convert_blessed_universally mode + +If use C<JSON> with C<-convert_blessed_universally>, the C<UNIVERSAL::TO_JSON> +subroutine is defined as the below code: + + *UNIVERSAL::TO_JSON = sub { + my $b_obj = B::svref_2object( $_[0] ); + return $b_obj->isa('B::HV') ? { %{ $_[0] } } + : $b_obj->isa('B::AV') ? [ @{ $_[0] } ] + : undef + ; + } + +This will cause that C<encode> method converts simple blessed objects into +JSON objects as non-blessed object. + + JSON -convert_blessed_universally; + $json->allow_blessed->convert_blessed->encode( $blessed_object ) + +This feature is experimental and may be removed in the future. + +=back + +=head2 filter_json_object + + $json = $json->filter_json_object([$coderef]) + +When C<$coderef> is specified, it will be called from C<decode> each +time it decodes a JSON object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(NOTE: I<not> C<undef>, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. + +When C<$coderef> is omitted or undefined, any existing callback will +be removed and C<decode> will not change the deserialised hash in any +way. + +Example, convert all JSON objects into the integer 5: + + my $js = JSON->new->filter_json_object (sub { 5 }); + # returns [5] + $js->decode ('[{}]'); # the given subroutine takes a hash reference. + # throw an exception because allow_nonref is not enabled + # so a lone 5 is not allowed. + $js->decode ('{"a":1, "b":2}'); + + +=head2 filter_json_single_key_object + + $json = $json->filter_json_single_key_object($key [=> $coderef]) + +Works remotely similar to C<filter_json_object>, but is only called for +JSON objects having a single key named C<$key>. + +This C<$coderef> is called before the one specified via +C<filter_json_object>, if any. It gets passed the single value in the JSON +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even C<undef> but the empty list), +the callback from C<filter_json_object> will be called next, as if no +single-key callback were specified. + +If C<$coderef> is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. + +As this callback gets called less often then the C<filter_json_object> +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key JSON objects are as close to the type-tagged value concept +as JSON gets (it's basically an ID/VALUE tuple). Of course, JSON does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. + +Typical names for the single object key are C<__class_whatever__>, or +C<$__dollars_are_rarely_used__$> or C<}ugly_brace_placement>, or even +things like C<__class_md5sum(classname)__>, to reduce the risk of clashing +with real hashes. + +Example, decode JSON objects of the form C<< { "__widget__" => <id> } >> +into the corresponding C<< $WIDGET{<id>} >> object: + + # return whatever is in $WIDGET{5}: + JSON + ->new + ->filter_json_single_key_object (__widget__ => sub { + $WIDGET{ $_[0] } + }) + ->decode ('{"__widget__": 5') + + # this can be used with a TO_JSON method in some "widget" class + # for serialisation to json: + sub WidgetBase::TO_JSON { + my ($self) = @_; + + unless ($self->{id}) { + $self->{id} = ..get..some..id..; + $WIDGET{$self->{id}} = $self; + } + + { __widget__ => $self->{id} } + } + + +=head2 shrink + + $json = $json->shrink([$enable]) + + $enabled = $json->get_shrink + +With JSON::XS, this flag resizes strings generated by either +C<encode> or C<decode> to their minimum size possible. This can save +memory when your JSON texts are either very very long or you have many +short strings. It will also try to downgrade any strings to octet-form +if possible: perl stores strings internally either in an encoding called +UTF-X or in octet-form. The latter cannot store everything but uses less +space in general (and some buggy Perl or C code might even rely on that +internal representation being used). + +With JSON::PP, it is noop about resizing strings but tries +C<utf8::downgrade> to the returned string by C<encode>. See to L<utf8>. + +See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> and L<JSON::PP/METHODS>. + +=head2 max_depth + + $json = $json->max_depth([$maximum_nesting_depth]) + + $max_depth = $json->get_max_depth + +Sets the maximum nesting level (default C<512>) accepted while encoding +or decoding. If a higher nesting level is detected in JSON text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. + +Nesting level is defined by number of hash- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of C<{> or C<[> +characters without their matching closing parenthesis crossed to reach a +given character in a string. + +If no argument is given, the highest possible setting will be used, which +is rarely useful. + +Note that nesting is implemented by recursion in C. The default value has +been chosen to be as large as typical operating systems allow without +crashing. (JSON::XS) + +With JSON::PP as the backend, when a large value (100 or more) was set and +it de/encodes a deep nested object/text, it may raise a warning +'Deep recursion on subroutine' at the perl runtime phase. + +See L<JSON::XS/SECURITY CONSIDERATIONS> for more info on why this is useful. + +=head2 max_size + + $json = $json->max_size([$maximum_string_size]) + + $max_size = $json->get_max_size + +Set the maximum length a JSON text may have (in bytes) where decoding is +being attempted. The default is C<0>, meaning no limit. When C<decode> +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on C<encode> (yet). + +If no argument is given, the limit check will be deactivated (same as when +C<0> is specified). + +See L<JSON::XS/SECURITY CONSIDERATIONS>, below, for more info on why this is useful. + +=head2 encode + + $json_text = $json->encode($perl_scalar) + +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its JSON representation. Simple scalars will be +converted into JSON string or number sequences, while references to arrays +become JSON arrays and references to hashes become JSON objects. Undefined +Perl values (e.g. C<undef>) become JSON C<null> values. +References to the integers C<0> and C<1> are converted into C<true> and C<false>. + +=head2 decode + + $perl_scalar = $json->decode($json_text) + +The opposite of C<encode>: expects a JSON text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. + +JSON numbers and strings become simple Perl scalars. JSON arrays become +Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes +C<1> (C<JSON::true>), C<false> becomes C<0> (C<JSON::false>) and +C<null> becomes C<undef>. + +=head2 decode_prefix + + ($perl_scalar, $characters) = $json->decode_prefix($json_text) + +This works like the C<decode> method, but instead of raising an exception +when there is trailing garbage after the first JSON object, it will +silently stop parsing there and return the number of characters consumed +so far. + + JSON->new->decode_prefix ("[1] the tail") + => ([], 3) + +See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> + +=head2 property + + $boolean = $json->property($property_name) + +Returns a boolean value about above some properties. + +The available properties are C<ascii>, C<latin1>, C<utf8>, +C<indent>,C<space_before>, C<space_after>, C<relaxed>, C<canonical>, +C<allow_nonref>, C<allow_unknown>, C<allow_blessed>, C<convert_blessed>, +C<shrink>, C<max_depth> and C<max_size>. + + $boolean = $json->property('utf8'); + => 0 + $json->utf8; + $boolean = $json->property('utf8'); + => 1 + +Sets the property with a given boolean value. + + $json = $json->property($property_name => $boolean); + +With no argument, it returns all the above properties as a hash reference. + + $flag_hashref = $json->property(); + +=head1 INCREMENTAL PARSING + +Most of this section are copied and modified from L<JSON::XS/INCREMENTAL PARSING>. + +In some cases, there is the need for incremental parsing of JSON texts. +This module does allow you to parse a JSON stream incrementally. +It does so by accumulating text until it has a full JSON object, which +it then can decode. This process is similar to using C<decode_prefix> +to see if a full JSON object is available, but is much more efficient +(and can be implemented with a minimum of method calls). + +The backend module will only attempt to parse the JSON text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid JSON text has been seen. This means you need +to set resource limits (e.g. C<max_size>) to ensure the parser will stop +parsing in the presence if syntax errors. + +The following methods implement this incremental parser. + +=head2 incr_parse + + $json->incr_parse( [$string] ) # void context + + $obj_or_undef = $json->incr_parse( [$string] ) # scalar context + + @obj_or_empty = $json->incr_parse( [$string] ) # list context + +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). + +If C<$string> is given, then this string is appended to the already +existing JSON fragment stored in the C<$json> object. + +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. + +If the method is called in scalar context, then it will try to extract +exactly I<one> JSON object. If that is successful, it will return this +object, otherwise it will return C<undef>. If there is a parse error, +this method will croak just as C<decode> would do (one can then use +C<incr_skip> to skip the erroneous part). This is the most common way of +using the method. + +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the JSON +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed JSON texts will be +lost. + +Example: Parse some JSON arrays/objects in a given string and return them. + + my @objs = JSON->new->incr_parse ("[5][7][1,2]"); + +=head2 incr_text + + $lvalue_string = $json->incr_text + +This method returns the currently stored JSON fragment as an lvalue, that +is, you can manipulate it. This I<only> works when a preceding call to +C<incr_parse> in I<scalar context> successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it I<will> fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. + +This function is useful in two cases: a) finding the trailing text after a +JSON object or b) parsing multiple JSON objects separated by non-JSON text +(such as commas). + + $json->incr_text =~ s/\s*,\s*//; + +In Perl 5.005, C<lvalue> attribute is not available. +You must write codes like the below: + + $string = $json->incr_text; + $string =~ s/\s*,\s*//; + $json->incr_text( $string ); + +=head2 incr_skip + + $json->incr_skip + +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after C<incr_parse> +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. + +=head2 incr_reset + + $json->incr_reset + +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. + +This is useful if you want to repeatedly parse JSON objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. + +See to L<JSON::XS/INCREMENTAL PARSING> for examples. + + +=head1 JSON::PP SUPPORT METHODS + +The below methods are JSON::PP own methods, so when C<JSON> works +with JSON::PP (i.e. the created object is a JSON::PP object), available. +See to L<JSON::PP/JSON::PP OWN METHODS> in detail. + +If you use C<JSON> with additional C<-support_by_pp>, some methods +are available even with JSON::XS. See to L<USE PP FEATURES EVEN THOUGH XS BACKEND>. + + BEING { $ENV{PERL_JSON_BACKEND} = 'JSON::XS' } + + use JSON -support_by_pp; + + my $json = JSON->new; + $json->allow_nonref->escape_slash->encode("/"); + + # functional interfaces too. + print to_json(["/"], {escape_slash => 1}); + print from_json('["foo"]', {utf8 => 1}); + +If you do not want to all functions but C<-support_by_pp>, +use C<-no_export>. + + use JSON -support_by_pp, -no_export; + # functional interfaces are not exported. + +=head2 allow_singlequote + + $json = $json->allow_singlequote([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +any JSON strings quoted by single quotations that are invalid JSON +format. + + $json->allow_singlequote->decode({"foo":'bar'}); + $json->allow_singlequote->decode({'foo':"bar"}); + $json->allow_singlequote->decode({'foo':'bar'}); + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + +=head2 allow_barekey + + $json = $json->allow_barekey([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +bare keys of JSON object that are invalid JSON format. + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + + $json->allow_barekey->decode('{foo:"bar"}'); + +=head2 allow_bignum + + $json = $json->allow_bignum([$enable]) + +If C<$enable> is true (or missing), then C<decode> will convert +the big integer Perl cannot handle as integer into a L<Math::BigInt> +object and convert a floating number (any) into a L<Math::BigFloat>. + +On the contrary, C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers with C<allow_blessed> enable. + + $json->allow_nonref->allow_blessed->allow_bignum; + $bigfloat = $json->decode('2.000000000000000000000000001'); + print $json->encode($bigfloat); + # => 2.000000000000000000000000001 + +See to L<MAPPING> about the conversion of JSON number. + +=head2 loose + + $json = $json->loose([$enable]) + +The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON strings +and the module doesn't allow to C<decode> to these (except for \x2f). +If C<$enable> is true (or missing), then C<decode> will accept these +unescaped strings. + + $json->loose->decode(qq|["abc + def"]|); + +See to L<JSON::PP/JSON::PP OWN METHODS>. + +=head2 escape_slash + + $json = $json->escape_slash([$enable]) + +According to JSON Grammar, I<slash> (U+002F) is escaped. But by default +JSON backend modules encode strings without escaping slash. + +If C<$enable> is true (or missing), then C<encode> will escape slashes. + +=head2 indent_length + + $json = $json->indent_length($length) + +With JSON::XS, The indent space length is 3 and cannot be changed. +With JSON::PP, it sets the indent space length with the given $length. +The default is 3. The acceptable range is 0 to 15. + +=head2 sort_by + + $json = $json->sort_by($function_name) + $json = $json->sort_by($subroutine_ref) + +If $function_name or $subroutine_ref are set, its sort routine are used. + + $js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + $js = $pc->sort_by('own_sort')->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } + +As the sorting routine runs in the JSON::PP scope, the given +subroutine name and the special variables C<$a>, C<$b> will begin +with 'JSON::PP::'. + +If $integer is set, then the effect is same as C<canonical> on. + +See to L<JSON::PP/JSON::PP OWN METHODS>. + +=head1 MAPPING + +This section is copied from JSON::XS and modified to C<JSON>. +JSON::XS and JSON::PP mapping mechanisms are almost equivalent. + +See to L<JSON::XS/MAPPING>. + +=head2 JSON -> PERL + +=over 4 + +=item object + +A JSON object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (JSON does not preserver object key ordering itself). + +=item array + +A JSON array becomes a reference to an array in Perl. + +=item string + +A JSON string becomes a string scalar in Perl - Unicode codepoints in JSON +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. + +=item number + +A JSON number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. + +If the number consists of digits only, C<JSON> will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the JSON number will be +re-encoded to a JSON string). + +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the JSON number will still be re-encoded as a JSON number). + +Note that precision is not accuracy - binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, C<JSON> only guarantees precision up to but not including +the least significant bit. + +If the backend is JSON::PP and C<allow_bignum> is enable, the big integers +and the numeric can be optionally converted into L<Math::BigInt> and +L<Math::BigFloat> objects. + +=item true, false + +These JSON atoms become C<JSON::true> and C<JSON::false>, +respectively. They are overloaded to act almost exactly like the numbers +C<1> and C<0>. You can check whether a scalar is a JSON boolean by using +the C<JSON::is_bool> function. + +If C<JSON::true> and C<JSON::false> are used as strings or compared as strings, +they represent as C<true> and C<false> respectively. + + print JSON::true . "\n"; + => true + print JSON::true + 1; + => 1 + + ok(JSON::true eq 'true'); + ok(JSON::true eq '1'); + ok(JSON::true == 1); + +C<JSON> will install these missing overloading features to the backend modules. + + +=item null + +A JSON null atom becomes C<undef> in Perl. + +C<JSON::null> returns C<undef>. + +=back + + +=head2 PERL -> JSON + +The mapping from Perl to JSON is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which JSON type is meant by +a Perl value. + +=over 4 + +=item hash references + +Perl hash references become JSON objects. As there is no inherent ordering +in hash keys (or JSON objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. C<JSON> +optionally sort the hash keys (determined by the I<canonical> flag), so +the same data structure will serialise to the same JSON text (given same +settings and version of JSON::XS), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some JSON text +against another for equality. + +In future, the ordered object feature will be added to JSON::PP using C<tie> mechanism. + + +=item array references + +Perl array references become JSON arrays. + +=item other references + +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers C<0> and +C<1>, which get turned into C<false> and C<true> atoms in JSON. You can +also use C<JSON::false> and C<JSON::true> to improve readability. + + to_json [\0,JSON::true] # yields [false,true] + +=item JSON::true, JSON::false, JSON::null + +These special values become JSON true and JSON false values, +respectively. You can also use C<\1> and C<\0> directly if you want. + +JSON::null returns C<undef>. + +=item blessed objects + +Blessed objects are not directly representable in JSON. See the +C<allow_blessed> and C<convert_blessed> methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. + +With C<convert_blessed_universally> mode, C<encode> converts blessed +hash references or blessed array references (contains other blessed references) +into JSON members and arrays. + + use JSON -convert_blessed_universally; + JSON->new->allow_blessed->convert_blessed->encode( $blessed_object ); + +See to L<convert_blessed>. + +=item simple scalars + +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: JSON::XS and JSON::PP will encode undefined scalars as +JSON C<null> values, scalars that have last been used in a string context +before encoding as JSON strings, and anything else as number value: + + # dump as number + encode_json [2] # yields [2] + encode_json [-3.0e17] # yields [-3e+17] + my $value = 5; encode_json [$value] # yields [5] + + # used as string, so dump as string + print $value; + encode_json [$value] # yields ["5"] + + # undef becomes null + encode_json [undef] # yields [null] + +You can force the type to be a string by stringifying it: + + my $x = 3.1; # some variable containing a number + "$x"; # stringified + $x .= ""; # another, more awkward way to stringify + print $x; # perl does it for you, too, quite often + +You can force the type to be a number by numifying it: + + my $x = "3"; # some variable containing a string + $x += 0; # numify it, ensuring it will be dumped as a number + $x *= 1; # same thing, the choice is yours. + +You can not currently force the type in other, less obscure, ways. + +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's - these cannot be represented in JSON, and it is an +error to pass those in. + +=item Big Number + +If the backend is JSON::PP and C<allow_bignum> is enable, +C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers. + + +=back + +=head1 JSON and ECMAscript + +See to L<JSON::XS/JSON and ECMAscript>. + +=head1 JSON and YAML + +JSON is not a subset of YAML. +See to L<JSON::XS/JSON and YAML>. + + +=head1 BACKEND MODULE DECISION + +When you use C<JSON>, C<JSON> tries to C<use> JSON::XS. If this call failed, it will +C<uses> JSON::PP. The required JSON::XS version is I<2.2> or later. + +The C<JSON> constructor method returns an object inherited from the backend module, +and JSON::XS object is a blessed scalar reference while JSON::PP is a blessed hash +reference. + +So, your program should not depend on the backend module, especially +returned objects should not be modified. + + my $json = JSON->new; # XS or PP? + $json->{stash} = 'this is xs object'; # this code may raise an error! + +To check the backend module, there are some methods - C<backend>, C<is_pp> and C<is_xs>. + + JSON->backend; # 'JSON::XS' or 'JSON::PP' + + JSON->backend->is_pp: # 0 or 1 + + JSON->backend->is_xs: # 1 or 0 + + $json->is_xs; # 1 or 0 + + $json->is_pp; # 0 or 1 + + +If you set an environment variable C<PERL_JSON_BACKEND>, the calling action will be changed. + +=over + +=item PERL_JSON_BACKEND = 0 or PERL_JSON_BACKEND = 'JSON::PP' + +Always use JSON::PP + +=item PERL_JSON_BACKEND == 1 or PERL_JSON_BACKEND = 'JSON::XS,JSON::PP' + +(The default) Use compiled JSON::XS if it is properly compiled & installed, +otherwise use JSON::PP. + +=item PERL_JSON_BACKEND == 2 or PERL_JSON_BACKEND = 'JSON::XS' + +Always use compiled JSON::XS, die if it isn't properly compiled & installed. + +=item PERL_JSON_BACKEND = 'JSON::backportPP' + +Always use JSON::backportPP. +JSON::backportPP is JSON::PP back port module. +C<JSON> includes JSON::backportPP instead of JSON::PP. + +=back + +These ideas come from L<DBI::PurePerl> mechanism. + +example: + + BEGIN { $ENV{PERL_JSON_BACKEND} = 'JSON::PP' } + use JSON; # always uses JSON::PP + +In future, it may be able to specify another module. + +=head1 USE PP FEATURES EVEN THOUGH XS BACKEND + +Many methods are available with either JSON::XS or JSON::PP and +when the backend module is JSON::XS, if any JSON::PP specific (i.e. JSON::XS unsupported) +method is called, it will C<warn> and be noop. + +But If you C<use> C<JSON> passing the optional string C<-support_by_pp>, +it makes a part of those unsupported methods available. +This feature is achieved by using JSON::PP in C<de/encode>. + + BEGIN { $ENV{PERL_JSON_BACKEND} = 2 } # with JSON::XS + use JSON -support_by_pp; + my $json = JSON->new; + $json->allow_nonref->escape_slash->encode("/"); + +At this time, the returned object is a C<JSON::Backend::XS::Supportable> +object (re-blessed XS object), and by checking JSON::XS unsupported flags +in de/encoding, can support some unsupported methods - C<loose>, C<allow_bignum>, +C<allow_barekey>, C<allow_singlequote>, C<escape_slash> and C<indent_length>. + +When any unsupported methods are not enable, C<XS de/encode> will be +used as is. The switch is achieved by changing the symbolic tables. + +C<-support_by_pp> is effective only when the backend module is JSON::XS +and it makes the de/encoding speed down a bit. + +See to L<JSON::PP SUPPORT METHODS>. + +=head1 INCOMPATIBLE CHANGES TO OLD VERSION + +There are big incompatibility between new version (2.00) and old (1.xx). +If you use old C<JSON> 1.xx in your code, please check it. + +See to L<Transition ways from 1.xx to 2.xx.> + +=over + +=item jsonToObj and objToJson are obsoleted. + +Non Perl-style name C<jsonToObj> and C<objToJson> are obsoleted +(but not yet deleted from the source). +If you use these functions in your code, please replace them +with C<from_json> and C<to_json>. + + +=item Global variables are no longer available. + +C<JSON> class variables - C<$JSON::AUTOCONVERT>, C<$JSON::BareKey>, etc... +- are not available any longer. +Instead, various features can be used through object methods. + + +=item Package JSON::Converter and JSON::Parser are deleted. + +Now C<JSON> bundles with JSON::PP which can handle JSON more properly than them. + +=item Package JSON::NotString is deleted. + +There was C<JSON::NotString> class which represents JSON value C<true>, C<false>, C<null> +and numbers. It was deleted and replaced by C<JSON::Boolean>. + +C<JSON::Boolean> represents C<true> and C<false>. + +C<JSON::Boolean> does not represent C<null>. + +C<JSON::null> returns C<undef>. + +C<JSON> makes L<JSON::XS::Boolean> and L<JSON::PP::Boolean> is-a relation +to L<JSON::Boolean>. + +=item function JSON::Number is obsoleted. + +C<JSON::Number> is now needless because JSON::XS and JSON::PP have +round-trip integrity. + +=item JSONRPC modules are deleted. + +Perl implementation of JSON-RPC protocol - C<JSONRPC >, C<JSONRPC::Transport::HTTP> +and C<Apache::JSONRPC > are deleted in this distribution. +Instead of them, there is L<JSON::RPC> which supports JSON-RPC protocol version 1.1. + +=back + +=head2 Transition ways from 1.xx to 2.xx. + +You should set C<suport_by_pp> mode firstly, because +it is always successful for the below codes even with JSON::XS. + + use JSON -support_by_pp; + +=over + +=item Exported jsonToObj (simple) + + from_json($json_text); + +=item Exported objToJson (simple) + + to_json($perl_scalar); + +=item Exported jsonToObj (advanced) + + $flags = {allow_barekey => 1, allow_singlequote => 1}; + from_json($json_text, $flags); + +equivalent to: + + $JSON::BareKey = 1; + $JSON::QuotApos = 1; + jsonToObj($json_text); + +=item Exported objToJson (advanced) + + $flags = {allow_blessed => 1, allow_barekey => 1}; + to_json($perl_scalar, $flags); + +equivalent to: + + $JSON::BareKey = 1; + objToJson($perl_scalar); + +=item jsonToObj as object method + + $json->decode($json_text); + +=item objToJson as object method + + $json->encode($perl_scalar); + +=item new method with parameters + +The C<new> method in 2.x takes any parameters no longer. +You can set parameters instead; + + $json = JSON->new->pretty; + +=item $JSON::Pretty, $JSON::Indent, $JSON::Delimiter + +If C<indent> is enable, that means C<$JSON::Pretty> flag set. And +C<$JSON::Delimiter> was substituted by C<space_before> and C<space_after>. +In conclusion: + + $json->indent->space_before->space_after; + +Equivalent to: + + $json->pretty; + +To change indent length, use C<indent_length>. + +(Only with JSON::PP, if C<-support_by_pp> is not used.) + + $json->pretty->indent_length(2)->encode($perl_scalar); + +=item $JSON::BareKey + +(Only with JSON::PP, if C<-support_by_pp> is not used.) + + $json->allow_barekey->decode($json_text) + +=item $JSON::ConvBlessed + +use C<-convert_blessed_universally>. See to L<convert_blessed>. + +=item $JSON::QuotApos + +(Only with JSON::PP, if C<-support_by_pp> is not used.) + + $json->allow_singlequote->decode($json_text) + +=item $JSON::SingleQuote + +Disable. C<JSON> does not make such a invalid JSON string any longer. + +=item $JSON::KeySort + + $json->canonical->encode($perl_scalar) + +This is the ascii sort. + +If you want to use with your own sort routine, check the C<sort_by> method. + +(Only with JSON::PP, even if C<-support_by_pp> is used currently.) + + $json->sort_by($sort_routine_ref)->encode($perl_scalar) + + $json->sort_by(sub { $JSON::PP::a <=> $JSON::PP::b })->encode($perl_scalar) + +Can't access C<$a> and C<$b> but C<$JSON::PP::a> and C<$JSON::PP::b>. + +=item $JSON::SkipInvalid + + $json->allow_unknown + +=item $JSON::AUTOCONVERT + +Needless. C<JSON> backend modules have the round-trip integrity. + +=item $JSON::UTF8 + +Needless because C<JSON> (JSON::XS/JSON::PP) sets +the UTF8 flag on properly. + + # With UTF8-flagged strings + + $json->allow_nonref; + $str = chr(1000); # UTF8-flagged + + $json_text = $json->utf8(0)->encode($str); + utf8::is_utf8($json_text); + # true + $json_text = $json->utf8(1)->encode($str); + utf8::is_utf8($json_text); + # false + + $str = '"' . chr(1000) . '"'; # UTF8-flagged + + $perl_scalar = $json->utf8(0)->decode($str); + utf8::is_utf8($perl_scalar); + # true + $perl_scalar = $json->utf8(1)->decode($str); + # died because of 'Wide character in subroutine' + +See to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL>. + +=item $JSON::UnMapping + +Disable. See to L<MAPPING>. + +=item $JSON::SelfConvert + +This option was deleted. +Instead of it, if a given blessed object has the C<TO_JSON> method, +C<TO_JSON> will be executed with C<convert_blessed>. + + $json->convert_blessed->encode($blessed_hashref_or_arrayref) + # if need, call allow_blessed + +Note that it was C<toJson> in old version, but now not C<toJson> but C<TO_JSON>. + +=back + +=head1 TODO + +=over + +=item example programs + +=back + +=head1 THREADS + +No test with JSON::PP. If with JSON::XS, See to L<JSON::XS/THREADS>. + + +=head1 BUGS + +Please report bugs relevant to C<JSON> to E<lt>makamaka[at]cpan.orgE<gt>. + + +=head1 SEE ALSO + +Most of the document is copied and modified from JSON::XS doc. + +L<JSON::XS>, L<JSON::PP> + +C<RFC4627>(L<http://www.ietf.org/rfc/rfc4627.txt>) + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + +JSON::XS was written by Marc Lehmann <schmorp[at]schmorp.de> + +The release of this new version owes to the courtesy of Marc Lehmann. + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2005-2013 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/out/lib/perl5/JSON/backportPP.pm b/third_party/JSON/out/lib/perl5/JSON/backportPP.pm new file mode 100644 index 0000000..cdf0c76 --- /dev/null +++ b/third_party/JSON/out/lib/perl5/JSON/backportPP.pm @@ -0,0 +1,2803 @@ +package # This is JSON::backportPP + JSON::PP; + +# JSON-2.0 + +use 5.005; +use strict; +use base qw(Exporter); +use overload (); + +use Carp (); +use B (); +#use Devel::Peek; + +use vars qw($VERSION); +$VERSION = '2.27202'; + +@JSON::PP::EXPORT = qw(encode_json decode_json from_json to_json); + +# instead of hash-access, i tried index-access for speed. +# but this method is not faster than what i expected. so it will be changed. + +use constant P_ASCII => 0; +use constant P_LATIN1 => 1; +use constant P_UTF8 => 2; +use constant P_INDENT => 3; +use constant P_CANONICAL => 4; +use constant P_SPACE_BEFORE => 5; +use constant P_SPACE_AFTER => 6; +use constant P_ALLOW_NONREF => 7; +use constant P_SHRINK => 8; +use constant P_ALLOW_BLESSED => 9; +use constant P_CONVERT_BLESSED => 10; +use constant P_RELAXED => 11; + +use constant P_LOOSE => 12; +use constant P_ALLOW_BIGNUM => 13; +use constant P_ALLOW_BAREKEY => 14; +use constant P_ALLOW_SINGLEQUOTE => 15; +use constant P_ESCAPE_SLASH => 16; +use constant P_AS_NONBLESSED => 17; + +use constant P_ALLOW_UNKNOWN => 18; + +use constant OLD_PERL => $] < 5.008 ? 1 : 0; + +BEGIN { + my @xs_compati_bit_properties = qw( + latin1 ascii utf8 indent canonical space_before space_after allow_nonref shrink + allow_blessed convert_blessed relaxed allow_unknown + ); + my @pp_bit_properties = qw( + allow_singlequote allow_bignum loose + allow_barekey escape_slash as_nonblessed + ); + + # Perl version check, Unicode handling is enable? + # Helper module sets @JSON::PP::_properties. + if ($] < 5.008 ) { + my $helper = $] >= 5.006 ? 'JSON::backportPP::Compat5006' : 'JSON::backportPP::Compat5005'; + eval qq| require $helper |; + if ($@) { Carp::croak $@; } + } + + for my $name (@xs_compati_bit_properties, @pp_bit_properties) { + my $flag_name = 'P_' . uc($name); + + eval qq/ + sub $name { + my \$enable = defined \$_[1] ? \$_[1] : 1; + + if (\$enable) { + \$_[0]->{PROPS}->[$flag_name] = 1; + } + else { + \$_[0]->{PROPS}->[$flag_name] = 0; + } + + \$_[0]; + } + + sub get_$name { + \$_[0]->{PROPS}->[$flag_name] ? 1 : ''; + } + /; + } + +} + + + +# Functions + +my %encode_allow_method + = map {($_ => 1)} qw/utf8 pretty allow_nonref latin1 self_encode escape_slash + allow_blessed convert_blessed indent indent_length allow_bignum + as_nonblessed + /; +my %decode_allow_method + = map {($_ => 1)} qw/utf8 allow_nonref loose allow_singlequote allow_bignum + allow_barekey max_size relaxed/; + + +my $JSON; # cache + +sub encode_json ($) { # encode + ($JSON ||= __PACKAGE__->new->utf8)->encode(@_); +} + + +sub decode_json { # decode + ($JSON ||= __PACKAGE__->new->utf8)->decode(@_); +} + +# Obsoleted + +sub to_json($) { + Carp::croak ("JSON::PP::to_json has been renamed to encode_json."); +} + + +sub from_json($) { + Carp::croak ("JSON::PP::from_json has been renamed to decode_json."); +} + + +# Methods + +sub new { + my $class = shift; + my $self = { + max_depth => 512, + max_size => 0, + indent => 0, + FLAGS => 0, + fallback => sub { encode_error('Invalid value. JSON can only reference.') }, + indent_length => 3, + }; + + bless $self, $class; +} + + +sub encode { + return $_[0]->PP_encode_json($_[1]); +} + + +sub decode { + return $_[0]->PP_decode_json($_[1], 0x00000000); +} + + +sub decode_prefix { + return $_[0]->PP_decode_json($_[1], 0x00000001); +} + + +# accessor + + +# pretty printing + +sub pretty { + my ($self, $v) = @_; + my $enable = defined $v ? $v : 1; + + if ($enable) { # indent_length(3) for JSON::XS compatibility + $self->indent(1)->indent_length(3)->space_before(1)->space_after(1); + } + else { + $self->indent(0)->space_before(0)->space_after(0); + } + + $self; +} + +# etc + +sub max_depth { + my $max = defined $_[1] ? $_[1] : 0x80000000; + $_[0]->{max_depth} = $max; + $_[0]; +} + + +sub get_max_depth { $_[0]->{max_depth}; } + + +sub max_size { + my $max = defined $_[1] ? $_[1] : 0; + $_[0]->{max_size} = $max; + $_[0]; +} + + +sub get_max_size { $_[0]->{max_size}; } + + +sub filter_json_object { + $_[0]->{cb_object} = defined $_[1] ? $_[1] : 0; + $_[0]->{F_HOOK} = ($_[0]->{cb_object} or $_[0]->{cb_sk_object}) ? 1 : 0; + $_[0]; +} + +sub filter_json_single_key_object { + if (@_ > 1) { + $_[0]->{cb_sk_object}->{$_[1]} = $_[2]; + } + $_[0]->{F_HOOK} = ($_[0]->{cb_object} or $_[0]->{cb_sk_object}) ? 1 : 0; + $_[0]; +} + +sub indent_length { + if (!defined $_[1] or $_[1] > 15 or $_[1] < 0) { + Carp::carp "The acceptable range of indent_length() is 0 to 15."; + } + else { + $_[0]->{indent_length} = $_[1]; + } + $_[0]; +} + +sub get_indent_length { + $_[0]->{indent_length}; +} + +sub sort_by { + $_[0]->{sort_by} = defined $_[1] ? $_[1] : 1; + $_[0]; +} + +sub allow_bigint { + Carp::carp("allow_bigint() is obsoleted. use allow_bignum() insted."); +} + +############################### + +### +### Perl => JSON +### + + +{ # Convert + + my $max_depth; + my $indent; + my $ascii; + my $latin1; + my $utf8; + my $space_before; + my $space_after; + my $canonical; + my $allow_blessed; + my $convert_blessed; + + my $indent_length; + my $escape_slash; + my $bignum; + my $as_nonblessed; + + my $depth; + my $indent_count; + my $keysort; + + + sub PP_encode_json { + my $self = shift; + my $obj = shift; + + $indent_count = 0; + $depth = 0; + + my $idx = $self->{PROPS}; + + ($ascii, $latin1, $utf8, $indent, $canonical, $space_before, $space_after, $allow_blessed, + $convert_blessed, $escape_slash, $bignum, $as_nonblessed) + = @{$idx}[P_ASCII .. P_SPACE_AFTER, P_ALLOW_BLESSED, P_CONVERT_BLESSED, + P_ESCAPE_SLASH, P_ALLOW_BIGNUM, P_AS_NONBLESSED]; + + ($max_depth, $indent_length) = @{$self}{qw/max_depth indent_length/}; + + $keysort = $canonical ? sub { $a cmp $b } : undef; + + if ($self->{sort_by}) { + $keysort = ref($self->{sort_by}) eq 'CODE' ? $self->{sort_by} + : $self->{sort_by} =~ /\D+/ ? $self->{sort_by} + : sub { $a cmp $b }; + } + + encode_error("hash- or arrayref expected (not a simple scalar, use allow_nonref to allow this)") + if(!ref $obj and !$idx->[ P_ALLOW_NONREF ]); + + my $str = $self->object_to_json($obj); + + $str .= "\n" if ( $indent ); # JSON::XS 2.26 compatible + + unless ($ascii or $latin1 or $utf8) { + utf8::upgrade($str); + } + + if ($idx->[ P_SHRINK ]) { + utf8::downgrade($str, 1); + } + + return $str; + } + + + sub object_to_json { + my ($self, $obj) = @_; + my $type = ref($obj); + + if($type eq 'HASH'){ + return $self->hash_to_json($obj); + } + elsif($type eq 'ARRAY'){ + return $self->array_to_json($obj); + } + elsif ($type) { # blessed object? + if (blessed($obj)) { + + return $self->value_to_json($obj) if ( $obj->isa('JSON::PP::Boolean') ); + + if ( $convert_blessed and $obj->can('TO_JSON') ) { + my $result = $obj->TO_JSON(); + if ( defined $result and ref( $result ) ) { + if ( refaddr( $obj ) eq refaddr( $result ) ) { + encode_error( sprintf( + "%s::TO_JSON method returned same object as was passed instead of a new one", + ref $obj + ) ); + } + } + + return $self->object_to_json( $result ); + } + + return "$obj" if ( $bignum and _is_bignum($obj) ); + return $self->blessed_to_json($obj) if ($allow_blessed and $as_nonblessed); # will be removed. + + encode_error( sprintf("encountered object '%s', but neither allow_blessed " + . "nor convert_blessed settings are enabled", $obj) + ) unless ($allow_blessed); + + return 'null'; + } + else { + return $self->value_to_json($obj); + } + } + else{ + return $self->value_to_json($obj); + } + } + + + sub hash_to_json { + my ($self, $obj) = @_; + my @res; + + encode_error("json text or perl structure exceeds maximum nesting level (max_depth set too low?)") + if (++$depth > $max_depth); + + my ($pre, $post) = $indent ? $self->_up_indent() : ('', ''); + my $del = ($space_before ? ' ' : '') . ':' . ($space_after ? ' ' : ''); + + for my $k ( _sort( $obj ) ) { + if ( OLD_PERL ) { utf8::decode($k) } # key for Perl 5.6 / be optimized + push @res, string_to_json( $self, $k ) + . $del + . ( $self->object_to_json( $obj->{$k} ) || $self->value_to_json( $obj->{$k} ) ); + } + + --$depth; + $self->_down_indent() if ($indent); + + return '{' . ( @res ? $pre : '' ) . ( @res ? join( ",$pre", @res ) . $post : '' ) . '}'; + } + + + sub array_to_json { + my ($self, $obj) = @_; + my @res; + + encode_error("json text or perl structure exceeds maximum nesting level (max_depth set too low?)") + if (++$depth > $max_depth); + + my ($pre, $post) = $indent ? $self->_up_indent() : ('', ''); + + for my $v (@$obj){ + push @res, $self->object_to_json($v) || $self->value_to_json($v); + } + + --$depth; + $self->_down_indent() if ($indent); + + return '[' . ( @res ? $pre : '' ) . ( @res ? join( ",$pre", @res ) . $post : '' ) . ']'; + } + + + sub value_to_json { + my ($self, $value) = @_; + + return 'null' if(!defined $value); + + my $b_obj = B::svref_2object(\$value); # for round trip problem + my $flags = $b_obj->FLAGS; + + return $value # as is + if $flags & ( B::SVp_IOK | B::SVp_NOK ) and !( $flags & B::SVp_POK ); # SvTYPE is IV or NV? + + my $type = ref($value); + + if(!$type){ + return string_to_json($self, $value); + } + elsif( blessed($value) and $value->isa('JSON::PP::Boolean') ){ + return $$value == 1 ? 'true' : 'false'; + } + elsif ($type) { + if ((overload::StrVal($value) =~ /=(\w+)/)[0]) { + return $self->value_to_json("$value"); + } + + if ($type eq 'SCALAR' and defined $$value) { + return $$value eq '1' ? 'true' + : $$value eq '0' ? 'false' + : $self->{PROPS}->[ P_ALLOW_UNKNOWN ] ? 'null' + : encode_error("cannot encode reference to scalar"); + } + + if ( $self->{PROPS}->[ P_ALLOW_UNKNOWN ] ) { + return 'null'; + } + else { + if ( $type eq 'SCALAR' or $type eq 'REF' ) { + encode_error("cannot encode reference to scalar"); + } + else { + encode_error("encountered $value, but JSON can only represent references to arrays or hashes"); + } + } + + } + else { + return $self->{fallback}->($value) + if ($self->{fallback} and ref($self->{fallback}) eq 'CODE'); + return 'null'; + } + + } + + + my %esc = ( + "\n" => '\n', + "\r" => '\r', + "\t" => '\t', + "\f" => '\f', + "\b" => '\b', + "\"" => '\"', + "\\" => '\\\\', + "\'" => '\\\'', + ); + + + sub string_to_json { + my ($self, $arg) = @_; + + $arg =~ s/([\x22\x5c\n\r\t\f\b])/$esc{$1}/g; + $arg =~ s/\//\\\//g if ($escape_slash); + $arg =~ s/([\x00-\x08\x0b\x0e-\x1f])/'\\u00' . unpack('H2', $1)/eg; + + if ($ascii) { + $arg = JSON_PP_encode_ascii($arg); + } + + if ($latin1) { + $arg = JSON_PP_encode_latin1($arg); + } + + if ($utf8) { + utf8::encode($arg); + } + + return '"' . $arg . '"'; + } + + + sub blessed_to_json { + my $reftype = reftype($_[1]) || ''; + if ($reftype eq 'HASH') { + return $_[0]->hash_to_json($_[1]); + } + elsif ($reftype eq 'ARRAY') { + return $_[0]->array_to_json($_[1]); + } + else { + return 'null'; + } + } + + + sub encode_error { + my $error = shift; + Carp::croak "$error"; + } + + + sub _sort { + defined $keysort ? (sort $keysort (keys %{$_[0]})) : keys %{$_[0]}; + } + + + sub _up_indent { + my $self = shift; + my $space = ' ' x $indent_length; + + my ($pre,$post) = ('',''); + + $post = "\n" . $space x $indent_count; + + $indent_count++; + + $pre = "\n" . $space x $indent_count; + + return ($pre,$post); + } + + + sub _down_indent { $indent_count--; } + + + sub PP_encode_box { + { + depth => $depth, + indent_count => $indent_count, + }; + } + +} # Convert + + +sub _encode_ascii { + join('', + map { + $_ <= 127 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', _encode_surrogates($_)); + } unpack('U*', $_[0]) + ); +} + + +sub _encode_latin1 { + join('', + map { + $_ <= 255 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', _encode_surrogates($_)); + } unpack('U*', $_[0]) + ); +} + + +sub _encode_surrogates { # from perlunicode + my $uni = $_[0] - 0x10000; + return ($uni / 0x400 + 0xD800, $uni % 0x400 + 0xDC00); +} + + +sub _is_bignum { + $_[0]->isa('Math::BigInt') or $_[0]->isa('Math::BigFloat'); +} + + + +# +# JSON => Perl +# + +my $max_intsize; + +BEGIN { + my $checkint = 1111; + for my $d (5..64) { + $checkint .= 1; + my $int = eval qq| $checkint |; + if ($int =~ /[eE]/) { + $max_intsize = $d - 1; + last; + } + } +} + +{ # PARSE + + my %escapes = ( # by Jeremy Muhlich <jmuhlich [at] bitflood.org> + b => "\x8", + t => "\x9", + n => "\xA", + f => "\xC", + r => "\xD", + '\\' => '\\', + '"' => '"', + '/' => '/', + ); + + my $text; # json data + my $at; # offset + my $ch; # 1chracter + my $len; # text length (changed according to UTF8 or NON UTF8) + # INTERNAL + my $depth; # nest counter + my $encoding; # json text encoding + my $is_valid_utf8; # temp variable + my $utf8_len; # utf8 byte length + # FLAGS + my $utf8; # must be utf8 + my $max_depth; # max nest number of objects and arrays + my $max_size; + my $relaxed; + my $cb_object; + my $cb_sk_object; + + my $F_HOOK; + + my $allow_bigint; # using Math::BigInt + my $singlequote; # loosely quoting + my $loose; # + my $allow_barekey; # bareKey + + # $opt flag + # 0x00000001 .... decode_prefix + # 0x10000000 .... incr_parse + + sub PP_decode_json { + my ($self, $opt); # $opt is an effective flag during this decode_json. + + ($self, $text, $opt) = @_; + + ($at, $ch, $depth) = (0, '', 0); + + if ( !defined $text or ref $text ) { + decode_error("malformed JSON string, neither array, object, number, string or atom"); + } + + my $idx = $self->{PROPS}; + + ($utf8, $relaxed, $loose, $allow_bigint, $allow_barekey, $singlequote) + = @{$idx}[P_UTF8, P_RELAXED, P_LOOSE .. P_ALLOW_SINGLEQUOTE]; + + if ( $utf8 ) { + utf8::downgrade( $text, 1 ) or Carp::croak("Wide character in subroutine entry"); + } + else { + utf8::upgrade( $text ); + } + + $len = length $text; + + ($max_depth, $max_size, $cb_object, $cb_sk_object, $F_HOOK) + = @{$self}{qw/max_depth max_size cb_object cb_sk_object F_HOOK/}; + + if ($max_size > 1) { + use bytes; + my $bytes = length $text; + decode_error( + sprintf("attempted decode of JSON text of %s bytes size, but max_size is set to %s" + , $bytes, $max_size), 1 + ) if ($bytes > $max_size); + } + + # Currently no effect + # should use regexp + my @octets = unpack('C4', $text); + $encoding = ( $octets[0] and $octets[1]) ? 'UTF-8' + : (!$octets[0] and $octets[1]) ? 'UTF-16BE' + : (!$octets[0] and !$octets[1]) ? 'UTF-32BE' + : ( $octets[2] ) ? 'UTF-16LE' + : (!$octets[2] ) ? 'UTF-32LE' + : 'unknown'; + + white(); # remove head white space + + my $valid_start = defined $ch; # Is there a first character for JSON structure? + + my $result = value(); + + return undef if ( !$result && ( $opt & 0x10000000 ) ); # for incr_parse + + decode_error("malformed JSON string, neither array, object, number, string or atom") unless $valid_start; + + if ( !$idx->[ P_ALLOW_NONREF ] and !ref $result ) { + decode_error( + 'JSON text must be an object or array (but found number, string, true, false or null,' + . ' use allow_nonref to allow this)', 1); + } + + Carp::croak('something wrong.') if $len < $at; # we won't arrive here. + + my $consumed = defined $ch ? $at - 1 : $at; # consumed JSON text length + + white(); # remove tail white space + + if ( $ch ) { + return ( $result, $consumed ) if ($opt & 0x00000001); # all right if decode_prefix + decode_error("garbage after JSON object"); + } + + ( $opt & 0x00000001 ) ? ( $result, $consumed ) : $result; + } + + + sub next_chr { + return $ch = undef if($at >= $len); + $ch = substr($text, $at++, 1); + } + + + sub value { + white(); + return if(!defined $ch); + return object() if($ch eq '{'); + return array() if($ch eq '['); + return string() if($ch eq '"' or ($singlequote and $ch eq "'")); + return number() if($ch =~ /[0-9]/ or $ch eq '-'); + return word(); + } + + sub string { + my ($i, $s, $t, $u); + my $utf16; + my $is_utf8; + + ($is_valid_utf8, $utf8_len) = ('', 0); + + $s = ''; # basically UTF8 flag on + + if($ch eq '"' or ($singlequote and $ch eq "'")){ + my $boundChar = $ch; + + OUTER: while( defined(next_chr()) ){ + + if($ch eq $boundChar){ + next_chr(); + + if ($utf16) { + decode_error("missing low surrogate character in surrogate pair"); + } + + utf8::decode($s) if($is_utf8); + + return $s; + } + elsif($ch eq '\\'){ + next_chr(); + if(exists $escapes{$ch}){ + $s .= $escapes{$ch}; + } + elsif($ch eq 'u'){ # UNICODE handling + my $u = ''; + + for(1..4){ + $ch = next_chr(); + last OUTER if($ch !~ /[0-9a-fA-F]/); + $u .= $ch; + } + + # U+D800 - U+DBFF + if ($u =~ /^[dD][89abAB][0-9a-fA-F]{2}/) { # UTF-16 high surrogate? + $utf16 = $u; + } + # U+DC00 - U+DFFF + elsif ($u =~ /^[dD][c-fC-F][0-9a-fA-F]{2}/) { # UTF-16 low surrogate? + unless (defined $utf16) { + decode_error("missing high surrogate character in surrogate pair"); + } + $is_utf8 = 1; + $s .= JSON_PP_decode_surrogates($utf16, $u) || next; + $utf16 = undef; + } + else { + if (defined $utf16) { + decode_error("surrogate pair expected"); + } + + if ( ( my $hex = hex( $u ) ) > 127 ) { + $is_utf8 = 1; + $s .= JSON_PP_decode_unicode($u) || next; + } + else { + $s .= chr $hex; + } + } + + } + else{ + unless ($loose) { + $at -= 2; + decode_error('illegal backslash escape sequence in string'); + } + $s .= $ch; + } + } + else{ + + if ( ord $ch > 127 ) { + if ( $utf8 ) { + unless( $ch = is_valid_utf8($ch) ) { + $at -= 1; + decode_error("malformed UTF-8 character in JSON string"); + } + else { + $at += $utf8_len - 1; + } + } + else { + utf8::encode( $ch ); + } + + $is_utf8 = 1; + } + + if (!$loose) { + if ($ch =~ /[\x00-\x1f\x22\x5c]/) { # '/' ok + $at--; + decode_error('invalid character encountered while parsing JSON string'); + } + } + + $s .= $ch; + } + } + } + + decode_error("unexpected end of string while parsing JSON string"); + } + + + sub white { + while( defined $ch ){ + if($ch le ' '){ + next_chr(); + } + elsif($ch eq '/'){ + next_chr(); + if(defined $ch and $ch eq '/'){ + 1 while(defined(next_chr()) and $ch ne "\n" and $ch ne "\r"); + } + elsif(defined $ch and $ch eq '*'){ + next_chr(); + while(1){ + if(defined $ch){ + if($ch eq '*'){ + if(defined(next_chr()) and $ch eq '/'){ + next_chr(); + last; + } + } + else{ + next_chr(); + } + } + else{ + decode_error("Unterminated comment"); + } + } + next; + } + else{ + $at--; + decode_error("malformed JSON string, neither array, object, number, string or atom"); + } + } + else{ + if ($relaxed and $ch eq '#') { # correctly? + pos($text) = $at; + $text =~ /\G([^\n]*(?:\r\n|\r|\n|$))/g; + $at = pos($text); + next_chr; + next; + } + + last; + } + } + } + + + sub array { + my $a = $_[0] || []; # you can use this code to use another array ref object. + + decode_error('json text or perl structure exceeds maximum nesting level (max_depth set too low?)') + if (++$depth > $max_depth); + + next_chr(); + white(); + + if(defined $ch and $ch eq ']'){ + --$depth; + next_chr(); + return $a; + } + else { + while(defined($ch)){ + push @$a, value(); + + white(); + + if (!defined $ch) { + last; + } + + if($ch eq ']'){ + --$depth; + next_chr(); + return $a; + } + + if($ch ne ','){ + last; + } + + next_chr(); + white(); + + if ($relaxed and $ch eq ']') { + --$depth; + next_chr(); + return $a; + } + + } + } + + decode_error(", or ] expected while parsing array"); + } + + + sub object { + my $o = $_[0] || {}; # you can use this code to use another hash ref object. + my $k; + + decode_error('json text or perl structure exceeds maximum nesting level (max_depth set too low?)') + if (++$depth > $max_depth); + next_chr(); + white(); + + if(defined $ch and $ch eq '}'){ + --$depth; + next_chr(); + if ($F_HOOK) { + return _json_object_hook($o); + } + return $o; + } + else { + while (defined $ch) { + $k = ($allow_barekey and $ch ne '"' and $ch ne "'") ? bareKey() : string(); + white(); + + if(!defined $ch or $ch ne ':'){ + $at--; + decode_error("':' expected"); + } + + next_chr(); + $o->{$k} = value(); + white(); + + last if (!defined $ch); + + if($ch eq '}'){ + --$depth; + next_chr(); + if ($F_HOOK) { + return _json_object_hook($o); + } + return $o; + } + + if($ch ne ','){ + last; + } + + next_chr(); + white(); + + if ($relaxed and $ch eq '}') { + --$depth; + next_chr(); + if ($F_HOOK) { + return _json_object_hook($o); + } + return $o; + } + + } + + } + + $at--; + decode_error(", or } expected while parsing object/hash"); + } + + + sub bareKey { # doesn't strictly follow Standard ECMA-262 3rd Edition + my $key; + while($ch =~ /[^\x00-\x23\x25-\x2F\x3A-\x40\x5B-\x5E\x60\x7B-\x7F]/){ + $key .= $ch; + next_chr(); + } + return $key; + } + + + sub word { + my $word = substr($text,$at-1,4); + + if($word eq 'true'){ + $at += 3; + next_chr; + return $JSON::PP::true; + } + elsif($word eq 'null'){ + $at += 3; + next_chr; + return undef; + } + elsif($word eq 'fals'){ + $at += 3; + if(substr($text,$at,1) eq 'e'){ + $at++; + next_chr; + return $JSON::PP::false; + } + } + + $at--; # for decode_error report + + decode_error("'null' expected") if ($word =~ /^n/); + decode_error("'true' expected") if ($word =~ /^t/); + decode_error("'false' expected") if ($word =~ /^f/); + decode_error("malformed JSON string, neither array, object, number, string or atom"); + } + + + sub number { + my $n = ''; + my $v; + + # According to RFC4627, hex or oct digits are invalid. + if($ch eq '0'){ + my $peek = substr($text,$at,1); + my $hex = $peek =~ /[xX]/; # 0 or 1 + + if($hex){ + decode_error("malformed number (leading zero must not be followed by another digit)"); + ($n) = ( substr($text, $at+1) =~ /^([0-9a-fA-F]+)/); + } + else{ # oct + ($n) = ( substr($text, $at) =~ /^([0-7]+)/); + if (defined $n and length $n > 1) { + decode_error("malformed number (leading zero must not be followed by another digit)"); + } + } + + if(defined $n and length($n)){ + if (!$hex and length($n) == 1) { + decode_error("malformed number (leading zero must not be followed by another digit)"); + } + $at += length($n) + $hex; + next_chr; + return $hex ? hex($n) : oct($n); + } + } + + if($ch eq '-'){ + $n = '-'; + next_chr; + if (!defined $ch or $ch !~ /\d/) { + decode_error("malformed number (no digits after initial minus)"); + } + } + + while(defined $ch and $ch =~ /\d/){ + $n .= $ch; + next_chr; + } + + if(defined $ch and $ch eq '.'){ + $n .= '.'; + + next_chr; + if (!defined $ch or $ch !~ /\d/) { + decode_error("malformed number (no digits after decimal point)"); + } + else { + $n .= $ch; + } + + while(defined(next_chr) and $ch =~ /\d/){ + $n .= $ch; + } + } + + if(defined $ch and ($ch eq 'e' or $ch eq 'E')){ + $n .= $ch; + next_chr; + + if(defined($ch) and ($ch eq '+' or $ch eq '-')){ + $n .= $ch; + next_chr; + if (!defined $ch or $ch =~ /\D/) { + decode_error("malformed number (no digits after exp sign)"); + } + $n .= $ch; + } + elsif(defined($ch) and $ch =~ /\d/){ + $n .= $ch; + } + else { + decode_error("malformed number (no digits after exp sign)"); + } + + while(defined(next_chr) and $ch =~ /\d/){ + $n .= $ch; + } + + } + + $v .= $n; + + if ($v !~ /[.eE]/ and length $v > $max_intsize) { + if ($allow_bigint) { # from Adam Sussman + require Math::BigInt; + return Math::BigInt->new($v); + } + else { + return "$v"; + } + } + elsif ($allow_bigint) { + require Math::BigFloat; + return Math::BigFloat->new($v); + } + + return 0+$v; + } + + + sub is_valid_utf8 { + + $utf8_len = $_[0] =~ /[\x00-\x7F]/ ? 1 + : $_[0] =~ /[\xC2-\xDF]/ ? 2 + : $_[0] =~ /[\xE0-\xEF]/ ? 3 + : $_[0] =~ /[\xF0-\xF4]/ ? 4 + : 0 + ; + + return unless $utf8_len; + + my $is_valid_utf8 = substr($text, $at - 1, $utf8_len); + + return ( $is_valid_utf8 =~ /^(?: + [\x00-\x7F] + |[\xC2-\xDF][\x80-\xBF] + |[\xE0][\xA0-\xBF][\x80-\xBF] + |[\xE1-\xEC][\x80-\xBF][\x80-\xBF] + |[\xED][\x80-\x9F][\x80-\xBF] + |[\xEE-\xEF][\x80-\xBF][\x80-\xBF] + |[\xF0][\x90-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF4][\x80-\x8F][\x80-\xBF][\x80-\xBF] + )$/x ) ? $is_valid_utf8 : ''; + } + + + sub decode_error { + my $error = shift; + my $no_rep = shift; + my $str = defined $text ? substr($text, $at) : ''; + my $mess = ''; + my $type = $] >= 5.008 ? 'U*' + : $] < 5.006 ? 'C*' + : utf8::is_utf8( $str ) ? 'U*' # 5.6 + : 'C*' + ; + + for my $c ( unpack( $type, $str ) ) { # emulate pv_uni_display() ? + $mess .= $c == 0x07 ? '\a' + : $c == 0x09 ? '\t' + : $c == 0x0a ? '\n' + : $c == 0x0d ? '\r' + : $c == 0x0c ? '\f' + : $c < 0x20 ? sprintf('\x{%x}', $c) + : $c == 0x5c ? '\\\\' + : $c < 0x80 ? chr($c) + : sprintf('\x{%x}', $c) + ; + if ( length $mess >= 20 ) { + $mess .= '...'; + last; + } + } + + unless ( length $mess ) { + $mess = '(end of string)'; + } + + Carp::croak ( + $no_rep ? "$error" : "$error, at character offset $at (before \"$mess\")" + ); + + } + + + sub _json_object_hook { + my $o = $_[0]; + my @ks = keys %{$o}; + + if ( $cb_sk_object and @ks == 1 and exists $cb_sk_object->{ $ks[0] } and ref $cb_sk_object->{ $ks[0] } ) { + my @val = $cb_sk_object->{ $ks[0] }->( $o->{$ks[0]} ); + if (@val == 1) { + return $val[0]; + } + } + + my @val = $cb_object->($o) if ($cb_object); + if (@val == 0 or @val > 1) { + return $o; + } + else { + return $val[0]; + } + } + + + sub PP_decode_box { + { + text => $text, + at => $at, + ch => $ch, + len => $len, + depth => $depth, + encoding => $encoding, + is_valid_utf8 => $is_valid_utf8, + }; + } + +} # PARSE + + +sub _decode_surrogates { # from perlunicode + my $uni = 0x10000 + (hex($_[0]) - 0xD800) * 0x400 + (hex($_[1]) - 0xDC00); + my $un = pack('U*', $uni); + utf8::encode( $un ); + return $un; +} + + +sub _decode_unicode { + my $un = pack('U', hex shift); + utf8::encode( $un ); + return $un; +} + +# +# Setup for various Perl versions (the code from JSON::PP58) +# + +BEGIN { + + unless ( defined &utf8::is_utf8 ) { + require Encode; + *utf8::is_utf8 = *Encode::is_utf8; + } + + if ( $] >= 5.008 ) { + *JSON::PP::JSON_PP_encode_ascii = \&_encode_ascii; + *JSON::PP::JSON_PP_encode_latin1 = \&_encode_latin1; + *JSON::PP::JSON_PP_decode_surrogates = \&_decode_surrogates; + *JSON::PP::JSON_PP_decode_unicode = \&_decode_unicode; + } + + if ($] >= 5.008 and $] < 5.008003) { # join() in 5.8.0 - 5.8.2 is broken. + package # hide from PAUSE + JSON::PP; + require subs; + subs->import('join'); + eval q| + sub join { + return '' if (@_ < 2); + my $j = shift; + my $str = shift; + for (@_) { $str .= $j . $_; } + return $str; + } + |; + } + + + sub JSON::PP::incr_parse { + local $Carp::CarpLevel = 1; + ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_parse( @_ ); + } + + + sub JSON::PP::incr_skip { + ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_skip; + } + + + sub JSON::PP::incr_reset { + ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_reset; + } + + eval q{ + sub JSON::PP::incr_text : lvalue { + $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new; + + if ( $_[0]->{_incr_parser}->{incr_parsing} ) { + Carp::croak("incr_text can not be called when the incremental parser already started parsing"); + } + $_[0]->{_incr_parser}->{incr_text}; + } + } if ( $] >= 5.006 ); + +} # Setup for various Perl versions (the code from JSON::PP58) + + +############################### +# Utilities +# + +BEGIN { + eval 'require Scalar::Util'; + unless($@){ + *JSON::PP::blessed = \&Scalar::Util::blessed; + *JSON::PP::reftype = \&Scalar::Util::reftype; + *JSON::PP::refaddr = \&Scalar::Util::refaddr; + } + else{ # This code is from Scalar::Util. + # warn $@; + eval 'sub UNIVERSAL::a_sub_not_likely_to_be_here { ref($_[0]) }'; + *JSON::PP::blessed = sub { + local($@, $SIG{__DIE__}, $SIG{__WARN__}); + ref($_[0]) ? eval { $_[0]->a_sub_not_likely_to_be_here } : undef; + }; + my %tmap = qw( + B::NULL SCALAR + B::HV HASH + B::AV ARRAY + B::CV CODE + B::IO IO + B::GV GLOB + B::REGEXP REGEXP + ); + *JSON::PP::reftype = sub { + my $r = shift; + + return undef unless length(ref($r)); + + my $t = ref(B::svref_2object($r)); + + return + exists $tmap{$t} ? $tmap{$t} + : length(ref($$r)) ? 'REF' + : 'SCALAR'; + }; + *JSON::PP::refaddr = sub { + return undef unless length(ref($_[0])); + + my $addr; + if(defined(my $pkg = blessed($_[0]))) { + $addr .= bless $_[0], 'Scalar::Util::Fake'; + bless $_[0], $pkg; + } + else { + $addr .= $_[0] + } + + $addr =~ /0x(\w+)/; + local $^W; + #no warnings 'portable'; + hex($1); + } + } +} + + +# shamelessly copied and modified from JSON::XS code. + +$JSON::PP::true = do { bless \(my $dummy = 1), "JSON::backportPP::Boolean" }; +$JSON::PP::false = do { bless \(my $dummy = 0), "JSON::backportPP::Boolean" }; + +sub is_bool { defined $_[0] and UNIVERSAL::isa($_[0], "JSON::PP::Boolean"); } + +sub true { $JSON::PP::true } +sub false { $JSON::PP::false } +sub null { undef; } + +############################### + +package JSON::backportPP::Boolean; + +@JSON::backportPP::Boolean::ISA = ('JSON::PP::Boolean'); +use overload ( + "0+" => sub { ${$_[0]} }, + "++" => sub { $_[0] = ${$_[0]} + 1 }, + "--" => sub { $_[0] = ${$_[0]} - 1 }, + fallback => 1, +); + + +############################### + +package # hide from PAUSE + JSON::PP::IncrParser; + +use strict; + +use constant INCR_M_WS => 0; # initial whitespace skipping +use constant INCR_M_STR => 1; # inside string +use constant INCR_M_BS => 2; # inside backslash +use constant INCR_M_JSON => 3; # outside anything, count nesting +use constant INCR_M_C0 => 4; +use constant INCR_M_C1 => 5; + +use vars qw($VERSION); +$VERSION = '1.01'; + +my $unpack_format = $] < 5.006 ? 'C*' : 'U*'; + +sub new { + my ( $class ) = @_; + + bless { + incr_nest => 0, + incr_text => undef, + incr_parsing => 0, + incr_p => 0, + }, $class; +} + + +sub incr_parse { + my ( $self, $coder, $text ) = @_; + + $self->{incr_text} = '' unless ( defined $self->{incr_text} ); + + if ( defined $text ) { + if ( utf8::is_utf8( $text ) and !utf8::is_utf8( $self->{incr_text} ) ) { + utf8::upgrade( $self->{incr_text} ) ; + utf8::decode( $self->{incr_text} ) ; + } + $self->{incr_text} .= $text; + } + + + my $max_size = $coder->get_max_size; + + if ( defined wantarray ) { + + $self->{incr_mode} = INCR_M_WS unless defined $self->{incr_mode}; + + if ( wantarray ) { + my @ret; + + $self->{incr_parsing} = 1; + + do { + push @ret, $self->_incr_parse( $coder, $self->{incr_text} ); + + unless ( !$self->{incr_nest} and $self->{incr_mode} == INCR_M_JSON ) { + $self->{incr_mode} = INCR_M_WS if $self->{incr_mode} != INCR_M_STR; + } + + } until ( length $self->{incr_text} >= $self->{incr_p} ); + + $self->{incr_parsing} = 0; + + return @ret; + } + else { # in scalar context + $self->{incr_parsing} = 1; + my $obj = $self->_incr_parse( $coder, $self->{incr_text} ); + $self->{incr_parsing} = 0 if defined $obj; # pointed by Martin J. Evans + return $obj ? $obj : undef; # $obj is an empty string, parsing was completed. + } + + } + +} + + +sub _incr_parse { + my ( $self, $coder, $text, $skip ) = @_; + my $p = $self->{incr_p}; + my $restore = $p; + + my @obj; + my $len = length $text; + + if ( $self->{incr_mode} == INCR_M_WS ) { + while ( $len > $p ) { + my $s = substr( $text, $p, 1 ); + $p++ and next if ( 0x20 >= unpack($unpack_format, $s) ); + $self->{incr_mode} = INCR_M_JSON; + last; + } + } + + while ( $len > $p ) { + my $s = substr( $text, $p++, 1 ); + + if ( $s eq '"' ) { + if (substr( $text, $p - 2, 1 ) eq '\\' ) { + next; + } + + if ( $self->{incr_mode} != INCR_M_STR ) { + $self->{incr_mode} = INCR_M_STR; + } + else { + $self->{incr_mode} = INCR_M_JSON; + unless ( $self->{incr_nest} ) { + last; + } + } + } + + if ( $self->{incr_mode} == INCR_M_JSON ) { + + if ( $s eq '[' or $s eq '{' ) { + if ( ++$self->{incr_nest} > $coder->get_max_depth ) { + Carp::croak('json text or perl structure exceeds maximum nesting level (max_depth set too low?)'); + } + } + elsif ( $s eq ']' or $s eq '}' ) { + last if ( --$self->{incr_nest} <= 0 ); + } + elsif ( $s eq '#' ) { + while ( $len > $p ) { + last if substr( $text, $p++, 1 ) eq "\n"; + } + } + + } + + } + + $self->{incr_p} = $p; + + return if ( $self->{incr_mode} == INCR_M_STR and not $self->{incr_nest} ); + return if ( $self->{incr_mode} == INCR_M_JSON and $self->{incr_nest} > 0 ); + + return '' unless ( length substr( $self->{incr_text}, 0, $p ) ); + + local $Carp::CarpLevel = 2; + + $self->{incr_p} = $restore; + $self->{incr_c} = $p; + + my ( $obj, $tail ) = $coder->PP_decode_json( substr( $self->{incr_text}, 0, $p ), 0x10000001 ); + + $self->{incr_text} = substr( $self->{incr_text}, $p ); + $self->{incr_p} = 0; + + return $obj or ''; +} + + +sub incr_text { + if ( $_[0]->{incr_parsing} ) { + Carp::croak("incr_text can not be called when the incremental parser already started parsing"); + } + $_[0]->{incr_text}; +} + + +sub incr_skip { + my $self = shift; + $self->{incr_text} = substr( $self->{incr_text}, $self->{incr_c} ); + $self->{incr_p} = 0; +} + + +sub incr_reset { + my $self = shift; + $self->{incr_text} = undef; + $self->{incr_p} = 0; + $self->{incr_mode} = 0; + $self->{incr_nest} = 0; + $self->{incr_parsing} = 0; +} + +############################### + + +1; +__END__ +=pod + +=head1 NAME + +JSON::PP - JSON::XS compatible pure-Perl module. + +=head1 SYNOPSIS + + use JSON::PP; + + # exported functions, they croak on error + # and expect/generate UTF-8 + + $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; + $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; + + # OO-interface + + $coder = JSON::PP->new->ascii->pretty->allow_nonref; + + $json_text = $json->encode( $perl_scalar ); + $perl_scalar = $json->decode( $json_text ); + + $pretty_printed = $json->pretty->encode( $perl_scalar ); # pretty-printing + + # Note that JSON version 2.0 and above will automatically use + # JSON::XS or JSON::PP, so you should be able to just: + + use JSON; + + +=head1 VERSION + + 2.27200 + +L<JSON::XS> 2.27 (~2.30) compatible. + +=head1 DESCRIPTION + +This module is L<JSON::XS> compatible pure Perl module. +(Perl 5.8 or later is recommended) + +JSON::XS is the fastest and most proper JSON module on CPAN. +It is written by Marc Lehmann in C, so must be compiled and +installed in the used environment. + +JSON::PP is a pure-Perl module and has compatibility to JSON::XS. + + +=head2 FEATURES + +=over + +=item * correct unicode handling + +This module knows how to handle Unicode (depending on Perl version). + +See to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL> and +L<UNICODE HANDLING ON PERLS>. + + +=item * round-trip integrity + +When you serialise a perl data structure using only data types +supported by JSON and Perl, the deserialised data structure is +identical on the Perl level. (e.g. the string "2.0" doesn't suddenly +become "2" just because it looks like a number). There I<are> minor +exceptions to this, read the MAPPING section below to learn about +those. + + +=item * strict checking of JSON correctness + +There is no guessing, no generating of illegal JSON texts by default, +and only JSON is accepted as input by default (the latter is a +security feature). But when some options are set, loose checking +features are available. + +=back + +=head1 FUNCTIONAL INTERFACE + +Some documents are copied and modified from L<JSON::XS/FUNCTIONAL INTERFACE>. + +=head2 encode_json + + $json_text = encode_json $perl_scalar + +Converts the given Perl data structure to a UTF-8 encoded, binary string. + +This function call is functionally identical to: + + $json_text = JSON::PP->new->utf8->encode($perl_scalar) + +=head2 decode_json + + $perl_scalar = decode_json $json_text + +The opposite of C<encode_json>: expects an UTF-8 (binary) string and tries +to parse that as an UTF-8 encoded JSON text, returning the resulting +reference. + +This function call is functionally identical to: + + $perl_scalar = JSON::PP->new->utf8->decode($json_text) + +=head2 JSON::PP::is_bool + + $is_boolean = JSON::PP::is_bool($scalar) + +Returns true if the passed scalar represents either JSON::PP::true or +JSON::PP::false, two constants that act like C<1> and C<0> respectively +and are also used to represent JSON C<true> and C<false> in Perl strings. + +=head2 JSON::PP::true + +Returns JSON true value which is blessed object. +It C<isa> JSON::PP::Boolean object. + +=head2 JSON::PP::false + +Returns JSON false value which is blessed object. +It C<isa> JSON::PP::Boolean object. + +=head2 JSON::PP::null + +Returns C<undef>. + +See L<MAPPING>, below, for more information on how JSON values are mapped to +Perl. + + +=head1 HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER + +This section supposes that your perl version is 5.8 or later. + +If you know a JSON text from an outer world - a network, a file content, and so on, +is encoded in UTF-8, you should use C<decode_json> or C<JSON> module object +with C<utf8> enable. And the decoded result will contain UNICODE characters. + + # from network + my $json = JSON::PP->new->utf8; + my $json_text = CGI->new->param( 'json_data' ); + my $perl_scalar = $json->decode( $json_text ); + + # from file content + local $/; + open( my $fh, '<', 'json.data' ); + $json_text = <$fh>; + $perl_scalar = decode_json( $json_text ); + +If an outer data is not encoded in UTF-8, firstly you should C<decode> it. + + use Encode; + local $/; + open( my $fh, '<', 'json.data' ); + my $encoding = 'cp932'; + my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE + + # or you can write the below code. + # + # open( my $fh, "<:encoding($encoding)", 'json.data' ); + # $unicode_json_text = <$fh>; + +In this case, C<$unicode_json_text> is of course UNICODE string. +So you B<cannot> use C<decode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable. + + $perl_scalar = $json->utf8(0)->decode( $unicode_json_text ); + +Or C<encode 'utf8'> and C<decode_json>: + + $perl_scalar = decode_json( encode( 'utf8', $unicode_json_text ) ); + # this way is not efficient. + +And now, you want to convert your C<$perl_scalar> into JSON data and +send it to an outer world - a network or a file content, and so on. + +Your data usually contains UNICODE strings and you want the converted data to be encoded +in UTF-8, you should use C<encode_json> or C<JSON> module object with C<utf8> enable. + + print encode_json( $perl_scalar ); # to a network? file? or display? + # or + print $json->utf8->encode( $perl_scalar ); + +If C<$perl_scalar> does not contain UNICODE but C<$encoding>-encoded strings +for some reason, then its characters are regarded as B<latin1> for perl +(because it does not concern with your $encoding). +You B<cannot> use C<encode_json> nor C<JSON> module object with C<utf8> enable. +Instead of them, you use C<JSON> module object with C<utf8> disable. +Note that the resulted text is a UNICODE string but no problem to print it. + + # $perl_scalar contains $encoding encoded string values + $unicode_json_text = $json->utf8(0)->encode( $perl_scalar ); + # $unicode_json_text consists of characters less than 0x100 + print $unicode_json_text; + +Or C<decode $encoding> all string values and C<encode_json>: + + $perl_scalar->{ foo } = decode( $encoding, $perl_scalar->{ foo } ); + # ... do it to each string values, then encode_json + $json_text = encode_json( $perl_scalar ); + +This method is a proper way but probably not efficient. + +See to L<Encode>, L<perluniintro>. + + +=head1 METHODS + +Basically, check to L<JSON> or L<JSON::XS>. + +=head2 new + + $json = JSON::PP->new + +Returns a new JSON::PP object that can be used to de/encode JSON +strings. + +All boolean flags described below are by default I<disabled>. + +The mutators for flags all return the JSON object again and thus calls can +be chained: + + my $json = JSON::PP->new->utf8->space_after->encode({a => [1,2]}) + => {"a": [1, 2]} + +=head2 ascii + + $json = $json->ascii([$enable]) + + $enabled = $json->get_ascii + +If $enable is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627. +(See to L<JSON::XS/OBJECT-ORIENTED INTERFACE>). + +In Perl 5.005, there is no character having high value (more than 255). +See to L<UNICODE HANDLING ON PERLS>. + +If $enable is false, then the encode method will not escape Unicode characters unless +required by the JSON syntax or other flags. This results in a faster and more compact format. + + JSON::PP->new->ascii(1)->encode([chr 0x10401]) + => ["\ud801\udc01"] + +=head2 latin1 + + $json = $json->latin1([$enable]) + + $enabled = $json->get_latin1 + +If $enable is true (or missing), then the encode method will encode the resulting JSON +text as latin1 (or iso-8859-1), escaping any characters outside the code range 0..255. + +If $enable is false, then the encode method will not escape Unicode characters +unless required by the JSON syntax or other flags. + + JSON::XS->new->latin1->encode (["\x{89}\x{abc}"] + => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not) + +See to L<UNICODE HANDLING ON PERLS>. + +=head2 utf8 + + $json = $json->utf8([$enable]) + + $enabled = $json->get_utf8 + +If $enable is true (or missing), then the encode method will encode the JSON result +into UTF-8, as required by many protocols, while the decode method expects to be handled +an UTF-8-encoded string. Please note that UTF-8-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. + +(In Perl 5.005, any character outside the range 0..255 does not exist. +See to L<UNICODE HANDLING ON PERLS>.) + +In future versions, enabling this option might enable autodetection of the UTF-16 and UTF-32 +encoding families, as described in RFC4627. + +If $enable is false, then the encode method will return the JSON string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to UTF-8 or UTF-16) needs to be done yourself, e.g. using the Encode module. + +Example, output UTF-16BE-encoded JSON: + + use Encode; + $jsontext = encode "UTF-16BE", JSON::PP->new->encode ($object); + +Example, decode UTF-32LE-encoded JSON: + + use Encode; + $object = JSON::PP->new->decode (decode "UTF-32LE", $jsontext); + + +=head2 pretty + + $json = $json->pretty([$enable]) + +This enables (or disables) all of the C<indent>, C<space_before> and +C<space_after> flags in one call to generate the most readable +(or most compact) form possible. + +Equivalent to: + + $json->indent->space_before->space_after + +=head2 indent + + $json = $json->indent([$enable]) + + $enabled = $json->get_indent + +The default indent space length is three. +You can use C<indent_length> to change the length. + +=head2 space_before + + $json = $json->space_before([$enable]) + + $enabled = $json->get_space_before + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space before the C<:> separating keys from values in JSON objects. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before enabled, space_after and indent disabled: + + {"key" :"value"} + +=head2 space_after + + $json = $json->space_after([$enable]) + + $enabled = $json->get_space_after + +If C<$enable> is true (or missing), then the C<encode> method will add an extra +optional space after the C<:> separating keys from values in JSON objects +and extra whitespace after the C<,> separating key-value pairs and array +members. + +If C<$enable> is false, then the C<encode> method will not add any extra +space at those places. + +This setting has no effect when decoding JSON texts. + +Example, space_before and indent disabled, space_after enabled: + + {"key": "value"} + +=head2 relaxed + + $json = $json->relaxed([$enable]) + + $enabled = $json->get_relaxed + +If C<$enable> is true (or missing), then C<decode> will accept some +extensions to normal JSON syntax (see below). C<encode> will not be +affected in anyway. I<Be aware that this option makes you accept invalid +JSON texts as if they were valid!>. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) + +If C<$enable> is false (the default), then C<decode> will only accept +valid JSON texts. + +Currently accepted extensions are: + +=over 4 + +=item * list items can have an end-comma + +JSON I<separates> array elements and key-value pairs with commas. This +can be annoying if you write JSON texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: + + [ + 1, + 2, <- this comma not normally allowed + ] + { + "k1": "v1", + "k2": "v2", <- this comma not normally allowed + } + +=item * shell-style '#'-comments + +Whenever JSON allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. + + [ + 1, # this comment not allowed in JSON + # neither this one... + ] + +=back + +=head2 canonical + + $json = $json->canonical([$enable]) + + $enabled = $json->get_canonical + +If C<$enable> is true (or missing), then the C<encode> method will output JSON objects +by sorting their keys. This is adding a comparatively high overhead. + +If C<$enable> is false, then the C<encode> method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). + +This option is useful if you want the same data structure to be encoded as +the same JSON text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. + +This setting has no effect when decoding JSON texts. + +If you want your own sorting routine, you can give a code reference +or a subroutine name to C<sort_by>. See to C<JSON::PP OWN METHODS>. + +=head2 allow_nonref + + $json = $json->allow_nonref([$enable]) + + $enabled = $json->get_allow_nonref + +If C<$enable> is true (or missing), then the C<encode> method can convert a +non-reference into its corresponding string, number or null JSON value, +which is an extension to RFC4627. Likewise, C<decode> will accept those JSON +values instead of croaking. + +If C<$enable> is false, then the C<encode> method will croak if it isn't +passed an arrayref or hashref, as JSON texts must either be an object +or array. Likewise, C<decode> will croak if given something that is not a +JSON object or array. + + JSON::PP->new->allow_nonref->encode ("Hello, World!") + => "Hello, World!" + +=head2 allow_unknown + + $json = $json->allow_unknown ([$enable]) + + $enabled = $json->get_allow_unknown + +If $enable is true (or missing), then "encode" will *not* throw an +exception when it encounters values it cannot represent in JSON (for +example, filehandles) but instead will encode a JSON "null" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. + +If $enable is false (the default), then "encode" will throw an +exception when it encounters anything it cannot encode as JSON. + +This option does not affect "decode" in any way, and it is +recommended to leave it off unless you know your communications +partner. + +=head2 allow_blessed + + $json = $json->allow_blessed([$enable]) + + $enabled = $json->get_allow_blessed + +If C<$enable> is true (or missing), then the C<encode> method will not +barf when it encounters a blessed reference. Instead, the value of the +B<convert_blessed> option will decide whether C<null> (C<convert_blessed> +disabled or no C<TO_JSON> method found) or a representation of the +object (C<convert_blessed> enabled and C<TO_JSON> method found) is being +encoded. Has no effect on C<decode>. + +If C<$enable> is false (the default), then C<encode> will throw an +exception when it encounters a blessed object. + +=head2 convert_blessed + + $json = $json->convert_blessed([$enable]) + + $enabled = $json->get_convert_blessed + +If C<$enable> is true (or missing), then C<encode>, upon encountering a +blessed object, will check for the availability of the C<TO_JSON> method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +C<TO_JSON> method is found, the value of C<allow_blessed> will decide what +to do. + +The C<TO_JSON> method may safely call die if it wants. If C<TO_JSON> +returns other blessed objects, those will be handled in the same +way. C<TO_JSON> must take care of not causing an endless recursion cycle +(== crash) in this case. The name of C<TO_JSON> was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the C<to_json> +function or method. + +This setting does not yet influence C<decode> in any way. + +If C<$enable> is false, then the C<allow_blessed> setting will decide what +to do when a blessed object is found. + +=head2 filter_json_object + + $json = $json->filter_json_object([$coderef]) + +When C<$coderef> is specified, it will be called from C<decode> each +time it decodes a JSON object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(NOTE: I<not> C<undef>, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. + +When C<$coderef> is omitted or undefined, any existing callback will +be removed and C<decode> will not change the deserialised hash in any +way. + +Example, convert all JSON objects into the integer 5: + + my $js = JSON::PP->new->filter_json_object (sub { 5 }); + # returns [5] + $js->decode ('[{}]'); # the given subroutine takes a hash reference. + # throw an exception because allow_nonref is not enabled + # so a lone 5 is not allowed. + $js->decode ('{"a":1, "b":2}'); + +=head2 filter_json_single_key_object + + $json = $json->filter_json_single_key_object($key [=> $coderef]) + +Works remotely similar to C<filter_json_object>, but is only called for +JSON objects having a single key named C<$key>. + +This C<$coderef> is called before the one specified via +C<filter_json_object>, if any. It gets passed the single value in the JSON +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even C<undef> but the empty list), +the callback from C<filter_json_object> will be called next, as if no +single-key callback were specified. + +If C<$coderef> is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. + +As this callback gets called less often then the C<filter_json_object> +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key JSON objects are as close to the type-tagged value concept +as JSON gets (it's basically an ID/VALUE tuple). Of course, JSON does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. + +Typical names for the single object key are C<__class_whatever__>, or +C<$__dollars_are_rarely_used__$> or C<}ugly_brace_placement>, or even +things like C<__class_md5sum(classname)__>, to reduce the risk of clashing +with real hashes. + +Example, decode JSON objects of the form C<< { "__widget__" => <id> } >> +into the corresponding C<< $WIDGET{<id>} >> object: + + # return whatever is in $WIDGET{5}: + JSON::PP + ->new + ->filter_json_single_key_object (__widget__ => sub { + $WIDGET{ $_[0] } + }) + ->decode ('{"__widget__": 5') + + # this can be used with a TO_JSON method in some "widget" class + # for serialisation to json: + sub WidgetBase::TO_JSON { + my ($self) = @_; + + unless ($self->{id}) { + $self->{id} = ..get..some..id..; + $WIDGET{$self->{id}} = $self; + } + + { __widget__ => $self->{id} } + } + +=head2 shrink + + $json = $json->shrink([$enable]) + + $enabled = $json->get_shrink + +In JSON::XS, this flag resizes strings generated by either +C<encode> or C<decode> to their minimum size possible. +It will also try to downgrade any strings to octet-form if possible. + +In JSON::PP, it is noop about resizing strings but tries +C<utf8::downgrade> to the returned string by C<encode>. +See to L<utf8>. + +See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> + +=head2 max_depth + + $json = $json->max_depth([$maximum_nesting_depth]) + + $max_depth = $json->get_max_depth + +Sets the maximum nesting level (default C<512>) accepted while encoding +or decoding. If a higher nesting level is detected in JSON text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. + +Nesting level is defined by number of hash- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of C<{> or C<[> +characters without their matching closing parenthesis crossed to reach a +given character in a string. + +If no argument is given, the highest possible setting will be used, which +is rarely useful. + +See L<JSON::XS/SSECURITY CONSIDERATIONS> for more info on why this is useful. + +When a large value (100 or more) was set and it de/encodes a deep nested object/text, +it may raise a warning 'Deep recursion on subroutine' at the perl runtime phase. + +=head2 max_size + + $json = $json->max_size([$maximum_string_size]) + + $max_size = $json->get_max_size + +Set the maximum length a JSON text may have (in bytes) where decoding is +being attempted. The default is C<0>, meaning no limit. When C<decode> +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on C<encode> (yet). + +If no argument is given, the limit check will be deactivated (same as when +C<0> is specified). + +See L<JSON::XS/SECURITY CONSIDERATIONS> for more info on why this is useful. + +=head2 encode + + $json_text = $json->encode($perl_scalar) + +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its JSON representation. Simple scalars will be +converted into JSON string or number sequences, while references to arrays +become JSON arrays and references to hashes become JSON objects. Undefined +Perl values (e.g. C<undef>) become JSON C<null> values. +References to the integers C<0> and C<1> are converted into C<true> and C<false>. + +=head2 decode + + $perl_scalar = $json->decode($json_text) + +The opposite of C<encode>: expects a JSON text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. + +JSON numbers and strings become simple Perl scalars. JSON arrays become +Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes +C<1> (C<JSON::true>), C<false> becomes C<0> (C<JSON::false>) and +C<null> becomes C<undef>. + +=head2 decode_prefix + + ($perl_scalar, $characters) = $json->decode_prefix($json_text) + +This works like the C<decode> method, but instead of raising an exception +when there is trailing garbage after the first JSON object, it will +silently stop parsing there and return the number of characters consumed +so far. + + JSON->new->decode_prefix ("[1] the tail") + => ([], 3) + +=head1 INCREMENTAL PARSING + +Most of this section are copied and modified from L<JSON::XS/INCREMENTAL PARSING>. + +In some cases, there is the need for incremental parsing of JSON texts. +This module does allow you to parse a JSON stream incrementally. +It does so by accumulating text until it has a full JSON object, which +it then can decode. This process is similar to using C<decode_prefix> +to see if a full JSON object is available, but is much more efficient +(and can be implemented with a minimum of method calls). + +This module will only attempt to parse the JSON text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid JSON text has been seen. This means you need +to set resource limits (e.g. C<max_size>) to ensure the parser will stop +parsing in the presence if syntax errors. + +The following methods implement this incremental parser. + +=head2 incr_parse + + $json->incr_parse( [$string] ) # void context + + $obj_or_undef = $json->incr_parse( [$string] ) # scalar context + + @obj_or_empty = $json->incr_parse( [$string] ) # list context + +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). + +If C<$string> is given, then this string is appended to the already +existing JSON fragment stored in the C<$json> object. + +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. + +If the method is called in scalar context, then it will try to extract +exactly I<one> JSON object. If that is successful, it will return this +object, otherwise it will return C<undef>. If there is a parse error, +this method will croak just as C<decode> would do (one can then use +C<incr_skip> to skip the erroneous part). This is the most common way of +using the method. + +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the JSON +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed JSON texts will be +lost. + +Example: Parse some JSON arrays/objects in a given string and return them. + + my @objs = JSON->new->incr_parse ("[5][7][1,2]"); + +=head2 incr_text + + $lvalue_string = $json->incr_text + +This method returns the currently stored JSON fragment as an lvalue, that +is, you can manipulate it. This I<only> works when a preceding call to +C<incr_parse> in I<scalar context> successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it I<will> fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. + +This function is useful in two cases: a) finding the trailing text after a +JSON object or b) parsing multiple JSON objects separated by non-JSON text +(such as commas). + + $json->incr_text =~ s/\s*,\s*//; + +In Perl 5.005, C<lvalue> attribute is not available. +You must write codes like the below: + + $string = $json->incr_text; + $string =~ s/\s*,\s*//; + $json->incr_text( $string ); + +=head2 incr_skip + + $json->incr_skip + +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after C<incr_parse> +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. + +=head2 incr_reset + + $json->incr_reset + +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. + +This is useful if you want to repeatedly parse JSON objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. + +See to L<JSON::XS/INCREMENTAL PARSING> for examples. + + +=head1 JSON::PP OWN METHODS + +=head2 allow_singlequote + + $json = $json->allow_singlequote([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +JSON strings quoted by single quotations that are invalid JSON +format. + + $json->allow_singlequote->decode({"foo":'bar'}); + $json->allow_singlequote->decode({'foo':"bar"}); + $json->allow_singlequote->decode({'foo':'bar'}); + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + + +=head2 allow_barekey + + $json = $json->allow_barekey([$enable]) + +If C<$enable> is true (or missing), then C<decode> will accept +bare keys of JSON object that are invalid JSON format. + +As same as the C<relaxed> option, this option may be used to parse +application-specific files written by humans. + + $json->allow_barekey->decode('{foo:"bar"}'); + +=head2 allow_bignum + + $json = $json->allow_bignum([$enable]) + +If C<$enable> is true (or missing), then C<decode> will convert +the big integer Perl cannot handle as integer into a L<Math::BigInt> +object and convert a floating number (any) into a L<Math::BigFloat>. + +On the contrary, C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers with C<allow_blessed> enable. + + $json->allow_nonref->allow_blessed->allow_bignum; + $bigfloat = $json->decode('2.000000000000000000000000001'); + print $json->encode($bigfloat); + # => 2.000000000000000000000000001 + +See to L<JSON::XS/MAPPING> about the normal conversion of JSON number. + +=head2 loose + + $json = $json->loose([$enable]) + +The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON strings +and the module doesn't allow to C<decode> to these (except for \x2f). +If C<$enable> is true (or missing), then C<decode> will accept these +unescaped strings. + + $json->loose->decode(qq|["abc + def"]|); + +See L<JSON::XS/SSECURITY CONSIDERATIONS>. + +=head2 escape_slash + + $json = $json->escape_slash([$enable]) + +According to JSON Grammar, I<slash> (U+002F) is escaped. But default +JSON::PP (as same as JSON::XS) encodes strings without escaping slash. + +If C<$enable> is true (or missing), then C<encode> will escape slashes. + +=head2 indent_length + + $json = $json->indent_length($length) + +JSON::XS indent space length is 3 and cannot be changed. +JSON::PP set the indent space length with the given $length. +The default is 3. The acceptable range is 0 to 15. + +=head2 sort_by + + $json = $json->sort_by($function_name) + $json = $json->sort_by($subroutine_ref) + +If $function_name or $subroutine_ref are set, its sort routine are used +in encoding JSON objects. + + $js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + $js = $pc->sort_by('own_sort')->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } + +As the sorting routine runs in the JSON::PP scope, the given +subroutine name and the special variables C<$a>, C<$b> will begin +'JSON::PP::'. + +If $integer is set, then the effect is same as C<canonical> on. + +=head1 INTERNAL + +For developers. + +=over + +=item PP_encode_box + +Returns + + { + depth => $depth, + indent_count => $indent_count, + } + + +=item PP_decode_box + +Returns + + { + text => $text, + at => $at, + ch => $ch, + len => $len, + depth => $depth, + encoding => $encoding, + is_valid_utf8 => $is_valid_utf8, + }; + +=back + +=head1 MAPPING + +This section is copied from JSON::XS and modified to C<JSON::PP>. +JSON::XS and JSON::PP mapping mechanisms are almost equivalent. + +See to L<JSON::XS/MAPPING>. + +=head2 JSON -> PERL + +=over 4 + +=item object + +A JSON object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (JSON does not preserver object key ordering itself). + +=item array + +A JSON array becomes a reference to an array in Perl. + +=item string + +A JSON string becomes a string scalar in Perl - Unicode codepoints in JSON +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. + +=item number + +A JSON number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. + +If the number consists of digits only, C<JSON> will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the JSON number will be +re-encoded to a JSON string). + +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the JSON number will still be re-encoded as a JSON number). + +Note that precision is not accuracy - binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, C<JSON> only guarantees precision up to but not including +the least significant bit. + +When C<allow_bignum> is enable, the big integers +and the numeric can be optionally converted into L<Math::BigInt> and +L<Math::BigFloat> objects. + +=item true, false + +These JSON atoms become C<JSON::PP::true> and C<JSON::PP::false>, +respectively. They are overloaded to act almost exactly like the numbers +C<1> and C<0>. You can check whether a scalar is a JSON boolean by using +the C<JSON::is_bool> function. + + print JSON::PP::true . "\n"; + => true + print JSON::PP::true + 1; + => 1 + + ok(JSON::true eq '1'); + ok(JSON::true == 1); + +C<JSON> will install these missing overloading features to the backend modules. + + +=item null + +A JSON null atom becomes C<undef> in Perl. + +C<JSON::PP::null> returns C<undef>. + +=back + + +=head2 PERL -> JSON + +The mapping from Perl to JSON is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which JSON type is meant by +a Perl value. + +=over 4 + +=item hash references + +Perl hash references become JSON objects. As there is no inherent ordering +in hash keys (or JSON objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. C<JSON> +optionally sort the hash keys (determined by the I<canonical> flag), so +the same data structure will serialise to the same JSON text (given same +settings and version of JSON::XS), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some JSON text +against another for equality. + + +=item array references + +Perl array references become JSON arrays. + +=item other references + +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers C<0> and +C<1>, which get turned into C<false> and C<true> atoms in JSON. You can +also use C<JSON::false> and C<JSON::true> to improve readability. + + to_json [\0,JSON::PP::true] # yields [false,true] + +=item JSON::PP::true, JSON::PP::false, JSON::PP::null + +These special values become JSON true and JSON false values, +respectively. You can also use C<\1> and C<\0> directly if you want. + +JSON::PP::null returns C<undef>. + +=item blessed objects + +Blessed objects are not directly representable in JSON. See the +C<allow_blessed> and C<convert_blessed> methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. + +See to L<convert_blessed>. + +=item simple scalars + +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: JSON::XS and JSON::PP will encode undefined scalars as +JSON C<null> values, scalars that have last been used in a string context +before encoding as JSON strings, and anything else as number value: + + # dump as number + encode_json [2] # yields [2] + encode_json [-3.0e17] # yields [-3e+17] + my $value = 5; encode_json [$value] # yields [5] + + # used as string, so dump as string + print $value; + encode_json [$value] # yields ["5"] + + # undef becomes null + encode_json [undef] # yields [null] + +You can force the type to be a string by stringifying it: + + my $x = 3.1; # some variable containing a number + "$x"; # stringified + $x .= ""; # another, more awkward way to stringify + print $x; # perl does it for you, too, quite often + +You can force the type to be a number by numifying it: + + my $x = "3"; # some variable containing a string + $x += 0; # numify it, ensuring it will be dumped as a number + $x *= 1; # same thing, the choice is yours. + +You can not currently force the type in other, less obscure, ways. + +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's - these cannot be represented in JSON, and it is an +error to pass those in. + +=item Big Number + +When C<allow_bignum> is enable, +C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat> +objects into JSON numbers. + + +=back + +=head1 UNICODE HANDLING ON PERLS + +If you do not know about Unicode on Perl well, +please check L<JSON::XS/A FEW NOTES ON UNICODE AND PERL>. + +=head2 Perl 5.8 and later + +Perl can handle Unicode and the JSON::PP de/encode methods also work properly. + + $json->allow_nonref->encode(chr hex 3042); + $json->allow_nonref->encode(chr hex 12345); + +Returns C<"\u3042"> and C<"\ud808\udf45"> respectively. + + $json->allow_nonref->decode('"\u3042"'); + $json->allow_nonref->decode('"\ud808\udf45"'); + +Returns UTF-8 encoded strings with UTF8 flag, regarded as C<U+3042> and C<U+12345>. + +Note that the versions from Perl 5.8.0 to 5.8.2, Perl built-in C<join> was broken, +so JSON::PP wraps the C<join> with a subroutine. Thus JSON::PP works slow in the versions. + + +=head2 Perl 5.6 + +Perl can handle Unicode and the JSON::PP de/encode methods also work. + +=head2 Perl 5.005 + +Perl 5.005 is a byte semantics world -- all strings are sequences of bytes. +That means the unicode handling is not available. + +In encoding, + + $json->allow_nonref->encode(chr hex 3042); # hex 3042 is 12354. + $json->allow_nonref->encode(chr hex 12345); # hex 12345 is 74565. + +Returns C<B> and C<E>, as C<chr> takes a value more than 255, it treats +as C<$value % 256>, so the above codes are equivalent to : + + $json->allow_nonref->encode(chr 66); + $json->allow_nonref->encode(chr 69); + +In decoding, + + $json->decode('"\u00e3\u0081\u0082"'); + +The returned is a byte sequence C<0xE3 0x81 0x82> for UTF-8 encoded +japanese character (C<HIRAGANA LETTER A>). +And if it is represented in Unicode code point, C<U+3042>. + +Next, + + $json->decode('"\u3042"'); + +We ordinary expect the returned value is a Unicode character C<U+3042>. +But here is 5.005 world. This is C<0xE3 0x81 0x82>. + + $json->decode('"\ud808\udf45"'); + +This is not a character C<U+12345> but bytes - C<0xf0 0x92 0x8d 0x85>. + + +=head1 TODO + +=over + +=item speed + +=item memory saving + +=back + + +=head1 SEE ALSO + +Most of the document are copied and modified from JSON::XS doc. + +L<JSON::XS> + +RFC4627 (L<http://www.ietf.org/rfc/rfc4627.txt>) + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2007-2012 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut diff --git a/third_party/JSON/out/lib/perl5/JSON/backportPP/Boolean.pm b/third_party/JSON/out/lib/perl5/JSON/backportPP/Boolean.pm new file mode 100644 index 0000000..38be6a3 --- /dev/null +++ b/third_party/JSON/out/lib/perl5/JSON/backportPP/Boolean.pm @@ -0,0 +1,27 @@ +=head1 NAME + +JSON::PP::Boolean - dummy module providing JSON::PP::Boolean + +=head1 SYNOPSIS + + # do not "use" yourself + +=head1 DESCRIPTION + +This module exists only to provide overload resolution for Storable +and similar modules. See L<JSON::PP> for more info about this class. + +=cut + +use JSON::backportPP (); +use strict; + +1; + +=head1 AUTHOR + +This idea is from L<JSON::XS::Boolean> written by +Marc Lehmann <schmorp[at]schmorp.de> + +=cut + diff --git a/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5005.pm b/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5005.pm new file mode 100644 index 0000000..139990e --- /dev/null +++ b/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5005.pm @@ -0,0 +1,131 @@ +package # This is JSON::backportPP + JSON::backportPP5005; + +use 5.005; +use strict; + +my @properties; + +$JSON::PP5005::VERSION = '1.10'; + +BEGIN { + + sub utf8::is_utf8 { + 0; # It is considered that UTF8 flag off for Perl 5.005. + } + + sub utf8::upgrade { + } + + sub utf8::downgrade { + 1; # must always return true. + } + + sub utf8::encode { + } + + sub utf8::decode { + } + + *JSON::PP::JSON_PP_encode_ascii = \&_encode_ascii; + *JSON::PP::JSON_PP_encode_latin1 = \&_encode_latin1; + *JSON::PP::JSON_PP_decode_surrogates = \&_decode_surrogates; + *JSON::PP::JSON_PP_decode_unicode = \&_decode_unicode; + + # missing in B module. + sub B::SVp_IOK () { 0x01000000; } + sub B::SVp_NOK () { 0x02000000; } + sub B::SVp_POK () { 0x04000000; } + + $INC{'bytes.pm'} = 1; # dummy +} + + + +sub _encode_ascii { + join('', map { $_ <= 127 ? chr($_) : sprintf('\u%04x', $_) } unpack('C*', $_[0]) ); +} + + +sub _encode_latin1 { + join('', map { chr($_) } unpack('C*', $_[0]) ); +} + + +sub _decode_surrogates { # from http://homepage1.nifty.com/nomenclator/unicode/ucs_utf.htm + my $uni = 0x10000 + (hex($_[0]) - 0xD800) * 0x400 + (hex($_[1]) - 0xDC00); # from perlunicode + my $bit = unpack('B32', pack('N', $uni)); + + if ( $bit =~ /^00000000000(...)(......)(......)(......)$/ ) { + my ($w, $x, $y, $z) = ($1, $2, $3, $4); + return pack('B*', sprintf('11110%s10%s10%s10%s', $w, $x, $y, $z)); + } + else { + Carp::croak("Invalid surrogate pair"); + } +} + + +sub _decode_unicode { + my ($u) = @_; + my ($utf8bit); + + if ( $u =~ /^00([89a-f][0-9a-f])$/i ) { # 0x80-0xff + return pack( 'H2', $1 ); + } + + my $bit = unpack("B*", pack("H*", $u)); + + if ( $bit =~ /^00000(.....)(......)$/ ) { + $utf8bit = sprintf('110%s10%s', $1, $2); + } + elsif ( $bit =~ /^(....)(......)(......)$/ ) { + $utf8bit = sprintf('1110%s10%s10%s', $1, $2, $3); + } + else { + Carp::croak("Invalid escaped unicode"); + } + + return pack('B*', $utf8bit); +} + + +sub JSON::PP::incr_text { + $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new; + + if ( $_[0]->{_incr_parser}->{incr_parsing} ) { + Carp::croak("incr_text can not be called when the incremental parser already started parsing"); + } + + $_[0]->{_incr_parser}->{incr_text} = $_[1] if ( @_ > 1 ); + $_[0]->{_incr_parser}->{incr_text}; +} + + +1; +__END__ + +=pod + +=head1 NAME + +JSON::PP5005 - Helper module in using JSON::PP in Perl 5.005 + +=head1 DESCRIPTION + +JSON::PP calls internally. + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2007-2012 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5006.pm b/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5006.pm new file mode 100644 index 0000000..7736fd8 --- /dev/null +++ b/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5006.pm @@ -0,0 +1,173 @@ +package # This is JSON::backportPP + JSON::backportPP56; + +use 5.006; +use strict; + +my @properties; + +$JSON::PP56::VERSION = '1.08'; + +BEGIN { + + sub utf8::is_utf8 { + my $len = length $_[0]; # char length + { + use bytes; # byte length; + return $len != length $_[0]; # if !=, UTF8-flagged on. + } + } + + + sub utf8::upgrade { + ; # noop; + } + + + sub utf8::downgrade ($;$) { + return 1 unless ( utf8::is_utf8( $_[0] ) ); + + if ( _is_valid_utf8( $_[0] ) ) { + my $downgrade; + for my $c ( unpack( "U*", $_[0] ) ) { + if ( $c < 256 ) { + $downgrade .= pack("C", $c); + } + else { + $downgrade .= pack("U", $c); + } + } + $_[0] = $downgrade; + return 1; + } + else { + Carp::croak("Wide character in subroutine entry") unless ( $_[1] ); + 0; + } + } + + + sub utf8::encode ($) { # UTF8 flag off + if ( utf8::is_utf8( $_[0] ) ) { + $_[0] = pack( "C*", unpack( "C*", $_[0] ) ); + } + else { + $_[0] = pack( "U*", unpack( "C*", $_[0] ) ); + $_[0] = pack( "C*", unpack( "C*", $_[0] ) ); + } + } + + + sub utf8::decode ($) { # UTF8 flag on + if ( _is_valid_utf8( $_[0] ) ) { + utf8::downgrade( $_[0] ); + $_[0] = pack( "U*", unpack( "U*", $_[0] ) ); + } + } + + + *JSON::PP::JSON_PP_encode_ascii = \&_encode_ascii; + *JSON::PP::JSON_PP_encode_latin1 = \&_encode_latin1; + *JSON::PP::JSON_PP_decode_surrogates = \&JSON::PP::_decode_surrogates; + *JSON::PP::JSON_PP_decode_unicode = \&JSON::PP::_decode_unicode; + + unless ( defined &B::SVp_NOK ) { # missing in B module. + eval q{ sub B::SVp_NOK () { 0x02000000; } }; + } + +} + + + +sub _encode_ascii { + join('', + map { + $_ <= 127 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', JSON::PP::_encode_surrogates($_)); + } _unpack_emu($_[0]) + ); +} + + +sub _encode_latin1 { + join('', + map { + $_ <= 255 ? + chr($_) : + $_ <= 65535 ? + sprintf('\u%04x', $_) : sprintf('\u%x\u%x', JSON::PP::_encode_surrogates($_)); + } _unpack_emu($_[0]) + ); +} + + +sub _unpack_emu { # for Perl 5.6 unpack warnings + return !utf8::is_utf8($_[0]) ? unpack('C*', $_[0]) + : _is_valid_utf8($_[0]) ? unpack('U*', $_[0]) + : unpack('C*', $_[0]); +} + + +sub _is_valid_utf8 { + my $str = $_[0]; + my $is_utf8; + + while ($str =~ /(?: + ( + [\x00-\x7F] + |[\xC2-\xDF][\x80-\xBF] + |[\xE0][\xA0-\xBF][\x80-\xBF] + |[\xE1-\xEC][\x80-\xBF][\x80-\xBF] + |[\xED][\x80-\x9F][\x80-\xBF] + |[\xEE-\xEF][\x80-\xBF][\x80-\xBF] + |[\xF0][\x90-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF] + |[\xF4][\x80-\x8F][\x80-\xBF][\x80-\xBF] + ) + | (.) + )/xg) + { + if (defined $1) { + $is_utf8 = 1 if (!defined $is_utf8); + } + else { + $is_utf8 = 0 if (!defined $is_utf8); + if ($is_utf8) { # eventually, not utf8 + return; + } + } + } + + return $is_utf8; +} + + +1; +__END__ + +=pod + +=head1 NAME + +JSON::PP56 - Helper module in using JSON::PP in Perl 5.6 + +=head1 DESCRIPTION + +JSON::PP calls internally. + +=head1 AUTHOR + +Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt> + + +=head1 COPYRIGHT AND LICENSE + +Copyright 2007-2012 by Makamaka Hannyaharamitu + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut + diff --git a/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/auto/JSON/.packlist b/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/auto/JSON/.packlist new file mode 100644 index 0000000..fa91737 --- /dev/null +++ b/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/auto/JSON/.packlist @@ -0,0 +1,14 @@ +/w/chr/src/third_party/JSON/out/lib/perl5/JSON.pm +/w/chr/src/third_party/JSON/out/lib/perl5/JSON/backportPP.pm +/w/chr/src/third_party/JSON/out/lib/perl5/JSON/backportPP/Boolean.pm +/w/chr/src/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5005.pm +/w/chr/src/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5006.pm +/w/chr/src/third_party/JSON/out/man/man3/JSON.3pm +/w/chr/src/third_party/JSON/out/man/man3/JSON::backportPP.3pm +/w/chr/src/third_party/JSON/out/man/man3/JSON::backportPP::Boolean.3pm +/w/chr/src/third_party/JSON/out/man/man3/JSON::backportPP::Compat5005.3pm +/w/chr/src/third_party/JSON/out/man/man3/JSON::backportPP::Compat5006.3pm +/w/chr/src/third_party/JSON/out/man/man3/JSON__backportPP.3pm +/w/chr/src/third_party/JSON/out/man/man3/JSON__backportPP__Boolean.3pm +/w/chr/src/third_party/JSON/out/man/man3/JSON__backportPP__Compat5005.3pm +/w/chr/src/third_party/JSON/out/man/man3/JSON__backportPP__Compat5006.3pm diff --git a/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/perllocal.pod b/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/perllocal.pod new file mode 100644 index 0000000..5df3e8a --- /dev/null +++ b/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/perllocal.pod @@ -0,0 +1,66 @@ +=head2 Sat Jun 8 20:25:57 2013: C<Module> L<JSON|JSON> + +=over 4 + +=item * + +C<installed into: /w/chr/src/third_party/JSON/out/lib/perl5> + +=item * + +C<LINKTYPE: dynamic> + +=item * + +C<VERSION: 2.59> + +=item * + +C<EXE_FILES: > + +=back + +=head2 Mon Jun 10 12:38:28 2013: C<Module> L<JSON|JSON> + +=over 4 + +=item * + +C<installed into: /w/chr/src/third_party/JSON/out/lib/perl5> + +=item * + +C<LINKTYPE: dynamic> + +=item * + +C<VERSION: 2.59> + +=item * + +C<EXE_FILES: > + +=back + +=head2 Mon Jun 10 12:40:36 2013: C<Module> L<JSON|JSON> + +=over 4 + +=item * + +C<installed into: /w/chr/src/third_party/JSON/out/lib/perl5> + +=item * + +C<LINKTYPE: dynamic> + +=item * + +C<VERSION: 2.59> + +=item * + +C<EXE_FILES: > + +=back + diff --git a/third_party/JSON/out/man/man3/JSON.3pm b/third_party/JSON/out/man/man3/JSON.3pm new file mode 100644 index 0000000..4a73a04 --- /dev/null +++ b/third_party/JSON/out/man/man3/JSON.3pm @@ -0,0 +1,1876 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON 3pm" +.TH JSON 3pm "2013-06-05" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON \- JSON (JavaScript Object Notation) encoder/decoder +.SH "SYNOPSIS" +.IX Header "SYNOPSIS" +.Vb 1 +\& use JSON; # imports encode_json, decode_json, to_json and from_json. +\& +\& # simple and fast interfaces (expect/generate UTF\-8) +\& +\& $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; +\& $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; +\& +\& # OO\-interface +\& +\& $json = JSON\->new\->allow_nonref; +\& +\& $json_text = $json\->encode( $perl_scalar ); +\& $perl_scalar = $json\->decode( $json_text ); +\& +\& $pretty_printed = $json\->pretty\->encode( $perl_scalar ); # pretty\-printing +\& +\& # If you want to use PP only support features, call with \*(Aq\-support_by_pp\*(Aq +\& # When XS unsupported feature is enable, using PP (de|en)code instead of XS ones. +\& +\& use JSON \-support_by_pp; +\& +\& # option\-acceptable interfaces (expect/generate UNICODE by default) +\& +\& $json_text = to_json( $perl_scalar, { ascii => 1, pretty => 1 } ); +\& $perl_scalar = from_json( $json_text, { utf8 => 1 } ); +\& +\& # Between (en|de)code_json and (to|from)_json, if you want to write +\& # a code which communicates to an outer world (encoded in UTF\-8), +\& # recommend to use (en|de)code_json. +.Ve +.SH "VERSION" +.IX Header "VERSION" +.Vb 1 +\& 2.59 +.Ve +.PP +This version is compatible with \s-1JSON::XS\s0 \fB2.34\fR and later. +.SH "NOTE" +.IX Header "NOTE" +\&\s-1JSON::PP\s0 was earlier included in the \f(CW\*(C`JSON\*(C'\fR distribution, but +has since Perl 5.14 been a core module. For this reason, +\&\s-1JSON::PP\s0 was removed from the \s-1JSON\s0 distribution and can now +be found also in the Perl5 repository at +.IP "\(bu" 4 +<http://perl5.git.perl.org/perl.git> +.PP +(The newest \s-1JSON::PP\s0 version still exists in \s-1CPAN\s0.) +.PP +Instead, the \f(CW\*(C`JSON\*(C'\fR distribution will include JSON::backportPP +for backwards computability. \s-1JSON\s0.pm should thus work as it did +before. +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +.Vb 6 +\& ************************** CAUTION ******************************** +\& * This is \*(AqJSON module version 2\*(Aq and there are many differences * +\& * to version 1.xx * +\& * Please check your applications using old version. * +\& * See to \*(AqINCOMPATIBLE CHANGES TO OLD VERSION\*(Aq * +\& ******************************************************************* +.Ve +.PP +\&\s-1JSON\s0 (JavaScript Object Notation) is a simple data format. +See to <http://www.json.org/> and \f(CW\*(C`RFC4627\*(C'\fR(<http://www.ietf.org/rfc/rfc4627.txt>). +.PP +This module converts Perl data structures to \s-1JSON\s0 and vice versa using either +\&\s-1JSON::XS\s0 or \s-1JSON::PP\s0. +.PP +\&\s-1JSON::XS\s0 is the fastest and most proper \s-1JSON\s0 module on \s-1CPAN\s0 which must be +compiled and installed in your environment. +\&\s-1JSON::PP\s0 is a pure-Perl module which is bundled in this distribution and +has a strong compatibility to \s-1JSON::XS\s0. +.PP +This module try to use \s-1JSON::XS\s0 by default and fail to it, use \s-1JSON::PP\s0 instead. +So its features completely depend on \s-1JSON::XS\s0 or \s-1JSON::PP\s0. +.PP +See to \*(L"\s-1BACKEND\s0 \s-1MODULE\s0 \s-1DECISION\s0\*(R". +.PP +To distinguish the module name '\s-1JSON\s0' and the format type \s-1JSON\s0, +the former is quoted by C<> (its results vary with your using media), +and the latter is left just as it is. +.PP +Module name : \f(CW\*(C`JSON\*(C'\fR +.PP +Format type : \s-1JSON\s0 +.SS "\s-1FEATURES\s0" +.IX Subsection "FEATURES" +.IP "\(bu" 4 +correct unicode handling +.Sp +This module (i.e. backend modules) knows how to handle Unicode, documents +how and when it does so, and even documents what \*(L"correct\*(R" means. +.Sp +Even though there are limitations, this feature is available since Perl version 5.6. +.Sp +\&\s-1JSON::XS\s0 requires Perl 5.8.2 (but works correctly in 5.8.8 or later), so in older versions +\&\f(CW\*(C`JSON\*(C'\fR should call \s-1JSON::PP\s0 as the backend which can be used since Perl 5.005. +.Sp +With Perl 5.8.x \s-1JSON::PP\s0 works, but from 5.8.0 to 5.8.2, because of a Perl side problem, +\&\s-1JSON::PP\s0 works slower in the versions. And in 5.005, the Unicode handling is not available. +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R" in \s-1JSON::PP\s0 for more information. +.Sp +See also to \*(L"A \s-1FEW\s0 \s-1NOTES\s0 \s-1ON\s0 \s-1UNICODE\s0 \s-1AND\s0 \s-1PERL\s0\*(R" in \s-1JSON::XS\s0 +and \*(L"\s-1ENCODING/CODESET_FLAG_NOTES\s0\*(R" in \s-1JSON::XS\s0. +.IP "\(bu" 4 +round-trip integrity +.Sp +When you serialise a perl data structure using only data types supported +by \s-1JSON\s0 and Perl, the deserialised data structure is identical on the Perl +level. (e.g. the string \*(L"2.0\*(R" doesn't suddenly become \*(L"2\*(R" just because +it looks like a number). There \fIare\fR minor exceptions to this, read the +\&\*(L"\s-1MAPPING\s0\*(R" section below to learn about those. +.IP "\(bu" 4 +strict checking of \s-1JSON\s0 correctness +.Sp +There is no guessing, no generating of illegal \s-1JSON\s0 texts by default, +and only \s-1JSON\s0 is accepted as input by default (the latter is a security +feature). +.Sp +See to \*(L"\s-1FEATURES\s0\*(R" in \s-1JSON::XS\s0 and \*(L"\s-1FEATURES\s0\*(R" in \s-1JSON::PP\s0. +.IP "\(bu" 4 +fast +.Sp +This module returns a \s-1JSON::XS\s0 object itself if available. +Compared to other \s-1JSON\s0 modules and other serialisers such as Storable, +\&\s-1JSON::XS\s0 usually compares favorably in terms of speed, too. +.Sp +If not available, \f(CW\*(C`JSON\*(C'\fR returns a \s-1JSON::PP\s0 object instead of \s-1JSON::XS\s0 and +it is very slow as pure-Perl. +.IP "\(bu" 4 +simple to use +.Sp +This module has both a simple functional interface as well as an +object oriented interface interface. +.IP "\(bu" 4 +reasonably versatile output formats +.Sp +You can choose between the most compact guaranteed-single-line format possible +(nice for simple line-based protocols), a pure-ASCII format (for when your transport +is not 8\-bit clean, still supports the whole Unicode range), or a pretty-printed +format (for when you want to read that stuff). Or you can combine those features +in whatever way you like. +.SH "FUNCTIONAL INTERFACE" +.IX Header "FUNCTIONAL INTERFACE" +Some documents are copied and modified from \*(L"\s-1FUNCTIONAL\s0 \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0. +\&\f(CW\*(C`to_json\*(C'\fR and \f(CW\*(C`from_json\*(C'\fR are additional functions. +.SS "encode_json" +.IX Subsection "encode_json" +.Vb 1 +\& $json_text = encode_json $perl_scalar +.Ve +.PP +Converts the given Perl data structure to a \s-1UTF\-8\s0 encoded, binary string. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $json_text = JSON\->new\->utf8\->encode($perl_scalar) +.Ve +.SS "decode_json" +.IX Subsection "decode_json" +.Vb 1 +\& $perl_scalar = decode_json $json_text +.Ve +.PP +The opposite of \f(CW\*(C`encode_json\*(C'\fR: expects an \s-1UTF\-8\s0 (binary) string and tries +to parse that as an \s-1UTF\-8\s0 encoded \s-1JSON\s0 text, returning the resulting +reference. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $perl_scalar = JSON\->new\->utf8\->decode($json_text) +.Ve +.SS "to_json" +.IX Subsection "to_json" +.Vb 1 +\& $json_text = to_json($perl_scalar) +.Ve +.PP +Converts the given Perl data structure to a json string. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $json_text = JSON\->new\->encode($perl_scalar) +.Ve +.PP +Takes a hash reference as the second. +.PP +.Vb 1 +\& $json_text = to_json($perl_scalar, $flag_hashref) +.Ve +.PP +So, +.PP +.Vb 1 +\& $json_text = to_json($perl_scalar, {utf8 => 1, pretty => 1}) +.Ve +.PP +equivalent to: +.PP +.Vb 1 +\& $json_text = JSON\->new\->utf8(1)\->pretty(1)\->encode($perl_scalar) +.Ve +.PP +If you want to write a modern perl code which communicates to outer world, +you should use \f(CW\*(C`encode_json\*(C'\fR (supposed that \s-1JSON\s0 data are encoded in \s-1UTF\-8\s0). +.SS "from_json" +.IX Subsection "from_json" +.Vb 1 +\& $perl_scalar = from_json($json_text) +.Ve +.PP +The opposite of \f(CW\*(C`to_json\*(C'\fR: expects a json string and tries +to parse it, returning the resulting reference. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $perl_scalar = JSON\->decode($json_text) +.Ve +.PP +Takes a hash reference as the second. +.PP +.Vb 1 +\& $perl_scalar = from_json($json_text, $flag_hashref) +.Ve +.PP +So, +.PP +.Vb 1 +\& $perl_scalar = from_json($json_text, {utf8 => 1}) +.Ve +.PP +equivalent to: +.PP +.Vb 1 +\& $perl_scalar = JSON\->new\->utf8(1)\->decode($json_text) +.Ve +.PP +If you want to write a modern perl code which communicates to outer world, +you should use \f(CW\*(C`decode_json\*(C'\fR (supposed that \s-1JSON\s0 data are encoded in \s-1UTF\-8\s0). +.SS "JSON::is_bool" +.IX Subsection "JSON::is_bool" +.Vb 1 +\& $is_boolean = JSON::is_bool($scalar) +.Ve +.PP +Returns true if the passed scalar represents either JSON::true or +JSON::false, two constants that act like \f(CW1\fR and \f(CW0\fR respectively +and are also used to represent \s-1JSON\s0 \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR in Perl strings. +.SS "JSON::true" +.IX Subsection "JSON::true" +Returns \s-1JSON\s0 true value which is blessed object. +It \f(CW\*(C`isa\*(C'\fR JSON::Boolean object. +.SS "JSON::false" +.IX Subsection "JSON::false" +Returns \s-1JSON\s0 false value which is blessed object. +It \f(CW\*(C`isa\*(C'\fR JSON::Boolean object. +.SS "JSON::null" +.IX Subsection "JSON::null" +Returns \f(CW\*(C`undef\*(C'\fR. +.PP +See \s-1MAPPING\s0, below, for more information on how \s-1JSON\s0 values are mapped to +Perl. +.SH "HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER" +.IX Header "HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER" +This section supposes that your perl version is 5.8 or later. +.PP +If you know a \s-1JSON\s0 text from an outer world \- a network, a file content, and so on, +is encoded in \s-1UTF\-8\s0, you should use \f(CW\*(C`decode_json\*(C'\fR or \f(CW\*(C`JSON\*(C'\fR module object +with \f(CW\*(C`utf8\*(C'\fR enable. And the decoded result will contain \s-1UNICODE\s0 characters. +.PP +.Vb 4 +\& # from network +\& my $json = JSON\->new\->utf8; +\& my $json_text = CGI\->new\->param( \*(Aqjson_data\*(Aq ); +\& my $perl_scalar = $json\->decode( $json_text ); +\& +\& # from file content +\& local $/; +\& open( my $fh, \*(Aq<\*(Aq, \*(Aqjson.data\*(Aq ); +\& $json_text = <$fh>; +\& $perl_scalar = decode_json( $json_text ); +.Ve +.PP +If an outer data is not encoded in \s-1UTF\-8\s0, firstly you should \f(CW\*(C`decode\*(C'\fR it. +.PP +.Vb 5 +\& use Encode; +\& local $/; +\& open( my $fh, \*(Aq<\*(Aq, \*(Aqjson.data\*(Aq ); +\& my $encoding = \*(Aqcp932\*(Aq; +\& my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE +\& +\& # or you can write the below code. +\& # +\& # open( my $fh, "<:encoding($encoding)", \*(Aqjson.data\*(Aq ); +\& # $unicode_json_text = <$fh>; +.Ve +.PP +In this case, \f(CW$unicode_json_text\fR is of course \s-1UNICODE\s0 string. +So you \fBcannot\fR use \f(CW\*(C`decode_json\*(C'\fR nor \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +Instead of them, you use \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR disable or \f(CW\*(C`from_json\*(C'\fR. +.PP +.Vb 3 +\& $perl_scalar = $json\->utf8(0)\->decode( $unicode_json_text ); +\& # or +\& $perl_scalar = from_json( $unicode_json_text ); +.Ve +.PP +Or \f(CW\*(C`encode \*(Aqutf8\*(Aq\*(C'\fR and \f(CW\*(C`decode_json\*(C'\fR: +.PP +.Vb 2 +\& $perl_scalar = decode_json( encode( \*(Aqutf8\*(Aq, $unicode_json_text ) ); +\& # this way is not efficient. +.Ve +.PP +And now, you want to convert your \f(CW$perl_scalar\fR into \s-1JSON\s0 data and +send it to an outer world \- a network or a file content, and so on. +.PP +Your data usually contains \s-1UNICODE\s0 strings and you want the converted data to be encoded +in \s-1UTF\-8\s0, you should use \f(CW\*(C`encode_json\*(C'\fR or \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +.PP +.Vb 3 +\& print encode_json( $perl_scalar ); # to a network? file? or display? +\& # or +\& print $json\->utf8\->encode( $perl_scalar ); +.Ve +.PP +If \f(CW$perl_scalar\fR does not contain \s-1UNICODE\s0 but \f(CW$encoding\fR\-encoded strings +for some reason, then its characters are regarded as \fBlatin1\fR for perl +(because it does not concern with your \f(CW$encoding\fR). +You \fBcannot\fR use \f(CW\*(C`encode_json\*(C'\fR nor \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +Instead of them, you use \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR disable or \f(CW\*(C`to_json\*(C'\fR. +Note that the resulted text is a \s-1UNICODE\s0 string but no problem to print it. +.PP +.Vb 6 +\& # $perl_scalar contains $encoding encoded string values +\& $unicode_json_text = $json\->utf8(0)\->encode( $perl_scalar ); +\& # or +\& $unicode_json_text = to_json( $perl_scalar ); +\& # $unicode_json_text consists of characters less than 0x100 +\& print $unicode_json_text; +.Ve +.PP +Or \f(CW\*(C`decode $encoding\*(C'\fR all string values and \f(CW\*(C`encode_json\*(C'\fR: +.PP +.Vb 3 +\& $perl_scalar\->{ foo } = decode( $encoding, $perl_scalar\->{ foo } ); +\& # ... do it to each string values, then encode_json +\& $json_text = encode_json( $perl_scalar ); +.Ve +.PP +This method is a proper way but probably not efficient. +.PP +See to Encode, perluniintro. +.SH "COMMON OBJECT-ORIENTED INTERFACE" +.IX Header "COMMON OBJECT-ORIENTED INTERFACE" +.SS "new" +.IX Subsection "new" +.Vb 1 +\& $json = JSON\->new +.Ve +.PP +Returns a new \f(CW\*(C`JSON\*(C'\fR object inherited from either \s-1JSON::XS\s0 or \s-1JSON::PP\s0 +that can be used to de/encode \s-1JSON\s0 strings. +.PP +All boolean flags described below are by default \fIdisabled\fR. +.PP +The mutators for flags all return the \s-1JSON\s0 object again and thus calls can +be chained: +.PP +.Vb 2 +\& my $json = JSON\->new\->utf8\->space_after\->encode({a => [1,2]}) +\& => {"a": [1, 2]} +.Ve +.SS "ascii" +.IX Subsection "ascii" +.Vb 1 +\& $json = $json\->ascii([$enable]) +\& +\& $enabled = $json\->get_ascii +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \euXXXX or a double \euHHHH\euLLLLL escape sequence, as per \s-1RFC4627\s0. +.PP +If \f(CW$enable\fR is false, then the encode method will not escape Unicode characters unless +required by the \s-1JSON\s0 syntax or other flags. This results in a faster and more compact format. +.PP +This feature depends on the used Perl version and environment. +.PP +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R" in \s-1JSON::PP\s0 if the backend is \s-1PP\s0. +.PP +.Vb 2 +\& JSON\->new\->ascii(1)\->encode([chr 0x10401]) +\& => ["\eud801\eudc01"] +.Ve +.SS "latin1" +.IX Subsection "latin1" +.Vb 1 +\& $json = $json\->latin1([$enable]) +\& +\& $enabled = $json\->get_latin1 +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will encode the resulting \s-1JSON\s0 +text as latin1 (or iso\-8859\-1), escaping any characters outside the code range 0..255. +.PP +If \f(CW$enable\fR is false, then the encode method will not escape Unicode characters +unless required by the \s-1JSON\s0 syntax or other flags. +.PP +.Vb 2 +\& JSON\->new\->latin1\->encode (["\ex{89}\ex{abc}"] +\& => ["\ex{89}\e\eu0abc"] # (perl syntax, U+abc escaped, U+89 not) +.Ve +.SS "utf8" +.IX Subsection "utf8" +.Vb 1 +\& $json = $json\->utf8([$enable]) +\& +\& $enabled = $json\->get_utf8 +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will encode the \s-1JSON\s0 result +into \s-1UTF\-8\s0, as required by many protocols, while the decode method expects to be handled +an UTF\-8\-encoded string. Please note that UTF\-8\-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. +.PP +In future versions, enabling this option might enable autodetection of the \s-1UTF\-16\s0 and \s-1UTF\-32\s0 +encoding families, as described in \s-1RFC4627\s0. +.PP +If \f(CW$enable\fR is false, then the encode method will return the \s-1JSON\s0 string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to \s-1UTF\-8\s0 or \s-1UTF\-16\s0) needs to be done yourself, e.g. using the Encode module. +.PP +Example, output UTF\-16BE\-encoded \s-1JSON:\s0 +.PP +.Vb 2 +\& use Encode; +\& $jsontext = encode "UTF\-16BE", JSON::XS\->new\->encode ($object); +.Ve +.PP +Example, decode UTF\-32LE\-encoded \s-1JSON:\s0 +.PP +.Vb 2 +\& use Encode; +\& $object = JSON::XS\->new\->decode (decode "UTF\-32LE", $jsontext); +.Ve +.PP +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R" in \s-1JSON::PP\s0 if the backend is \s-1PP\s0. +.SS "pretty" +.IX Subsection "pretty" +.Vb 1 +\& $json = $json\->pretty([$enable]) +.Ve +.PP +This enables (or disables) all of the \f(CW\*(C`indent\*(C'\fR, \f(CW\*(C`space_before\*(C'\fR and +\&\f(CW\*(C`space_after\*(C'\fR (and in the future possibly more) flags in one call to +generate the most readable (or most compact) form possible. +.PP +Equivalent to: +.PP +.Vb 1 +\& $json\->indent\->space_before\->space_after +.Ve +.PP +The indent space length is three and \s-1JSON::XS\s0 cannot change the indent +space length. +.SS "indent" +.IX Subsection "indent" +.Vb 1 +\& $json = $json\->indent([$enable]) +\& +\& $enabled = $json\->get_indent +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will use a multiline +format as output, putting every array member or object/hash key-value pair +into its own line, identifying them properly. +.PP +If \f(CW$enable\fR is false, no newlines or indenting will be produced, and the +resulting \s-1JSON\s0 text is guaranteed not to contain any \f(CW\*(C`newlines\*(C'\fR. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +The indent space length is three. +With \s-1JSON::PP\s0, you can also access \f(CW\*(C`indent_length\*(C'\fR to change indent space length. +.SS "space_before" +.IX Subsection "space_before" +.Vb 1 +\& $json = $json\->space_before([$enable]) +\& +\& $enabled = $json\->get_space_before +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will add an extra +optional space before the \f(CW\*(C`:\*(C'\fR separating keys from values in \s-1JSON\s0 objects. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will not add any extra +space at those places. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +Example, space_before enabled, space_after and indent disabled: +.PP +.Vb 1 +\& {"key" :"value"} +.Ve +.SS "space_after" +.IX Subsection "space_after" +.Vb 1 +\& $json = $json\->space_after([$enable]) +\& +\& $enabled = $json\->get_space_after +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will add an extra +optional space after the \f(CW\*(C`:\*(C'\fR separating keys from values in \s-1JSON\s0 objects +and extra whitespace after the \f(CW\*(C`,\*(C'\fR separating key-value pairs and array +members. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will not add any extra +space at those places. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +Example, space_before and indent disabled, space_after enabled: +.PP +.Vb 1 +\& {"key": "value"} +.Ve +.SS "relaxed" +.IX Subsection "relaxed" +.Vb 1 +\& $json = $json\->relaxed([$enable]) +\& +\& $enabled = $json\->get_relaxed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept some +extensions to normal \s-1JSON\s0 syntax (see below). \f(CW\*(C`encode\*(C'\fR will not be +affected in anyway. \fIBe aware that this option makes you accept invalid +\&\s-1JSON\s0 texts as if they were valid!\fR. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) +.PP +If \f(CW$enable\fR is false (the default), then \f(CW\*(C`decode\*(C'\fR will only accept +valid \s-1JSON\s0 texts. +.PP +Currently accepted extensions are: +.IP "\(bu" 4 +list items can have an end-comma +.Sp +\&\s-1JSON\s0 \fIseparates\fR array elements and key-value pairs with commas. This +can be annoying if you write \s-1JSON\s0 texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: +.Sp +.Vb 8 +\& [ +\& 1, +\& 2, <\- this comma not normally allowed +\& ] +\& { +\& "k1": "v1", +\& "k2": "v2", <\- this comma not normally allowed +\& } +.Ve +.IP "\(bu" 4 +shell-style '#'\-comments +.Sp +Whenever \s-1JSON\s0 allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. +.Sp +.Vb 4 +\& [ +\& 1, # this comment not allowed in JSON +\& # neither this one... +\& ] +.Ve +.SS "canonical" +.IX Subsection "canonical" +.Vb 1 +\& $json = $json\->canonical([$enable]) +\& +\& $enabled = $json\->get_canonical +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will output \s-1JSON\s0 objects +by sorting their keys. This is adding a comparatively high overhead. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). +.PP +This option is useful if you want the same data structure to be encoded as +the same \s-1JSON\s0 text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.SS "allow_nonref" +.IX Subsection "allow_nonref" +.Vb 1 +\& $json = $json\->allow_nonref([$enable]) +\& +\& $enabled = $json\->get_allow_nonref +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method can convert a +non-reference into its corresponding string, number or null \s-1JSON\s0 value, +which is an extension to \s-1RFC4627\s0. Likewise, \f(CW\*(C`decode\*(C'\fR will accept those \s-1JSON\s0 +values instead of croaking. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will croak if it isn't +passed an arrayref or hashref, as \s-1JSON\s0 texts must either be an object +or array. Likewise, \f(CW\*(C`decode\*(C'\fR will croak if given something that is not a +\&\s-1JSON\s0 object or array. +.PP +.Vb 2 +\& JSON\->new\->allow_nonref\->encode ("Hello, World!") +\& => "Hello, World!" +.Ve +.SS "allow_unknown" +.IX Subsection "allow_unknown" +.Vb 1 +\& $json = $json\->allow_unknown ([$enable]) +\& +\& $enabled = $json\->get_allow_unknown +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \*(L"encode\*(R" will *not* throw an +exception when it encounters values it cannot represent in \s-1JSON\s0 (for +example, filehandles) but instead will encode a \s-1JSON\s0 \*(L"null\*(R" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. +.PP +If \f(CW$enable\fR is false (the default), then \*(L"encode\*(R" will throw an +exception when it encounters anything it cannot encode as \s-1JSON\s0. +.PP +This option does not affect \*(L"decode\*(R" in any way, and it is +recommended to leave it off unless you know your communications +partner. +.SS "allow_blessed" +.IX Subsection "allow_blessed" +.Vb 1 +\& $json = $json\->allow_blessed([$enable]) +\& +\& $enabled = $json\->get_allow_blessed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will not +barf when it encounters a blessed reference. Instead, the value of the +\&\fBconvert_blessed\fR option will decide whether \f(CW\*(C`null\*(C'\fR (\f(CW\*(C`convert_blessed\*(C'\fR +disabled or no \f(CW\*(C`TO_JSON\*(C'\fR method found) or a representation of the +object (\f(CW\*(C`convert_blessed\*(C'\fR enabled and \f(CW\*(C`TO_JSON\*(C'\fR method found) is being +encoded. Has no effect on \f(CW\*(C`decode\*(C'\fR. +.PP +If \f(CW$enable\fR is false (the default), then \f(CW\*(C`encode\*(C'\fR will throw an +exception when it encounters a blessed object. +.SS "convert_blessed" +.IX Subsection "convert_blessed" +.Vb 1 +\& $json = $json\->convert_blessed([$enable]) +\& +\& $enabled = $json\->get_convert_blessed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`encode\*(C'\fR, upon encountering a +blessed object, will check for the availability of the \f(CW\*(C`TO_JSON\*(C'\fR method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +\&\f(CW\*(C`TO_JSON\*(C'\fR method is found, the value of \f(CW\*(C`allow_blessed\*(C'\fR will decide what +to do. +.PP +The \f(CW\*(C`TO_JSON\*(C'\fR method may safely call die if it wants. If \f(CW\*(C`TO_JSON\*(C'\fR +returns other blessed objects, those will be handled in the same +way. \f(CW\*(C`TO_JSON\*(C'\fR must take care of not causing an endless recursion cycle +(== crash) in this case. The name of \f(CW\*(C`TO_JSON\*(C'\fR was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the \f(CW\*(C`to_json\*(C'\fR +function or method. +.PP +This setting does not yet influence \f(CW\*(C`decode\*(C'\fR in any way. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`allow_blessed\*(C'\fR setting will decide what +to do when a blessed object is found. +.IP "convert_blessed_universally mode" 4 +.IX Item "convert_blessed_universally mode" +If use \f(CW\*(C`JSON\*(C'\fR with \f(CW\*(C`\-convert_blessed_universally\*(C'\fR, the \f(CW\*(C`UNIVERSAL::TO_JSON\*(C'\fR +subroutine is defined as the below code: +.Sp +.Vb 7 +\& *UNIVERSAL::TO_JSON = sub { +\& my $b_obj = B::svref_2object( $_[0] ); +\& return $b_obj\->isa(\*(AqB::HV\*(Aq) ? { %{ $_[0] } } +\& : $b_obj\->isa(\*(AqB::AV\*(Aq) ? [ @{ $_[0] } ] +\& : undef +\& ; +\& } +.Ve +.Sp +This will cause that \f(CW\*(C`encode\*(C'\fR method converts simple blessed objects into +\&\s-1JSON\s0 objects as non-blessed object. +.Sp +.Vb 2 +\& JSON \-convert_blessed_universally; +\& $json\->allow_blessed\->convert_blessed\->encode( $blessed_object ) +.Ve +.Sp +This feature is experimental and may be removed in the future. +.SS "filter_json_object" +.IX Subsection "filter_json_object" +.Vb 1 +\& $json = $json\->filter_json_object([$coderef]) +.Ve +.PP +When \f(CW$coderef\fR is specified, it will be called from \f(CW\*(C`decode\*(C'\fR each +time it decodes a \s-1JSON\s0 object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(\s-1NOTE:\s0 \fInot\fR \f(CW\*(C`undef\*(C'\fR, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. +.PP +When \f(CW$coderef\fR is omitted or undefined, any existing callback will +be removed and \f(CW\*(C`decode\*(C'\fR will not change the deserialised hash in any +way. +.PP +Example, convert all \s-1JSON\s0 objects into the integer 5: +.PP +.Vb 6 +\& my $js = JSON\->new\->filter_json_object (sub { 5 }); +\& # returns [5] +\& $js\->decode (\*(Aq[{}]\*(Aq); # the given subroutine takes a hash reference. +\& # throw an exception because allow_nonref is not enabled +\& # so a lone 5 is not allowed. +\& $js\->decode (\*(Aq{"a":1, "b":2}\*(Aq); +.Ve +.SS "filter_json_single_key_object" +.IX Subsection "filter_json_single_key_object" +.Vb 1 +\& $json = $json\->filter_json_single_key_object($key [=> $coderef]) +.Ve +.PP +Works remotely similar to \f(CW\*(C`filter_json_object\*(C'\fR, but is only called for +\&\s-1JSON\s0 objects having a single key named \f(CW$key\fR. +.PP +This \f(CW$coderef\fR is called before the one specified via +\&\f(CW\*(C`filter_json_object\*(C'\fR, if any. It gets passed the single value in the \s-1JSON\s0 +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even \f(CW\*(C`undef\*(C'\fR but the empty list), +the callback from \f(CW\*(C`filter_json_object\*(C'\fR will be called next, as if no +single-key callback were specified. +.PP +If \f(CW$coderef\fR is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. +.PP +As this callback gets called less often then the \f(CW\*(C`filter_json_object\*(C'\fR +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key \s-1JSON\s0 objects are as close to the type-tagged value concept +as \s-1JSON\s0 gets (it's basically an \s-1ID/VALUE\s0 tuple). Of course, \s-1JSON\s0 does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. +.PP +Typical names for the single object key are \f(CW\*(C`_\|_class_whatever_\|_\*(C'\fR, or +\&\f(CW\*(C`$_\|_dollars_are_rarely_used_\|_$\*(C'\fR or \f(CW\*(C`}ugly_brace_placement\*(C'\fR, or even +things like \f(CW\*(C`_\|_class_md5sum(classname)_\|_\*(C'\fR, to reduce the risk of clashing +with real hashes. +.PP +Example, decode \s-1JSON\s0 objects of the form \f(CW\*(C`{ "_\|_widget_\|_" => <id> }\*(C'\fR +into the corresponding \f(CW$WIDGET{<id>}\fR object: +.PP +.Vb 7 +\& # return whatever is in $WIDGET{5}: +\& JSON +\& \->new +\& \->filter_json_single_key_object (_\|_widget_\|_ => sub { +\& $WIDGET{ $_[0] } +\& }) +\& \->decode (\*(Aq{"_\|_widget_\|_": 5\*(Aq) +\& +\& # this can be used with a TO_JSON method in some "widget" class +\& # for serialisation to json: +\& sub WidgetBase::TO_JSON { +\& my ($self) = @_; +\& +\& unless ($self\->{id}) { +\& $self\->{id} = ..get..some..id..; +\& $WIDGET{$self\->{id}} = $self; +\& } +\& +\& { _\|_widget_\|_ => $self\->{id} } +\& } +.Ve +.SS "shrink" +.IX Subsection "shrink" +.Vb 1 +\& $json = $json\->shrink([$enable]) +\& +\& $enabled = $json\->get_shrink +.Ve +.PP +With \s-1JSON::XS\s0, this flag resizes strings generated by either +\&\f(CW\*(C`encode\*(C'\fR or \f(CW\*(C`decode\*(C'\fR to their minimum size possible. This can save +memory when your \s-1JSON\s0 texts are either very very long or you have many +short strings. It will also try to downgrade any strings to octet-form +if possible: perl stores strings internally either in an encoding called +UTF-X or in octet-form. The latter cannot store everything but uses less +space in general (and some buggy Perl or C code might even rely on that +internal representation being used). +.PP +With \s-1JSON::PP\s0, it is noop about resizing strings but tries +\&\f(CW\*(C`utf8::downgrade\*(C'\fR to the returned string by \f(CW\*(C`encode\*(C'\fR. See to utf8. +.PP +See to \*(L"OBJECT-ORIENTED \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0 and \*(L"\s-1METHODS\s0\*(R" in \s-1JSON::PP\s0. +.SS "max_depth" +.IX Subsection "max_depth" +.Vb 1 +\& $json = $json\->max_depth([$maximum_nesting_depth]) +\& +\& $max_depth = $json\->get_max_depth +.Ve +.PP +Sets the maximum nesting level (default \f(CW512\fR) accepted while encoding +or decoding. If a higher nesting level is detected in \s-1JSON\s0 text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. +.PP +Nesting level is defined by number of hash\- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of \f(CW\*(C`{\*(C'\fR or \f(CW\*(C`[\*(C'\fR +characters without their matching closing parenthesis crossed to reach a +given character in a string. +.PP +If no argument is given, the highest possible setting will be used, which +is rarely useful. +.PP +Note that nesting is implemented by recursion in C. The default value has +been chosen to be as large as typical operating systems allow without +crashing. (\s-1JSON::XS\s0) +.PP +With \s-1JSON::PP\s0 as the backend, when a large value (100 or more) was set and +it de/encodes a deep nested object/text, it may raise a warning +\&'Deep recursion on subroutine' at the perl runtime phase. +.PP +See \*(L"\s-1SECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0 for more info on why this is useful. +.SS "max_size" +.IX Subsection "max_size" +.Vb 1 +\& $json = $json\->max_size([$maximum_string_size]) +\& +\& $max_size = $json\->get_max_size +.Ve +.PP +Set the maximum length a \s-1JSON\s0 text may have (in bytes) where decoding is +being attempted. The default is \f(CW0\fR, meaning no limit. When \f(CW\*(C`decode\*(C'\fR +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on \f(CW\*(C`encode\*(C'\fR (yet). +.PP +If no argument is given, the limit check will be deactivated (same as when +\&\f(CW0\fR is specified). +.PP +See \*(L"\s-1SECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0, below, for more info on why this is useful. +.SS "encode" +.IX Subsection "encode" +.Vb 1 +\& $json_text = $json\->encode($perl_scalar) +.Ve +.PP +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its \s-1JSON\s0 representation. Simple scalars will be +converted into \s-1JSON\s0 string or number sequences, while references to arrays +become \s-1JSON\s0 arrays and references to hashes become \s-1JSON\s0 objects. Undefined +Perl values (e.g. \f(CW\*(C`undef\*(C'\fR) become \s-1JSON\s0 \f(CW\*(C`null\*(C'\fR values. +References to the integers \f(CW0\fR and \f(CW1\fR are converted into \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR. +.SS "decode" +.IX Subsection "decode" +.Vb 1 +\& $perl_scalar = $json\->decode($json_text) +.Ve +.PP +The opposite of \f(CW\*(C`encode\*(C'\fR: expects a \s-1JSON\s0 text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. +.PP +\&\s-1JSON\s0 numbers and strings become simple Perl scalars. \s-1JSON\s0 arrays become +Perl arrayrefs and \s-1JSON\s0 objects become Perl hashrefs. \f(CW\*(C`true\*(C'\fR becomes +\&\f(CW1\fR (\f(CW\*(C`JSON::true\*(C'\fR), \f(CW\*(C`false\*(C'\fR becomes \f(CW0\fR (\f(CW\*(C`JSON::false\*(C'\fR) and +\&\f(CW\*(C`null\*(C'\fR becomes \f(CW\*(C`undef\*(C'\fR. +.SS "decode_prefix" +.IX Subsection "decode_prefix" +.Vb 1 +\& ($perl_scalar, $characters) = $json\->decode_prefix($json_text) +.Ve +.PP +This works like the \f(CW\*(C`decode\*(C'\fR method, but instead of raising an exception +when there is trailing garbage after the first \s-1JSON\s0 object, it will +silently stop parsing there and return the number of characters consumed +so far. +.PP +.Vb 2 +\& JSON\->new\->decode_prefix ("[1] the tail") +\& => ([], 3) +.Ve +.PP +See to \*(L"OBJECT-ORIENTED \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0 +.SS "property" +.IX Subsection "property" +.Vb 1 +\& $boolean = $json\->property($property_name) +.Ve +.PP +Returns a boolean value about above some properties. +.PP +The available properties are \f(CW\*(C`ascii\*(C'\fR, \f(CW\*(C`latin1\*(C'\fR, \f(CW\*(C`utf8\*(C'\fR, +\&\f(CW\*(C`indent\*(C'\fR,\f(CW\*(C`space_before\*(C'\fR, \f(CW\*(C`space_after\*(C'\fR, \f(CW\*(C`relaxed\*(C'\fR, \f(CW\*(C`canonical\*(C'\fR, +\&\f(CW\*(C`allow_nonref\*(C'\fR, \f(CW\*(C`allow_unknown\*(C'\fR, \f(CW\*(C`allow_blessed\*(C'\fR, \f(CW\*(C`convert_blessed\*(C'\fR, +\&\f(CW\*(C`shrink\*(C'\fR, \f(CW\*(C`max_depth\*(C'\fR and \f(CW\*(C`max_size\*(C'\fR. +.PP +.Vb 5 +\& $boolean = $json\->property(\*(Aqutf8\*(Aq); +\& => 0 +\& $json\->utf8; +\& $boolean = $json\->property(\*(Aqutf8\*(Aq); +\& => 1 +.Ve +.PP +Sets the property with a given boolean value. +.PP +.Vb 1 +\& $json = $json\->property($property_name => $boolean); +.Ve +.PP +With no argument, it returns all the above properties as a hash reference. +.PP +.Vb 1 +\& $flag_hashref = $json\->property(); +.Ve +.SH "INCREMENTAL PARSING" +.IX Header "INCREMENTAL PARSING" +Most of this section are copied and modified from \*(L"\s-1INCREMENTAL\s0 \s-1PARSING\s0\*(R" in \s-1JSON::XS\s0. +.PP +In some cases, there is the need for incremental parsing of \s-1JSON\s0 texts. +This module does allow you to parse a \s-1JSON\s0 stream incrementally. +It does so by accumulating text until it has a full \s-1JSON\s0 object, which +it then can decode. This process is similar to using \f(CW\*(C`decode_prefix\*(C'\fR +to see if a full \s-1JSON\s0 object is available, but is much more efficient +(and can be implemented with a minimum of method calls). +.PP +The backend module will only attempt to parse the \s-1JSON\s0 text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid \s-1JSON\s0 text has been seen. This means you need +to set resource limits (e.g. \f(CW\*(C`max_size\*(C'\fR) to ensure the parser will stop +parsing in the presence if syntax errors. +.PP +The following methods implement this incremental parser. +.SS "incr_parse" +.IX Subsection "incr_parse" +.Vb 1 +\& $json\->incr_parse( [$string] ) # void context +\& +\& $obj_or_undef = $json\->incr_parse( [$string] ) # scalar context +\& +\& @obj_or_empty = $json\->incr_parse( [$string] ) # list context +.Ve +.PP +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). +.PP +If \f(CW$string\fR is given, then this string is appended to the already +existing \s-1JSON\s0 fragment stored in the \f(CW$json\fR object. +.PP +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. +.PP +If the method is called in scalar context, then it will try to extract +exactly \fIone\fR \s-1JSON\s0 object. If that is successful, it will return this +object, otherwise it will return \f(CW\*(C`undef\*(C'\fR. If there is a parse error, +this method will croak just as \f(CW\*(C`decode\*(C'\fR would do (one can then use +\&\f(CW\*(C`incr_skip\*(C'\fR to skip the erroneous part). This is the most common way of +using the method. +.PP +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the \s-1JSON\s0 +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed \s-1JSON\s0 texts will be +lost. +.PP +Example: Parse some \s-1JSON\s0 arrays/objects in a given string and return them. +.PP +.Vb 1 +\& my @objs = JSON\->new\->incr_parse ("[5][7][1,2]"); +.Ve +.SS "incr_text" +.IX Subsection "incr_text" +.Vb 1 +\& $lvalue_string = $json\->incr_text +.Ve +.PP +This method returns the currently stored \s-1JSON\s0 fragment as an lvalue, that +is, you can manipulate it. This \fIonly\fR works when a preceding call to +\&\f(CW\*(C`incr_parse\*(C'\fR in \fIscalar context\fR successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it \fIwill\fR fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. +.PP +This function is useful in two cases: a) finding the trailing text after a +\&\s-1JSON\s0 object or b) parsing multiple \s-1JSON\s0 objects separated by non-JSON text +(such as commas). +.PP +.Vb 1 +\& $json\->incr_text =~ s/\es*,\es*//; +.Ve +.PP +In Perl 5.005, \f(CW\*(C`lvalue\*(C'\fR attribute is not available. +You must write codes like the below: +.PP +.Vb 3 +\& $string = $json\->incr_text; +\& $string =~ s/\es*,\es*//; +\& $json\->incr_text( $string ); +.Ve +.SS "incr_skip" +.IX Subsection "incr_skip" +.Vb 1 +\& $json\->incr_skip +.Ve +.PP +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after \f(CW\*(C`incr_parse\*(C'\fR +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. +.SS "incr_reset" +.IX Subsection "incr_reset" +.Vb 1 +\& $json\->incr_reset +.Ve +.PP +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. +.PP +This is useful if you want to repeatedly parse \s-1JSON\s0 objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. +.PP +See to \*(L"\s-1INCREMENTAL\s0 \s-1PARSING\s0\*(R" in \s-1JSON::XS\s0 for examples. +.SH "JSON::PP SUPPORT METHODS" +.IX Header "JSON::PP SUPPORT METHODS" +The below methods are \s-1JSON::PP\s0 own methods, so when \f(CW\*(C`JSON\*(C'\fR works +with \s-1JSON::PP\s0 (i.e. the created object is a \s-1JSON::PP\s0 object), available. +See to \*(L"\s-1JSON::PP\s0 \s-1OWN\s0 \s-1METHODS\s0\*(R" in \s-1JSON::PP\s0 in detail. +.PP +If you use \f(CW\*(C`JSON\*(C'\fR with additional \f(CW\*(C`\-support_by_pp\*(C'\fR, some methods +are available even with \s-1JSON::XS\s0. See to \*(L"\s-1USE\s0 \s-1PP\s0 \s-1FEATURES\s0 \s-1EVEN\s0 \s-1THOUGH\s0 \s-1XS\s0 \s-1BACKEND\s0\*(R". +.PP +.Vb 1 +\& BEING { $ENV{PERL_JSON_BACKEND} = \*(AqJSON::XS\*(Aq } +\& +\& use JSON \-support_by_pp; +\& +\& my $json = JSON\->new; +\& $json\->allow_nonref\->escape_slash\->encode("/"); +\& +\& # functional interfaces too. +\& print to_json(["/"], {escape_slash => 1}); +\& print from_json(\*(Aq["foo"]\*(Aq, {utf8 => 1}); +.Ve +.PP +If you do not want to all functions but \f(CW\*(C`\-support_by_pp\*(C'\fR, +use \f(CW\*(C`\-no_export\*(C'\fR. +.PP +.Vb 2 +\& use JSON \-support_by_pp, \-no_export; +\& # functional interfaces are not exported. +.Ve +.SS "allow_singlequote" +.IX Subsection "allow_singlequote" +.Vb 1 +\& $json = $json\->allow_singlequote([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept +any \s-1JSON\s0 strings quoted by single quotations that are invalid \s-1JSON\s0 +format. +.PP +.Vb 3 +\& $json\->allow_singlequote\->decode({"foo":\*(Aqbar\*(Aq}); +\& $json\->allow_singlequote\->decode({\*(Aqfoo\*(Aq:"bar"}); +\& $json\->allow_singlequote\->decode({\*(Aqfoo\*(Aq:\*(Aqbar\*(Aq}); +.Ve +.PP +As same as the \f(CW\*(C`relaxed\*(C'\fR option, this option may be used to parse +application-specific files written by humans. +.SS "allow_barekey" +.IX Subsection "allow_barekey" +.Vb 1 +\& $json = $json\->allow_barekey([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept +bare keys of \s-1JSON\s0 object that are invalid \s-1JSON\s0 format. +.PP +As same as the \f(CW\*(C`relaxed\*(C'\fR option, this option may be used to parse +application-specific files written by humans. +.PP +.Vb 1 +\& $json\->allow_barekey\->decode(\*(Aq{foo:"bar"}\*(Aq); +.Ve +.SS "allow_bignum" +.IX Subsection "allow_bignum" +.Vb 1 +\& $json = $json\->allow_bignum([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will convert +the big integer Perl cannot handle as integer into a Math::BigInt +object and convert a floating number (any) into a Math::BigFloat. +.PP +On the contrary, \f(CW\*(C`encode\*(C'\fR converts \f(CW\*(C`Math::BigInt\*(C'\fR objects and \f(CW\*(C`Math::BigFloat\*(C'\fR +objects into \s-1JSON\s0 numbers with \f(CW\*(C`allow_blessed\*(C'\fR enable. +.PP +.Vb 4 +\& $json\->allow_nonref\->allow_blessed\->allow_bignum; +\& $bigfloat = $json\->decode(\*(Aq2.000000000000000000000000001\*(Aq); +\& print $json\->encode($bigfloat); +\& # => 2.000000000000000000000000001 +.Ve +.PP +See to \s-1MAPPING\s0 about the conversion of \s-1JSON\s0 number. +.SS "loose" +.IX Subsection "loose" +.Vb 1 +\& $json = $json\->loose([$enable]) +.Ve +.PP +The unescaped [\ex00\-\ex1f\ex22\ex2f\ex5c] strings are invalid in \s-1JSON\s0 strings +and the module doesn't allow to \f(CW\*(C`decode\*(C'\fR to these (except for \ex2f). +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept these +unescaped strings. +.PP +.Vb 2 +\& $json\->loose\->decode(qq|["abc +\& def"]|); +.Ve +.PP +See to \*(L"\s-1JSON::PP\s0 \s-1OWN\s0 \s-1METHODS\s0\*(R" in \s-1JSON::PP\s0. +.SS "escape_slash" +.IX Subsection "escape_slash" +.Vb 1 +\& $json = $json\->escape_slash([$enable]) +.Ve +.PP +According to \s-1JSON\s0 Grammar, \fIslash\fR (U+002F) is escaped. But by default +\&\s-1JSON\s0 backend modules encode strings without escaping slash. +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`encode\*(C'\fR will escape slashes. +.SS "indent_length" +.IX Subsection "indent_length" +.Vb 1 +\& $json = $json\->indent_length($length) +.Ve +.PP +With \s-1JSON::XS\s0, The indent space length is 3 and cannot be changed. +With \s-1JSON::PP\s0, it sets the indent space length with the given \f(CW$length\fR. +The default is 3. The acceptable range is 0 to 15. +.SS "sort_by" +.IX Subsection "sort_by" +.Vb 2 +\& $json = $json\->sort_by($function_name) +\& $json = $json\->sort_by($subroutine_ref) +.Ve +.PP +If \f(CW$function_name\fR or \f(CW$subroutine_ref\fR are set, its sort routine are used. +.PP +.Vb 2 +\& $js = $pc\->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })\->encode($obj); +\& # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); +\& +\& $js = $pc\->sort_by(\*(Aqown_sort\*(Aq)\->encode($obj); +\& # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); +\& +\& sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } +.Ve +.PP +As the sorting routine runs in the \s-1JSON::PP\s0 scope, the given +subroutine name and the special variables \f(CW$a\fR, \f(CW$b\fR will begin +with '\s-1JSON::PP::\s0'. +.PP +If \f(CW$integer\fR is set, then the effect is same as \f(CW\*(C`canonical\*(C'\fR on. +.PP +See to \*(L"\s-1JSON::PP\s0 \s-1OWN\s0 \s-1METHODS\s0\*(R" in \s-1JSON::PP\s0. +.SH "MAPPING" +.IX Header "MAPPING" +This section is copied from \s-1JSON::XS\s0 and modified to \f(CW\*(C`JSON\*(C'\fR. +\&\s-1JSON::XS\s0 and \s-1JSON::PP\s0 mapping mechanisms are almost equivalent. +.PP +See to \*(L"\s-1MAPPING\s0\*(R" in \s-1JSON::XS\s0. +.SS "\s-1JSON\s0 \-> \s-1PERL\s0" +.IX Subsection "JSON -> PERL" +.IP "object" 4 +.IX Item "object" +A \s-1JSON\s0 object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (\s-1JSON\s0 does not preserver object key ordering itself). +.IP "array" 4 +.IX Item "array" +A \s-1JSON\s0 array becomes a reference to an array in Perl. +.IP "string" 4 +.IX Item "string" +A \s-1JSON\s0 string becomes a string scalar in Perl \- Unicode codepoints in \s-1JSON\s0 +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. +.IP "number" 4 +.IX Item "number" +A \s-1JSON\s0 number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. +.Sp +If the number consists of digits only, \f(CW\*(C`JSON\*(C'\fR will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the \s-1JSON\s0 number will be +re-encoded to a \s-1JSON\s0 string). +.Sp +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the \s-1JSON\s0 number will still be re-encoded as a \s-1JSON\s0 number). +.Sp +Note that precision is not accuracy \- binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, \f(CW\*(C`JSON\*(C'\fR only guarantees precision up to but not including +the least significant bit. +.Sp +If the backend is \s-1JSON::PP\s0 and \f(CW\*(C`allow_bignum\*(C'\fR is enable, the big integers +and the numeric can be optionally converted into Math::BigInt and +Math::BigFloat objects. +.IP "true, false" 4 +.IX Item "true, false" +These \s-1JSON\s0 atoms become \f(CW\*(C`JSON::true\*(C'\fR and \f(CW\*(C`JSON::false\*(C'\fR, +respectively. They are overloaded to act almost exactly like the numbers +\&\f(CW1\fR and \f(CW0\fR. You can check whether a scalar is a \s-1JSON\s0 boolean by using +the \f(CW\*(C`JSON::is_bool\*(C'\fR function. +.Sp +If \f(CW\*(C`JSON::true\*(C'\fR and \f(CW\*(C`JSON::false\*(C'\fR are used as strings or compared as strings, +they represent as \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR respectively. +.Sp +.Vb 4 +\& print JSON::true . "\en"; +\& => true +\& print JSON::true + 1; +\& => 1 +\& +\& ok(JSON::true eq \*(Aqtrue\*(Aq); +\& ok(JSON::true eq \*(Aq1\*(Aq); +\& ok(JSON::true == 1); +.Ve +.Sp +\&\f(CW\*(C`JSON\*(C'\fR will install these missing overloading features to the backend modules. +.IP "null" 4 +.IX Item "null" +A \s-1JSON\s0 null atom becomes \f(CW\*(C`undef\*(C'\fR in Perl. +.Sp +\&\f(CW\*(C`JSON::null\*(C'\fR returns \f(CW\*(C`undef\*(C'\fR. +.SS "\s-1PERL\s0 \-> \s-1JSON\s0" +.IX Subsection "PERL -> JSON" +The mapping from Perl to \s-1JSON\s0 is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which \s-1JSON\s0 type is meant by +a Perl value. +.IP "hash references" 4 +.IX Item "hash references" +Perl hash references become \s-1JSON\s0 objects. As there is no inherent ordering +in hash keys (or \s-1JSON\s0 objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. \f(CW\*(C`JSON\*(C'\fR +optionally sort the hash keys (determined by the \fIcanonical\fR flag), so +the same data structure will serialise to the same \s-1JSON\s0 text (given same +settings and version of \s-1JSON::XS\s0), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some \s-1JSON\s0 text +against another for equality. +.Sp +In future, the ordered object feature will be added to \s-1JSON::PP\s0 using \f(CW\*(C`tie\*(C'\fR mechanism. +.IP "array references" 4 +.IX Item "array references" +Perl array references become \s-1JSON\s0 arrays. +.IP "other references" 4 +.IX Item "other references" +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers \f(CW0\fR and +\&\f(CW1\fR, which get turned into \f(CW\*(C`false\*(C'\fR and \f(CW\*(C`true\*(C'\fR atoms in \s-1JSON\s0. You can +also use \f(CW\*(C`JSON::false\*(C'\fR and \f(CW\*(C`JSON::true\*(C'\fR to improve readability. +.Sp +.Vb 1 +\& to_json [\e0,JSON::true] # yields [false,true] +.Ve +.IP "JSON::true, JSON::false, JSON::null" 4 +.IX Item "JSON::true, JSON::false, JSON::null" +These special values become \s-1JSON\s0 true and \s-1JSON\s0 false values, +respectively. You can also use \f(CW\*(C`\e1\*(C'\fR and \f(CW\*(C`\e0\*(C'\fR directly if you want. +.Sp +JSON::null returns \f(CW\*(C`undef\*(C'\fR. +.IP "blessed objects" 4 +.IX Item "blessed objects" +Blessed objects are not directly representable in \s-1JSON\s0. See the +\&\f(CW\*(C`allow_blessed\*(C'\fR and \f(CW\*(C`convert_blessed\*(C'\fR methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. +.Sp +With \f(CW\*(C`convert_blessed_universally\*(C'\fR mode, \f(CW\*(C`encode\*(C'\fR converts blessed +hash references or blessed array references (contains other blessed references) +into \s-1JSON\s0 members and arrays. +.Sp +.Vb 2 +\& use JSON \-convert_blessed_universally; +\& JSON\->new\->allow_blessed\->convert_blessed\->encode( $blessed_object ); +.Ve +.Sp +See to convert_blessed. +.IP "simple scalars" 4 +.IX Item "simple scalars" +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: \s-1JSON::XS\s0 and \s-1JSON::PP\s0 will encode undefined scalars as +\&\s-1JSON\s0 \f(CW\*(C`null\*(C'\fR values, scalars that have last been used in a string context +before encoding as \s-1JSON\s0 strings, and anything else as number value: +.Sp +.Vb 4 +\& # dump as number +\& encode_json [2] # yields [2] +\& encode_json [\-3.0e17] # yields [\-3e+17] +\& my $value = 5; encode_json [$value] # yields [5] +\& +\& # used as string, so dump as string +\& print $value; +\& encode_json [$value] # yields ["5"] +\& +\& # undef becomes null +\& encode_json [undef] # yields [null] +.Ve +.Sp +You can force the type to be a string by stringifying it: +.Sp +.Vb 4 +\& my $x = 3.1; # some variable containing a number +\& "$x"; # stringified +\& $x .= ""; # another, more awkward way to stringify +\& print $x; # perl does it for you, too, quite often +.Ve +.Sp +You can force the type to be a number by numifying it: +.Sp +.Vb 3 +\& my $x = "3"; # some variable containing a string +\& $x += 0; # numify it, ensuring it will be dumped as a number +\& $x *= 1; # same thing, the choice is yours. +.Ve +.Sp +You can not currently force the type in other, less obscure, ways. +.Sp +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's \- these cannot be represented in \s-1JSON\s0, and it is an +error to pass those in. +.IP "Big Number" 4 +.IX Item "Big Number" +If the backend is \s-1JSON::PP\s0 and \f(CW\*(C`allow_bignum\*(C'\fR is enable, +\&\f(CW\*(C`encode\*(C'\fR converts \f(CW\*(C`Math::BigInt\*(C'\fR objects and \f(CW\*(C`Math::BigFloat\*(C'\fR +objects into \s-1JSON\s0 numbers. +.SH "JSON and ECMAscript" +.IX Header "JSON and ECMAscript" +See to \*(L"\s-1JSON\s0 and ECMAscript\*(R" in \s-1JSON::XS\s0. +.SH "JSON and YAML" +.IX Header "JSON and YAML" +\&\s-1JSON\s0 is not a subset of \s-1YAML\s0. +See to \*(L"\s-1JSON\s0 and \s-1YAML\s0\*(R" in \s-1JSON::XS\s0. +.SH "BACKEND MODULE DECISION" +.IX Header "BACKEND MODULE DECISION" +When you use \f(CW\*(C`JSON\*(C'\fR, \f(CW\*(C`JSON\*(C'\fR tries to \f(CW\*(C`use\*(C'\fR \s-1JSON::XS\s0. If this call failed, it will +\&\f(CW\*(C`uses\*(C'\fR \s-1JSON::PP\s0. The required \s-1JSON::XS\s0 version is \fI2.2\fR or later. +.PP +The \f(CW\*(C`JSON\*(C'\fR constructor method returns an object inherited from the backend module, +and \s-1JSON::XS\s0 object is a blessed scalar reference while \s-1JSON::PP\s0 is a blessed hash +reference. +.PP +So, your program should not depend on the backend module, especially +returned objects should not be modified. +.PP +.Vb 2 +\& my $json = JSON\->new; # XS or PP? +\& $json\->{stash} = \*(Aqthis is xs object\*(Aq; # this code may raise an error! +.Ve +.PP +To check the backend module, there are some methods \- \f(CW\*(C`backend\*(C'\fR, \f(CW\*(C`is_pp\*(C'\fR and \f(CW\*(C`is_xs\*(C'\fR. +.PP +.Vb 1 +\& JSON\->backend; # \*(AqJSON::XS\*(Aq or \*(AqJSON::PP\*(Aq +\& +\& JSON\->backend\->is_pp: # 0 or 1 +\& +\& JSON\->backend\->is_xs: # 1 or 0 +\& +\& $json\->is_xs; # 1 or 0 +\& +\& $json\->is_pp; # 0 or 1 +.Ve +.PP +If you set an environment variable \f(CW\*(C`PERL_JSON_BACKEND\*(C'\fR, the calling action will be changed. +.IP "\s-1PERL_JSON_BACKEND\s0 = 0 or \s-1PERL_JSON_BACKEND\s0 = '\s-1JSON::PP\s0'" 4 +.IX Item "PERL_JSON_BACKEND = 0 or PERL_JSON_BACKEND = 'JSON::PP'" +Always use \s-1JSON::PP\s0 +.IP "\s-1PERL_JSON_BACKEND\s0 == 1 or \s-1PERL_JSON_BACKEND\s0 = '\s-1JSON::XS\s0,JSON::PP'" 4 +.IX Item "PERL_JSON_BACKEND == 1 or PERL_JSON_BACKEND = 'JSON::XS,JSON::PP'" +(The default) Use compiled \s-1JSON::XS\s0 if it is properly compiled & installed, +otherwise use \s-1JSON::PP\s0. +.IP "\s-1PERL_JSON_BACKEND\s0 == 2 or \s-1PERL_JSON_BACKEND\s0 = '\s-1JSON::XS\s0'" 4 +.IX Item "PERL_JSON_BACKEND == 2 or PERL_JSON_BACKEND = 'JSON::XS'" +Always use compiled \s-1JSON::XS\s0, die if it isn't properly compiled & installed. +.IP "\s-1PERL_JSON_BACKEND\s0 = 'JSON::backportPP'" 4 +.IX Item "PERL_JSON_BACKEND = 'JSON::backportPP'" +Always use JSON::backportPP. +JSON::backportPP is \s-1JSON::PP\s0 back port module. +\&\f(CW\*(C`JSON\*(C'\fR includes JSON::backportPP instead of \s-1JSON::PP\s0. +.PP +These ideas come from DBI::PurePerl mechanism. +.PP +example: +.PP +.Vb 2 +\& BEGIN { $ENV{PERL_JSON_BACKEND} = \*(AqJSON::PP\*(Aq } +\& use JSON; # always uses JSON::PP +.Ve +.PP +In future, it may be able to specify another module. +.SH "USE PP FEATURES EVEN THOUGH XS BACKEND" +.IX Header "USE PP FEATURES EVEN THOUGH XS BACKEND" +Many methods are available with either \s-1JSON::XS\s0 or \s-1JSON::PP\s0 and +when the backend module is \s-1JSON::XS\s0, if any \s-1JSON::PP\s0 specific (i.e. \s-1JSON::XS\s0 unsupported) +method is called, it will \f(CW\*(C`warn\*(C'\fR and be noop. +.PP +But If you \f(CW\*(C`use\*(C'\fR \f(CW\*(C`JSON\*(C'\fR passing the optional string \f(CW\*(C`\-support_by_pp\*(C'\fR, +it makes a part of those unsupported methods available. +This feature is achieved by using \s-1JSON::PP\s0 in \f(CW\*(C`de/encode\*(C'\fR. +.PP +.Vb 4 +\& BEGIN { $ENV{PERL_JSON_BACKEND} = 2 } # with JSON::XS +\& use JSON \-support_by_pp; +\& my $json = JSON\->new; +\& $json\->allow_nonref\->escape_slash\->encode("/"); +.Ve +.PP +At this time, the returned object is a \f(CW\*(C`JSON::Backend::XS::Supportable\*(C'\fR +object (re-blessed \s-1XS\s0 object), and by checking \s-1JSON::XS\s0 unsupported flags +in de/encoding, can support some unsupported methods \- \f(CW\*(C`loose\*(C'\fR, \f(CW\*(C`allow_bignum\*(C'\fR, +\&\f(CW\*(C`allow_barekey\*(C'\fR, \f(CW\*(C`allow_singlequote\*(C'\fR, \f(CW\*(C`escape_slash\*(C'\fR and \f(CW\*(C`indent_length\*(C'\fR. +.PP +When any unsupported methods are not enable, \f(CW\*(C`XS de/encode\*(C'\fR will be +used as is. The switch is achieved by changing the symbolic tables. +.PP +\&\f(CW\*(C`\-support_by_pp\*(C'\fR is effective only when the backend module is \s-1JSON::XS\s0 +and it makes the de/encoding speed down a bit. +.PP +See to \*(L"\s-1JSON::PP\s0 \s-1SUPPORT\s0 \s-1METHODS\s0\*(R". +.SH "INCOMPATIBLE CHANGES TO OLD VERSION" +.IX Header "INCOMPATIBLE CHANGES TO OLD VERSION" +There are big incompatibility between new version (2.00) and old (1.xx). +If you use old \f(CW\*(C`JSON\*(C'\fR 1.xx in your code, please check it. +.PP +See to \*(L"Transition ways from 1.xx to 2.xx.\*(R" +.IP "jsonToObj and objToJson are obsoleted." 4 +.IX Item "jsonToObj and objToJson are obsoleted." +Non Perl-style name \f(CW\*(C`jsonToObj\*(C'\fR and \f(CW\*(C`objToJson\*(C'\fR are obsoleted +(but not yet deleted from the source). +If you use these functions in your code, please replace them +with \f(CW\*(C`from_json\*(C'\fR and \f(CW\*(C`to_json\*(C'\fR. +.IP "Global variables are no longer available." 4 +.IX Item "Global variables are no longer available." +\&\f(CW\*(C`JSON\*(C'\fR class variables \- \f(CW$JSON::AUTOCONVERT\fR, \f(CW$JSON::BareKey\fR, etc... +\&\- are not available any longer. +Instead, various features can be used through object methods. +.IP "Package JSON::Converter and JSON::Parser are deleted." 4 +.IX Item "Package JSON::Converter and JSON::Parser are deleted." +Now \f(CW\*(C`JSON\*(C'\fR bundles with \s-1JSON::PP\s0 which can handle \s-1JSON\s0 more properly than them. +.IP "Package JSON::NotString is deleted." 4 +.IX Item "Package JSON::NotString is deleted." +There was \f(CW\*(C`JSON::NotString\*(C'\fR class which represents \s-1JSON\s0 value \f(CW\*(C`true\*(C'\fR, \f(CW\*(C`false\*(C'\fR, \f(CW\*(C`null\*(C'\fR +and numbers. It was deleted and replaced by \f(CW\*(C`JSON::Boolean\*(C'\fR. +.Sp +\&\f(CW\*(C`JSON::Boolean\*(C'\fR represents \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR. +.Sp +\&\f(CW\*(C`JSON::Boolean\*(C'\fR does not represent \f(CW\*(C`null\*(C'\fR. +.Sp +\&\f(CW\*(C`JSON::null\*(C'\fR returns \f(CW\*(C`undef\*(C'\fR. +.Sp +\&\f(CW\*(C`JSON\*(C'\fR makes JSON::XS::Boolean and JSON::PP::Boolean is-a relation +to JSON::Boolean. +.IP "function JSON::Number is obsoleted." 4 +.IX Item "function JSON::Number is obsoleted." +\&\f(CW\*(C`JSON::Number\*(C'\fR is now needless because \s-1JSON::XS\s0 and \s-1JSON::PP\s0 have +round-trip integrity. +.IP "\s-1JSONRPC\s0 modules are deleted." 4 +.IX Item "JSONRPC modules are deleted." +Perl implementation of JSON-RPC protocol \- \f(CW\*(C`JSONRPC \*(C'\fR, \f(CW\*(C`JSONRPC::Transport::HTTP\*(C'\fR +and \f(CW\*(C`Apache::JSONRPC \*(C'\fR are deleted in this distribution. +Instead of them, there is \s-1JSON::RPC\s0 which supports JSON-RPC protocol version 1.1. +.SS "Transition ways from 1.xx to 2.xx." +.IX Subsection "Transition ways from 1.xx to 2.xx." +You should set \f(CW\*(C`suport_by_pp\*(C'\fR mode firstly, because +it is always successful for the below codes even with \s-1JSON::XS\s0. +.PP +.Vb 1 +\& use JSON \-support_by_pp; +.Ve +.IP "Exported jsonToObj (simple)" 4 +.IX Item "Exported jsonToObj (simple)" +.Vb 1 +\& from_json($json_text); +.Ve +.IP "Exported objToJson (simple)" 4 +.IX Item "Exported objToJson (simple)" +.Vb 1 +\& to_json($perl_scalar); +.Ve +.IP "Exported jsonToObj (advanced)" 4 +.IX Item "Exported jsonToObj (advanced)" +.Vb 2 +\& $flags = {allow_barekey => 1, allow_singlequote => 1}; +\& from_json($json_text, $flags); +.Ve +.Sp +equivalent to: +.Sp +.Vb 3 +\& $JSON::BareKey = 1; +\& $JSON::QuotApos = 1; +\& jsonToObj($json_text); +.Ve +.IP "Exported objToJson (advanced)" 4 +.IX Item "Exported objToJson (advanced)" +.Vb 2 +\& $flags = {allow_blessed => 1, allow_barekey => 1}; +\& to_json($perl_scalar, $flags); +.Ve +.Sp +equivalent to: +.Sp +.Vb 2 +\& $JSON::BareKey = 1; +\& objToJson($perl_scalar); +.Ve +.IP "jsonToObj as object method" 4 +.IX Item "jsonToObj as object method" +.Vb 1 +\& $json\->decode($json_text); +.Ve +.IP "objToJson as object method" 4 +.IX Item "objToJson as object method" +.Vb 1 +\& $json\->encode($perl_scalar); +.Ve +.IP "new method with parameters" 4 +.IX Item "new method with parameters" +The \f(CW\*(C`new\*(C'\fR method in 2.x takes any parameters no longer. +You can set parameters instead; +.Sp +.Vb 1 +\& $json = JSON\->new\->pretty; +.Ve +.ie n .IP "$JSON::Pretty, $JSON::Indent, $JSON::Delimiter" 4 +.el .IP "\f(CW$JSON::Pretty\fR, \f(CW$JSON::Indent\fR, \f(CW$JSON::Delimiter\fR" 4 +.IX Item "$JSON::Pretty, $JSON::Indent, $JSON::Delimiter" +If \f(CW\*(C`indent\*(C'\fR is enable, that means \f(CW$JSON::Pretty\fR flag set. And +\&\f(CW$JSON::Delimiter\fR was substituted by \f(CW\*(C`space_before\*(C'\fR and \f(CW\*(C`space_after\*(C'\fR. +In conclusion: +.Sp +.Vb 1 +\& $json\->indent\->space_before\->space_after; +.Ve +.Sp +Equivalent to: +.Sp +.Vb 1 +\& $json\->pretty; +.Ve +.Sp +To change indent length, use \f(CW\*(C`indent_length\*(C'\fR. +.Sp +(Only with \s-1JSON::PP\s0, if \f(CW\*(C`\-support_by_pp\*(C'\fR is not used.) +.Sp +.Vb 1 +\& $json\->pretty\->indent_length(2)\->encode($perl_scalar); +.Ve +.ie n .IP "$JSON::BareKey" 4 +.el .IP "\f(CW$JSON::BareKey\fR" 4 +.IX Item "$JSON::BareKey" +(Only with \s-1JSON::PP\s0, if \f(CW\*(C`\-support_by_pp\*(C'\fR is not used.) +.Sp +.Vb 1 +\& $json\->allow_barekey\->decode($json_text) +.Ve +.ie n .IP "$JSON::ConvBlessed" 4 +.el .IP "\f(CW$JSON::ConvBlessed\fR" 4 +.IX Item "$JSON::ConvBlessed" +use \f(CW\*(C`\-convert_blessed_universally\*(C'\fR. See to convert_blessed. +.ie n .IP "$JSON::QuotApos" 4 +.el .IP "\f(CW$JSON::QuotApos\fR" 4 +.IX Item "$JSON::QuotApos" +(Only with \s-1JSON::PP\s0, if \f(CW\*(C`\-support_by_pp\*(C'\fR is not used.) +.Sp +.Vb 1 +\& $json\->allow_singlequote\->decode($json_text) +.Ve +.ie n .IP "$JSON::SingleQuote" 4 +.el .IP "\f(CW$JSON::SingleQuote\fR" 4 +.IX Item "$JSON::SingleQuote" +Disable. \f(CW\*(C`JSON\*(C'\fR does not make such a invalid \s-1JSON\s0 string any longer. +.ie n .IP "$JSON::KeySort" 4 +.el .IP "\f(CW$JSON::KeySort\fR" 4 +.IX Item "$JSON::KeySort" +.Vb 1 +\& $json\->canonical\->encode($perl_scalar) +.Ve +.Sp +This is the ascii sort. +.Sp +If you want to use with your own sort routine, check the \f(CW\*(C`sort_by\*(C'\fR method. +.Sp +(Only with \s-1JSON::PP\s0, even if \f(CW\*(C`\-support_by_pp\*(C'\fR is used currently.) +.Sp +.Vb 1 +\& $json\->sort_by($sort_routine_ref)\->encode($perl_scalar) +\& +\& $json\->sort_by(sub { $JSON::PP::a <=> $JSON::PP::b })\->encode($perl_scalar) +.Ve +.Sp +Can't access \f(CW$a\fR and \f(CW$b\fR but \f(CW$JSON::PP::a\fR and \f(CW$JSON::PP::b\fR. +.ie n .IP "$JSON::SkipInvalid" 4 +.el .IP "\f(CW$JSON::SkipInvalid\fR" 4 +.IX Item "$JSON::SkipInvalid" +.Vb 1 +\& $json\->allow_unknown +.Ve +.ie n .IP "$JSON::AUTOCONVERT" 4 +.el .IP "\f(CW$JSON::AUTOCONVERT\fR" 4 +.IX Item "$JSON::AUTOCONVERT" +Needless. \f(CW\*(C`JSON\*(C'\fR backend modules have the round-trip integrity. +.ie n .IP "$JSON::UTF8" 4 +.el .IP "\f(CW$JSON::UTF8\fR" 4 +.IX Item "$JSON::UTF8" +Needless because \f(CW\*(C`JSON\*(C'\fR (\s-1JSON::XS/JSON::PP\s0) sets +the \s-1UTF8\s0 flag on properly. +.Sp +.Vb 1 +\& # With UTF8\-flagged strings +\& +\& $json\->allow_nonref; +\& $str = chr(1000); # UTF8\-flagged +\& +\& $json_text = $json\->utf8(0)\->encode($str); +\& utf8::is_utf8($json_text); +\& # true +\& $json_text = $json\->utf8(1)\->encode($str); +\& utf8::is_utf8($json_text); +\& # false +\& +\& $str = \*(Aq"\*(Aq . chr(1000) . \*(Aq"\*(Aq; # UTF8\-flagged +\& +\& $perl_scalar = $json\->utf8(0)\->decode($str); +\& utf8::is_utf8($perl_scalar); +\& # true +\& $perl_scalar = $json\->utf8(1)\->decode($str); +\& # died because of \*(AqWide character in subroutine\*(Aq +.Ve +.Sp +See to \*(L"A \s-1FEW\s0 \s-1NOTES\s0 \s-1ON\s0 \s-1UNICODE\s0 \s-1AND\s0 \s-1PERL\s0\*(R" in \s-1JSON::XS\s0. +.ie n .IP "$JSON::UnMapping" 4 +.el .IP "\f(CW$JSON::UnMapping\fR" 4 +.IX Item "$JSON::UnMapping" +Disable. See to \s-1MAPPING\s0. +.ie n .IP "$JSON::SelfConvert" 4 +.el .IP "\f(CW$JSON::SelfConvert\fR" 4 +.IX Item "$JSON::SelfConvert" +This option was deleted. +Instead of it, if a given blessed object has the \f(CW\*(C`TO_JSON\*(C'\fR method, +\&\f(CW\*(C`TO_JSON\*(C'\fR will be executed with \f(CW\*(C`convert_blessed\*(C'\fR. +.Sp +.Vb 2 +\& $json\->convert_blessed\->encode($blessed_hashref_or_arrayref) +\& # if need, call allow_blessed +.Ve +.Sp +Note that it was \f(CW\*(C`toJson\*(C'\fR in old version, but now not \f(CW\*(C`toJson\*(C'\fR but \f(CW\*(C`TO_JSON\*(C'\fR. +.SH "TODO" +.IX Header "TODO" +.IP "example programs" 4 +.IX Item "example programs" +.SH "THREADS" +.IX Header "THREADS" +No test with \s-1JSON::PP\s0. If with \s-1JSON::XS\s0, See to \*(L"\s-1THREADS\s0\*(R" in \s-1JSON::XS\s0. +.SH "BUGS" +.IX Header "BUGS" +Please report bugs relevant to \f(CW\*(C`JSON\*(C'\fR to <makamaka[at]cpan.org>. +.SH "SEE ALSO" +.IX Header "SEE ALSO" +Most of the document is copied and modified from \s-1JSON::XS\s0 doc. +.PP +\&\s-1JSON::XS\s0, \s-1JSON::PP\s0 +.PP +\&\f(CW\*(C`RFC4627\*(C'\fR(<http://www.ietf.org/rfc/rfc4627.txt>) +.SH "AUTHOR" +.IX Header "AUTHOR" +Makamaka Hannyaharamitu, <makamaka[at]cpan.org> +.PP +\&\s-1JSON::XS\s0 was written by Marc Lehmann <schmorp[at]schmorp.de> +.PP +The release of this new version owes to the courtesy of Marc Lehmann. +.SH "COPYRIGHT AND LICENSE" +.IX Header "COPYRIGHT AND LICENSE" +Copyright 2005\-2013 by Makamaka Hannyaharamitu +.PP +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. diff --git a/third_party/JSON/out/man/man3/JSON__backportPP.3pm b/third_party/JSON/out/man/man3/JSON__backportPP.3pm new file mode 100644 index 0000000..60015fb --- /dev/null +++ b/third_party/JSON/out/man/man3/JSON__backportPP.3pm @@ -0,0 +1,1379 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON::backportPP 3pm" +.TH JSON::backportPP 3pm "2013-05-23" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON::PP \- JSON::XS compatible pure\-Perl module. +.SH "SYNOPSIS" +.IX Header "SYNOPSIS" +.Vb 1 +\& use JSON::PP; +\& +\& # exported functions, they croak on error +\& # and expect/generate UTF\-8 +\& +\& $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; +\& $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; +\& +\& # OO\-interface +\& +\& $coder = JSON::PP\->new\->ascii\->pretty\->allow_nonref; +\& +\& $json_text = $json\->encode( $perl_scalar ); +\& $perl_scalar = $json\->decode( $json_text ); +\& +\& $pretty_printed = $json\->pretty\->encode( $perl_scalar ); # pretty\-printing +\& +\& # Note that JSON version 2.0 and above will automatically use +\& # JSON::XS or JSON::PP, so you should be able to just: +\& +\& use JSON; +.Ve +.SH "VERSION" +.IX Header "VERSION" +.Vb 1 +\& 2.27200 +.Ve +.PP +\&\s-1JSON::XS\s0 2.27 (~2.30) compatible. +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +This module is \s-1JSON::XS\s0 compatible pure Perl module. +(Perl 5.8 or later is recommended) +.PP +\&\s-1JSON::XS\s0 is the fastest and most proper \s-1JSON\s0 module on \s-1CPAN\s0. +It is written by Marc Lehmann in C, so must be compiled and +installed in the used environment. +.PP +\&\s-1JSON::PP\s0 is a pure-Perl module and has compatibility to \s-1JSON::XS\s0. +.SS "\s-1FEATURES\s0" +.IX Subsection "FEATURES" +.IP "\(bu" 4 +correct unicode handling +.Sp +This module knows how to handle Unicode (depending on Perl version). +.Sp +See to \*(L"A \s-1FEW\s0 \s-1NOTES\s0 \s-1ON\s0 \s-1UNICODE\s0 \s-1AND\s0 \s-1PERL\s0\*(R" in \s-1JSON::XS\s0 and +\&\*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R". +.IP "\(bu" 4 +round-trip integrity +.Sp +When you serialise a perl data structure using only data types +supported by \s-1JSON\s0 and Perl, the deserialised data structure is +identical on the Perl level. (e.g. the string \*(L"2.0\*(R" doesn't suddenly +become \*(L"2\*(R" just because it looks like a number). There \fIare\fR minor +exceptions to this, read the \s-1MAPPING\s0 section below to learn about +those. +.IP "\(bu" 4 +strict checking of \s-1JSON\s0 correctness +.Sp +There is no guessing, no generating of illegal \s-1JSON\s0 texts by default, +and only \s-1JSON\s0 is accepted as input by default (the latter is a +security feature). But when some options are set, loose checking +features are available. +.SH "FUNCTIONAL INTERFACE" +.IX Header "FUNCTIONAL INTERFACE" +Some documents are copied and modified from \*(L"\s-1FUNCTIONAL\s0 \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0. +.SS "encode_json" +.IX Subsection "encode_json" +.Vb 1 +\& $json_text = encode_json $perl_scalar +.Ve +.PP +Converts the given Perl data structure to a \s-1UTF\-8\s0 encoded, binary string. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $json_text = JSON::PP\->new\->utf8\->encode($perl_scalar) +.Ve +.SS "decode_json" +.IX Subsection "decode_json" +.Vb 1 +\& $perl_scalar = decode_json $json_text +.Ve +.PP +The opposite of \f(CW\*(C`encode_json\*(C'\fR: expects an \s-1UTF\-8\s0 (binary) string and tries +to parse that as an \s-1UTF\-8\s0 encoded \s-1JSON\s0 text, returning the resulting +reference. +.PP +This function call is functionally identical to: +.PP +.Vb 1 +\& $perl_scalar = JSON::PP\->new\->utf8\->decode($json_text) +.Ve +.SS "JSON::PP::is_bool" +.IX Subsection "JSON::PP::is_bool" +.Vb 1 +\& $is_boolean = JSON::PP::is_bool($scalar) +.Ve +.PP +Returns true if the passed scalar represents either JSON::PP::true or +JSON::PP::false, two constants that act like \f(CW1\fR and \f(CW0\fR respectively +and are also used to represent \s-1JSON\s0 \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR in Perl strings. +.SS "JSON::PP::true" +.IX Subsection "JSON::PP::true" +Returns \s-1JSON\s0 true value which is blessed object. +It \f(CW\*(C`isa\*(C'\fR JSON::PP::Boolean object. +.SS "JSON::PP::false" +.IX Subsection "JSON::PP::false" +Returns \s-1JSON\s0 false value which is blessed object. +It \f(CW\*(C`isa\*(C'\fR JSON::PP::Boolean object. +.SS "JSON::PP::null" +.IX Subsection "JSON::PP::null" +Returns \f(CW\*(C`undef\*(C'\fR. +.PP +See \s-1MAPPING\s0, below, for more information on how \s-1JSON\s0 values are mapped to +Perl. +.SH "HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER" +.IX Header "HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER" +This section supposes that your perl version is 5.8 or later. +.PP +If you know a \s-1JSON\s0 text from an outer world \- a network, a file content, and so on, +is encoded in \s-1UTF\-8\s0, you should use \f(CW\*(C`decode_json\*(C'\fR or \f(CW\*(C`JSON\*(C'\fR module object +with \f(CW\*(C`utf8\*(C'\fR enable. And the decoded result will contain \s-1UNICODE\s0 characters. +.PP +.Vb 4 +\& # from network +\& my $json = JSON::PP\->new\->utf8; +\& my $json_text = CGI\->new\->param( \*(Aqjson_data\*(Aq ); +\& my $perl_scalar = $json\->decode( $json_text ); +\& +\& # from file content +\& local $/; +\& open( my $fh, \*(Aq<\*(Aq, \*(Aqjson.data\*(Aq ); +\& $json_text = <$fh>; +\& $perl_scalar = decode_json( $json_text ); +.Ve +.PP +If an outer data is not encoded in \s-1UTF\-8\s0, firstly you should \f(CW\*(C`decode\*(C'\fR it. +.PP +.Vb 5 +\& use Encode; +\& local $/; +\& open( my $fh, \*(Aq<\*(Aq, \*(Aqjson.data\*(Aq ); +\& my $encoding = \*(Aqcp932\*(Aq; +\& my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE +\& +\& # or you can write the below code. +\& # +\& # open( my $fh, "<:encoding($encoding)", \*(Aqjson.data\*(Aq ); +\& # $unicode_json_text = <$fh>; +.Ve +.PP +In this case, \f(CW$unicode_json_text\fR is of course \s-1UNICODE\s0 string. +So you \fBcannot\fR use \f(CW\*(C`decode_json\*(C'\fR nor \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +Instead of them, you use \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR disable. +.PP +.Vb 1 +\& $perl_scalar = $json\->utf8(0)\->decode( $unicode_json_text ); +.Ve +.PP +Or \f(CW\*(C`encode \*(Aqutf8\*(Aq\*(C'\fR and \f(CW\*(C`decode_json\*(C'\fR: +.PP +.Vb 2 +\& $perl_scalar = decode_json( encode( \*(Aqutf8\*(Aq, $unicode_json_text ) ); +\& # this way is not efficient. +.Ve +.PP +And now, you want to convert your \f(CW$perl_scalar\fR into \s-1JSON\s0 data and +send it to an outer world \- a network or a file content, and so on. +.PP +Your data usually contains \s-1UNICODE\s0 strings and you want the converted data to be encoded +in \s-1UTF\-8\s0, you should use \f(CW\*(C`encode_json\*(C'\fR or \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +.PP +.Vb 3 +\& print encode_json( $perl_scalar ); # to a network? file? or display? +\& # or +\& print $json\->utf8\->encode( $perl_scalar ); +.Ve +.PP +If \f(CW$perl_scalar\fR does not contain \s-1UNICODE\s0 but \f(CW$encoding\fR\-encoded strings +for some reason, then its characters are regarded as \fBlatin1\fR for perl +(because it does not concern with your \f(CW$encoding\fR). +You \fBcannot\fR use \f(CW\*(C`encode_json\*(C'\fR nor \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR enable. +Instead of them, you use \f(CW\*(C`JSON\*(C'\fR module object with \f(CW\*(C`utf8\*(C'\fR disable. +Note that the resulted text is a \s-1UNICODE\s0 string but no problem to print it. +.PP +.Vb 4 +\& # $perl_scalar contains $encoding encoded string values +\& $unicode_json_text = $json\->utf8(0)\->encode( $perl_scalar ); +\& # $unicode_json_text consists of characters less than 0x100 +\& print $unicode_json_text; +.Ve +.PP +Or \f(CW\*(C`decode $encoding\*(C'\fR all string values and \f(CW\*(C`encode_json\*(C'\fR: +.PP +.Vb 3 +\& $perl_scalar\->{ foo } = decode( $encoding, $perl_scalar\->{ foo } ); +\& # ... do it to each string values, then encode_json +\& $json_text = encode_json( $perl_scalar ); +.Ve +.PP +This method is a proper way but probably not efficient. +.PP +See to Encode, perluniintro. +.SH "METHODS" +.IX Header "METHODS" +Basically, check to \s-1JSON\s0 or \s-1JSON::XS\s0. +.SS "new" +.IX Subsection "new" +.Vb 1 +\& $json = JSON::PP\->new +.Ve +.PP +Returns a new \s-1JSON::PP\s0 object that can be used to de/encode \s-1JSON\s0 +strings. +.PP +All boolean flags described below are by default \fIdisabled\fR. +.PP +The mutators for flags all return the \s-1JSON\s0 object again and thus calls can +be chained: +.PP +.Vb 2 +\& my $json = JSON::PP\->new\->utf8\->space_after\->encode({a => [1,2]}) +\& => {"a": [1, 2]} +.Ve +.SS "ascii" +.IX Subsection "ascii" +.Vb 1 +\& $json = $json\->ascii([$enable]) +\& +\& $enabled = $json\->get_ascii +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will not generate characters outside +the code range 0..127. Any Unicode characters outside that range will be escaped using either +a single \euXXXX or a double \euHHHH\euLLLLL escape sequence, as per \s-1RFC4627\s0. +(See to \*(L"OBJECT-ORIENTED \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0). +.PP +In Perl 5.005, there is no character having high value (more than 255). +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R". +.PP +If \f(CW$enable\fR is false, then the encode method will not escape Unicode characters unless +required by the \s-1JSON\s0 syntax or other flags. This results in a faster and more compact format. +.PP +.Vb 2 +\& JSON::PP\->new\->ascii(1)\->encode([chr 0x10401]) +\& => ["\eud801\eudc01"] +.Ve +.SS "latin1" +.IX Subsection "latin1" +.Vb 1 +\& $json = $json\->latin1([$enable]) +\& +\& $enabled = $json\->get_latin1 +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will encode the resulting \s-1JSON\s0 +text as latin1 (or iso\-8859\-1), escaping any characters outside the code range 0..255. +.PP +If \f(CW$enable\fR is false, then the encode method will not escape Unicode characters +unless required by the \s-1JSON\s0 syntax or other flags. +.PP +.Vb 2 +\& JSON::XS\->new\->latin1\->encode (["\ex{89}\ex{abc}"] +\& => ["\ex{89}\e\eu0abc"] # (perl syntax, U+abc escaped, U+89 not) +.Ve +.PP +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R". +.SS "utf8" +.IX Subsection "utf8" +.Vb 1 +\& $json = $json\->utf8([$enable]) +\& +\& $enabled = $json\->get_utf8 +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the encode method will encode the \s-1JSON\s0 result +into \s-1UTF\-8\s0, as required by many protocols, while the decode method expects to be handled +an UTF\-8\-encoded string. Please note that UTF\-8\-encoded strings do not contain any +characters outside the range 0..255, they are thus useful for bytewise/binary I/O. +.PP +(In Perl 5.005, any character outside the range 0..255 does not exist. +See to \*(L"\s-1UNICODE\s0 \s-1HANDLING\s0 \s-1ON\s0 \s-1PERLS\s0\*(R".) +.PP +In future versions, enabling this option might enable autodetection of the \s-1UTF\-16\s0 and \s-1UTF\-32\s0 +encoding families, as described in \s-1RFC4627\s0. +.PP +If \f(CW$enable\fR is false, then the encode method will return the \s-1JSON\s0 string as a (non-encoded) +Unicode string, while decode expects thus a Unicode string. Any decoding or encoding +(e.g. to \s-1UTF\-8\s0 or \s-1UTF\-16\s0) needs to be done yourself, e.g. using the Encode module. +.PP +Example, output UTF\-16BE\-encoded \s-1JSON:\s0 +.PP +.Vb 2 +\& use Encode; +\& $jsontext = encode "UTF\-16BE", JSON::PP\->new\->encode ($object); +.Ve +.PP +Example, decode UTF\-32LE\-encoded \s-1JSON:\s0 +.PP +.Vb 2 +\& use Encode; +\& $object = JSON::PP\->new\->decode (decode "UTF\-32LE", $jsontext); +.Ve +.SS "pretty" +.IX Subsection "pretty" +.Vb 1 +\& $json = $json\->pretty([$enable]) +.Ve +.PP +This enables (or disables) all of the \f(CW\*(C`indent\*(C'\fR, \f(CW\*(C`space_before\*(C'\fR and +\&\f(CW\*(C`space_after\*(C'\fR flags in one call to generate the most readable +(or most compact) form possible. +.PP +Equivalent to: +.PP +.Vb 1 +\& $json\->indent\->space_before\->space_after +.Ve +.SS "indent" +.IX Subsection "indent" +.Vb 1 +\& $json = $json\->indent([$enable]) +\& +\& $enabled = $json\->get_indent +.Ve +.PP +The default indent space length is three. +You can use \f(CW\*(C`indent_length\*(C'\fR to change the length. +.SS "space_before" +.IX Subsection "space_before" +.Vb 1 +\& $json = $json\->space_before([$enable]) +\& +\& $enabled = $json\->get_space_before +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will add an extra +optional space before the \f(CW\*(C`:\*(C'\fR separating keys from values in \s-1JSON\s0 objects. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will not add any extra +space at those places. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +Example, space_before enabled, space_after and indent disabled: +.PP +.Vb 1 +\& {"key" :"value"} +.Ve +.SS "space_after" +.IX Subsection "space_after" +.Vb 1 +\& $json = $json\->space_after([$enable]) +\& +\& $enabled = $json\->get_space_after +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will add an extra +optional space after the \f(CW\*(C`:\*(C'\fR separating keys from values in \s-1JSON\s0 objects +and extra whitespace after the \f(CW\*(C`,\*(C'\fR separating key-value pairs and array +members. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will not add any extra +space at those places. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +Example, space_before and indent disabled, space_after enabled: +.PP +.Vb 1 +\& {"key": "value"} +.Ve +.SS "relaxed" +.IX Subsection "relaxed" +.Vb 1 +\& $json = $json\->relaxed([$enable]) +\& +\& $enabled = $json\->get_relaxed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept some +extensions to normal \s-1JSON\s0 syntax (see below). \f(CW\*(C`encode\*(C'\fR will not be +affected in anyway. \fIBe aware that this option makes you accept invalid +\&\s-1JSON\s0 texts as if they were valid!\fR. I suggest only to use this option to +parse application-specific files written by humans (configuration files, +resource files etc.) +.PP +If \f(CW$enable\fR is false (the default), then \f(CW\*(C`decode\*(C'\fR will only accept +valid \s-1JSON\s0 texts. +.PP +Currently accepted extensions are: +.IP "\(bu" 4 +list items can have an end-comma +.Sp +\&\s-1JSON\s0 \fIseparates\fR array elements and key-value pairs with commas. This +can be annoying if you write \s-1JSON\s0 texts manually and want to be able to +quickly append elements, so this extension accepts comma at the end of +such items not just between them: +.Sp +.Vb 8 +\& [ +\& 1, +\& 2, <\- this comma not normally allowed +\& ] +\& { +\& "k1": "v1", +\& "k2": "v2", <\- this comma not normally allowed +\& } +.Ve +.IP "\(bu" 4 +shell-style '#'\-comments +.Sp +Whenever \s-1JSON\s0 allows whitespace, shell-style comments are additionally +allowed. They are terminated by the first carriage-return or line-feed +character, after which more white-space and comments are allowed. +.Sp +.Vb 4 +\& [ +\& 1, # this comment not allowed in JSON +\& # neither this one... +\& ] +.Ve +.SS "canonical" +.IX Subsection "canonical" +.Vb 1 +\& $json = $json\->canonical([$enable]) +\& +\& $enabled = $json\->get_canonical +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will output \s-1JSON\s0 objects +by sorting their keys. This is adding a comparatively high overhead. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will output key-value +pairs in the order Perl stores them (which will likely change between runs +of the same script). +.PP +This option is useful if you want the same data structure to be encoded as +the same \s-1JSON\s0 text (given the same overall settings). If it is disabled, +the same hash might be encoded differently even if contains the same data, +as key-value pairs have no inherent ordering in Perl. +.PP +This setting has no effect when decoding \s-1JSON\s0 texts. +.PP +If you want your own sorting routine, you can give a code reference +or a subroutine name to \f(CW\*(C`sort_by\*(C'\fR. See to \f(CW\*(C`JSON::PP OWN METHODS\*(C'\fR. +.SS "allow_nonref" +.IX Subsection "allow_nonref" +.Vb 1 +\& $json = $json\->allow_nonref([$enable]) +\& +\& $enabled = $json\->get_allow_nonref +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method can convert a +non-reference into its corresponding string, number or null \s-1JSON\s0 value, +which is an extension to \s-1RFC4627\s0. Likewise, \f(CW\*(C`decode\*(C'\fR will accept those \s-1JSON\s0 +values instead of croaking. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`encode\*(C'\fR method will croak if it isn't +passed an arrayref or hashref, as \s-1JSON\s0 texts must either be an object +or array. Likewise, \f(CW\*(C`decode\*(C'\fR will croak if given something that is not a +\&\s-1JSON\s0 object or array. +.PP +.Vb 2 +\& JSON::PP\->new\->allow_nonref\->encode ("Hello, World!") +\& => "Hello, World!" +.Ve +.SS "allow_unknown" +.IX Subsection "allow_unknown" +.Vb 1 +\& $json = $json\->allow_unknown ([$enable]) +\& +\& $enabled = $json\->get_allow_unknown +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \*(L"encode\*(R" will *not* throw an +exception when it encounters values it cannot represent in \s-1JSON\s0 (for +example, filehandles) but instead will encode a \s-1JSON\s0 \*(L"null\*(R" value. +Note that blessed objects are not included here and are handled +separately by c<allow_nonref>. +.PP +If \f(CW$enable\fR is false (the default), then \*(L"encode\*(R" will throw an +exception when it encounters anything it cannot encode as \s-1JSON\s0. +.PP +This option does not affect \*(L"decode\*(R" in any way, and it is +recommended to leave it off unless you know your communications +partner. +.SS "allow_blessed" +.IX Subsection "allow_blessed" +.Vb 1 +\& $json = $json\->allow_blessed([$enable]) +\& +\& $enabled = $json\->get_allow_blessed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then the \f(CW\*(C`encode\*(C'\fR method will not +barf when it encounters a blessed reference. Instead, the value of the +\&\fBconvert_blessed\fR option will decide whether \f(CW\*(C`null\*(C'\fR (\f(CW\*(C`convert_blessed\*(C'\fR +disabled or no \f(CW\*(C`TO_JSON\*(C'\fR method found) or a representation of the +object (\f(CW\*(C`convert_blessed\*(C'\fR enabled and \f(CW\*(C`TO_JSON\*(C'\fR method found) is being +encoded. Has no effect on \f(CW\*(C`decode\*(C'\fR. +.PP +If \f(CW$enable\fR is false (the default), then \f(CW\*(C`encode\*(C'\fR will throw an +exception when it encounters a blessed object. +.SS "convert_blessed" +.IX Subsection "convert_blessed" +.Vb 1 +\& $json = $json\->convert_blessed([$enable]) +\& +\& $enabled = $json\->get_convert_blessed +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`encode\*(C'\fR, upon encountering a +blessed object, will check for the availability of the \f(CW\*(C`TO_JSON\*(C'\fR method +on the object's class. If found, it will be called in scalar context +and the resulting scalar will be encoded instead of the object. If no +\&\f(CW\*(C`TO_JSON\*(C'\fR method is found, the value of \f(CW\*(C`allow_blessed\*(C'\fR will decide what +to do. +.PP +The \f(CW\*(C`TO_JSON\*(C'\fR method may safely call die if it wants. If \f(CW\*(C`TO_JSON\*(C'\fR +returns other blessed objects, those will be handled in the same +way. \f(CW\*(C`TO_JSON\*(C'\fR must take care of not causing an endless recursion cycle +(== crash) in this case. The name of \f(CW\*(C`TO_JSON\*(C'\fR was chosen because other +methods called by the Perl core (== not by the user of the object) are +usually in upper case letters and to avoid collisions with the \f(CW\*(C`to_json\*(C'\fR +function or method. +.PP +This setting does not yet influence \f(CW\*(C`decode\*(C'\fR in any way. +.PP +If \f(CW$enable\fR is false, then the \f(CW\*(C`allow_blessed\*(C'\fR setting will decide what +to do when a blessed object is found. +.SS "filter_json_object" +.IX Subsection "filter_json_object" +.Vb 1 +\& $json = $json\->filter_json_object([$coderef]) +.Ve +.PP +When \f(CW$coderef\fR is specified, it will be called from \f(CW\*(C`decode\*(C'\fR each +time it decodes a \s-1JSON\s0 object. The only argument passed to the coderef +is a reference to the newly-created hash. If the code references returns +a single scalar (which need not be a reference), this value +(i.e. a copy of that scalar to avoid aliasing) is inserted into the +deserialised data structure. If it returns an empty list +(\s-1NOTE:\s0 \fInot\fR \f(CW\*(C`undef\*(C'\fR, which is a valid scalar), the original deserialised +hash will be inserted. This setting can slow down decoding considerably. +.PP +When \f(CW$coderef\fR is omitted or undefined, any existing callback will +be removed and \f(CW\*(C`decode\*(C'\fR will not change the deserialised hash in any +way. +.PP +Example, convert all \s-1JSON\s0 objects into the integer 5: +.PP +.Vb 6 +\& my $js = JSON::PP\->new\->filter_json_object (sub { 5 }); +\& # returns [5] +\& $js\->decode (\*(Aq[{}]\*(Aq); # the given subroutine takes a hash reference. +\& # throw an exception because allow_nonref is not enabled +\& # so a lone 5 is not allowed. +\& $js\->decode (\*(Aq{"a":1, "b":2}\*(Aq); +.Ve +.SS "filter_json_single_key_object" +.IX Subsection "filter_json_single_key_object" +.Vb 1 +\& $json = $json\->filter_json_single_key_object($key [=> $coderef]) +.Ve +.PP +Works remotely similar to \f(CW\*(C`filter_json_object\*(C'\fR, but is only called for +\&\s-1JSON\s0 objects having a single key named \f(CW$key\fR. +.PP +This \f(CW$coderef\fR is called before the one specified via +\&\f(CW\*(C`filter_json_object\*(C'\fR, if any. It gets passed the single value in the \s-1JSON\s0 +object. If it returns a single value, it will be inserted into the data +structure. If it returns nothing (not even \f(CW\*(C`undef\*(C'\fR but the empty list), +the callback from \f(CW\*(C`filter_json_object\*(C'\fR will be called next, as if no +single-key callback were specified. +.PP +If \f(CW$coderef\fR is omitted or undefined, the corresponding callback will be +disabled. There can only ever be one callback for a given key. +.PP +As this callback gets called less often then the \f(CW\*(C`filter_json_object\*(C'\fR +one, decoding speed will not usually suffer as much. Therefore, single-key +objects make excellent targets to serialise Perl objects into, especially +as single-key \s-1JSON\s0 objects are as close to the type-tagged value concept +as \s-1JSON\s0 gets (it's basically an \s-1ID/VALUE\s0 tuple). Of course, \s-1JSON\s0 does not +support this in any way, so you need to make sure your data never looks +like a serialised Perl hash. +.PP +Typical names for the single object key are \f(CW\*(C`_\|_class_whatever_\|_\*(C'\fR, or +\&\f(CW\*(C`$_\|_dollars_are_rarely_used_\|_$\*(C'\fR or \f(CW\*(C`}ugly_brace_placement\*(C'\fR, or even +things like \f(CW\*(C`_\|_class_md5sum(classname)_\|_\*(C'\fR, to reduce the risk of clashing +with real hashes. +.PP +Example, decode \s-1JSON\s0 objects of the form \f(CW\*(C`{ "_\|_widget_\|_" => <id> }\*(C'\fR +into the corresponding \f(CW$WIDGET{<id>}\fR object: +.PP +.Vb 7 +\& # return whatever is in $WIDGET{5}: +\& JSON::PP +\& \->new +\& \->filter_json_single_key_object (_\|_widget_\|_ => sub { +\& $WIDGET{ $_[0] } +\& }) +\& \->decode (\*(Aq{"_\|_widget_\|_": 5\*(Aq) +\& +\& # this can be used with a TO_JSON method in some "widget" class +\& # for serialisation to json: +\& sub WidgetBase::TO_JSON { +\& my ($self) = @_; +\& +\& unless ($self\->{id}) { +\& $self\->{id} = ..get..some..id..; +\& $WIDGET{$self\->{id}} = $self; +\& } +\& +\& { _\|_widget_\|_ => $self\->{id} } +\& } +.Ve +.SS "shrink" +.IX Subsection "shrink" +.Vb 1 +\& $json = $json\->shrink([$enable]) +\& +\& $enabled = $json\->get_shrink +.Ve +.PP +In \s-1JSON::XS\s0, this flag resizes strings generated by either +\&\f(CW\*(C`encode\*(C'\fR or \f(CW\*(C`decode\*(C'\fR to their minimum size possible. +It will also try to downgrade any strings to octet-form if possible. +.PP +In \s-1JSON::PP\s0, it is noop about resizing strings but tries +\&\f(CW\*(C`utf8::downgrade\*(C'\fR to the returned string by \f(CW\*(C`encode\*(C'\fR. +See to utf8. +.PP +See to \*(L"OBJECT-ORIENTED \s-1INTERFACE\s0\*(R" in \s-1JSON::XS\s0 +.SS "max_depth" +.IX Subsection "max_depth" +.Vb 1 +\& $json = $json\->max_depth([$maximum_nesting_depth]) +\& +\& $max_depth = $json\->get_max_depth +.Ve +.PP +Sets the maximum nesting level (default \f(CW512\fR) accepted while encoding +or decoding. If a higher nesting level is detected in \s-1JSON\s0 text or a Perl +data structure, then the encoder and decoder will stop and croak at that +point. +.PP +Nesting level is defined by number of hash\- or arrayrefs that the encoder +needs to traverse to reach a given point or the number of \f(CW\*(C`{\*(C'\fR or \f(CW\*(C`[\*(C'\fR +characters without their matching closing parenthesis crossed to reach a +given character in a string. +.PP +If no argument is given, the highest possible setting will be used, which +is rarely useful. +.PP +See \*(L"\s-1SSECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0 for more info on why this is useful. +.PP +When a large value (100 or more) was set and it de/encodes a deep nested object/text, +it may raise a warning 'Deep recursion on subroutine' at the perl runtime phase. +.SS "max_size" +.IX Subsection "max_size" +.Vb 1 +\& $json = $json\->max_size([$maximum_string_size]) +\& +\& $max_size = $json\->get_max_size +.Ve +.PP +Set the maximum length a \s-1JSON\s0 text may have (in bytes) where decoding is +being attempted. The default is \f(CW0\fR, meaning no limit. When \f(CW\*(C`decode\*(C'\fR +is called on a string that is longer then this many bytes, it will not +attempt to decode the string but throw an exception. This setting has no +effect on \f(CW\*(C`encode\*(C'\fR (yet). +.PP +If no argument is given, the limit check will be deactivated (same as when +\&\f(CW0\fR is specified). +.PP +See \*(L"\s-1SECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0 for more info on why this is useful. +.SS "encode" +.IX Subsection "encode" +.Vb 1 +\& $json_text = $json\->encode($perl_scalar) +.Ve +.PP +Converts the given Perl data structure (a simple scalar or a reference +to a hash or array) to its \s-1JSON\s0 representation. Simple scalars will be +converted into \s-1JSON\s0 string or number sequences, while references to arrays +become \s-1JSON\s0 arrays and references to hashes become \s-1JSON\s0 objects. Undefined +Perl values (e.g. \f(CW\*(C`undef\*(C'\fR) become \s-1JSON\s0 \f(CW\*(C`null\*(C'\fR values. +References to the integers \f(CW0\fR and \f(CW1\fR are converted into \f(CW\*(C`true\*(C'\fR and \f(CW\*(C`false\*(C'\fR. +.SS "decode" +.IX Subsection "decode" +.Vb 1 +\& $perl_scalar = $json\->decode($json_text) +.Ve +.PP +The opposite of \f(CW\*(C`encode\*(C'\fR: expects a \s-1JSON\s0 text and tries to parse it, +returning the resulting simple scalar or reference. Croaks on error. +.PP +\&\s-1JSON\s0 numbers and strings become simple Perl scalars. \s-1JSON\s0 arrays become +Perl arrayrefs and \s-1JSON\s0 objects become Perl hashrefs. \f(CW\*(C`true\*(C'\fR becomes +\&\f(CW1\fR (\f(CW\*(C`JSON::true\*(C'\fR), \f(CW\*(C`false\*(C'\fR becomes \f(CW0\fR (\f(CW\*(C`JSON::false\*(C'\fR) and +\&\f(CW\*(C`null\*(C'\fR becomes \f(CW\*(C`undef\*(C'\fR. +.SS "decode_prefix" +.IX Subsection "decode_prefix" +.Vb 1 +\& ($perl_scalar, $characters) = $json\->decode_prefix($json_text) +.Ve +.PP +This works like the \f(CW\*(C`decode\*(C'\fR method, but instead of raising an exception +when there is trailing garbage after the first \s-1JSON\s0 object, it will +silently stop parsing there and return the number of characters consumed +so far. +.PP +.Vb 2 +\& JSON\->new\->decode_prefix ("[1] the tail") +\& => ([], 3) +.Ve +.SH "INCREMENTAL PARSING" +.IX Header "INCREMENTAL PARSING" +Most of this section are copied and modified from \*(L"\s-1INCREMENTAL\s0 \s-1PARSING\s0\*(R" in \s-1JSON::XS\s0. +.PP +In some cases, there is the need for incremental parsing of \s-1JSON\s0 texts. +This module does allow you to parse a \s-1JSON\s0 stream incrementally. +It does so by accumulating text until it has a full \s-1JSON\s0 object, which +it then can decode. This process is similar to using \f(CW\*(C`decode_prefix\*(C'\fR +to see if a full \s-1JSON\s0 object is available, but is much more efficient +(and can be implemented with a minimum of method calls). +.PP +This module will only attempt to parse the \s-1JSON\s0 text once it is sure it +has enough text to get a decisive result, using a very simple but +truly incremental parser. This means that it sometimes won't stop as +early as the full parser, for example, it doesn't detect parenthesis +mismatches. The only thing it guarantees is that it starts decoding as +soon as a syntactically valid \s-1JSON\s0 text has been seen. This means you need +to set resource limits (e.g. \f(CW\*(C`max_size\*(C'\fR) to ensure the parser will stop +parsing in the presence if syntax errors. +.PP +The following methods implement this incremental parser. +.SS "incr_parse" +.IX Subsection "incr_parse" +.Vb 1 +\& $json\->incr_parse( [$string] ) # void context +\& +\& $obj_or_undef = $json\->incr_parse( [$string] ) # scalar context +\& +\& @obj_or_empty = $json\->incr_parse( [$string] ) # list context +.Ve +.PP +This is the central parsing function. It can both append new text and +extract objects from the stream accumulated so far (both of these +functions are optional). +.PP +If \f(CW$string\fR is given, then this string is appended to the already +existing \s-1JSON\s0 fragment stored in the \f(CW$json\fR object. +.PP +After that, if the function is called in void context, it will simply +return without doing anything further. This can be used to add more text +in as many chunks as you want. +.PP +If the method is called in scalar context, then it will try to extract +exactly \fIone\fR \s-1JSON\s0 object. If that is successful, it will return this +object, otherwise it will return \f(CW\*(C`undef\*(C'\fR. If there is a parse error, +this method will croak just as \f(CW\*(C`decode\*(C'\fR would do (one can then use +\&\f(CW\*(C`incr_skip\*(C'\fR to skip the erroneous part). This is the most common way of +using the method. +.PP +And finally, in list context, it will try to extract as many objects +from the stream as it can find and return them, or the empty list +otherwise. For this to work, there must be no separators between the \s-1JSON\s0 +objects or arrays, instead they must be concatenated back-to-back. If +an error occurs, an exception will be raised as in the scalar context +case. Note that in this case, any previously-parsed \s-1JSON\s0 texts will be +lost. +.PP +Example: Parse some \s-1JSON\s0 arrays/objects in a given string and return them. +.PP +.Vb 1 +\& my @objs = JSON\->new\->incr_parse ("[5][7][1,2]"); +.Ve +.SS "incr_text" +.IX Subsection "incr_text" +.Vb 1 +\& $lvalue_string = $json\->incr_text +.Ve +.PP +This method returns the currently stored \s-1JSON\s0 fragment as an lvalue, that +is, you can manipulate it. This \fIonly\fR works when a preceding call to +\&\f(CW\*(C`incr_parse\*(C'\fR in \fIscalar context\fR successfully returned an object. Under +all other circumstances you must not call this function (I mean it. +although in simple tests it might actually work, it \fIwill\fR fail under +real world conditions). As a special exception, you can also call this +method before having parsed anything. +.PP +This function is useful in two cases: a) finding the trailing text after a +\&\s-1JSON\s0 object or b) parsing multiple \s-1JSON\s0 objects separated by non-JSON text +(such as commas). +.PP +.Vb 1 +\& $json\->incr_text =~ s/\es*,\es*//; +.Ve +.PP +In Perl 5.005, \f(CW\*(C`lvalue\*(C'\fR attribute is not available. +You must write codes like the below: +.PP +.Vb 3 +\& $string = $json\->incr_text; +\& $string =~ s/\es*,\es*//; +\& $json\->incr_text( $string ); +.Ve +.SS "incr_skip" +.IX Subsection "incr_skip" +.Vb 1 +\& $json\->incr_skip +.Ve +.PP +This will reset the state of the incremental parser and will remove the +parsed text from the input buffer. This is useful after \f(CW\*(C`incr_parse\*(C'\fR +died, in which case the input buffer and incremental parser state is left +unchanged, to skip the text parsed so far and to reset the parse state. +.SS "incr_reset" +.IX Subsection "incr_reset" +.Vb 1 +\& $json\->incr_reset +.Ve +.PP +This completely resets the incremental parser, that is, after this call, +it will be as if the parser had never parsed anything. +.PP +This is useful if you want to repeatedly parse \s-1JSON\s0 objects and want to +ignore any trailing data, which means you have to reset the parser after +each successful decode. +.PP +See to \*(L"\s-1INCREMENTAL\s0 \s-1PARSING\s0\*(R" in \s-1JSON::XS\s0 for examples. +.SH "JSON::PP OWN METHODS" +.IX Header "JSON::PP OWN METHODS" +.SS "allow_singlequote" +.IX Subsection "allow_singlequote" +.Vb 1 +\& $json = $json\->allow_singlequote([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept +\&\s-1JSON\s0 strings quoted by single quotations that are invalid \s-1JSON\s0 +format. +.PP +.Vb 3 +\& $json\->allow_singlequote\->decode({"foo":\*(Aqbar\*(Aq}); +\& $json\->allow_singlequote\->decode({\*(Aqfoo\*(Aq:"bar"}); +\& $json\->allow_singlequote\->decode({\*(Aqfoo\*(Aq:\*(Aqbar\*(Aq}); +.Ve +.PP +As same as the \f(CW\*(C`relaxed\*(C'\fR option, this option may be used to parse +application-specific files written by humans. +.SS "allow_barekey" +.IX Subsection "allow_barekey" +.Vb 1 +\& $json = $json\->allow_barekey([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept +bare keys of \s-1JSON\s0 object that are invalid \s-1JSON\s0 format. +.PP +As same as the \f(CW\*(C`relaxed\*(C'\fR option, this option may be used to parse +application-specific files written by humans. +.PP +.Vb 1 +\& $json\->allow_barekey\->decode(\*(Aq{foo:"bar"}\*(Aq); +.Ve +.SS "allow_bignum" +.IX Subsection "allow_bignum" +.Vb 1 +\& $json = $json\->allow_bignum([$enable]) +.Ve +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will convert +the big integer Perl cannot handle as integer into a Math::BigInt +object and convert a floating number (any) into a Math::BigFloat. +.PP +On the contrary, \f(CW\*(C`encode\*(C'\fR converts \f(CW\*(C`Math::BigInt\*(C'\fR objects and \f(CW\*(C`Math::BigFloat\*(C'\fR +objects into \s-1JSON\s0 numbers with \f(CW\*(C`allow_blessed\*(C'\fR enable. +.PP +.Vb 4 +\& $json\->allow_nonref\->allow_blessed\->allow_bignum; +\& $bigfloat = $json\->decode(\*(Aq2.000000000000000000000000001\*(Aq); +\& print $json\->encode($bigfloat); +\& # => 2.000000000000000000000000001 +.Ve +.PP +See to \*(L"\s-1MAPPING\s0\*(R" in \s-1JSON::XS\s0 about the normal conversion of \s-1JSON\s0 number. +.SS "loose" +.IX Subsection "loose" +.Vb 1 +\& $json = $json\->loose([$enable]) +.Ve +.PP +The unescaped [\ex00\-\ex1f\ex22\ex2f\ex5c] strings are invalid in \s-1JSON\s0 strings +and the module doesn't allow to \f(CW\*(C`decode\*(C'\fR to these (except for \ex2f). +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`decode\*(C'\fR will accept these +unescaped strings. +.PP +.Vb 2 +\& $json\->loose\->decode(qq|["abc +\& def"]|); +.Ve +.PP +See \*(L"\s-1SSECURITY\s0 \s-1CONSIDERATIONS\s0\*(R" in \s-1JSON::XS\s0. +.SS "escape_slash" +.IX Subsection "escape_slash" +.Vb 1 +\& $json = $json\->escape_slash([$enable]) +.Ve +.PP +According to \s-1JSON\s0 Grammar, \fIslash\fR (U+002F) is escaped. But default +\&\s-1JSON::PP\s0 (as same as \s-1JSON::XS\s0) encodes strings without escaping slash. +.PP +If \f(CW$enable\fR is true (or missing), then \f(CW\*(C`encode\*(C'\fR will escape slashes. +.SS "indent_length" +.IX Subsection "indent_length" +.Vb 1 +\& $json = $json\->indent_length($length) +.Ve +.PP +\&\s-1JSON::XS\s0 indent space length is 3 and cannot be changed. +\&\s-1JSON::PP\s0 set the indent space length with the given \f(CW$length\fR. +The default is 3. The acceptable range is 0 to 15. +.SS "sort_by" +.IX Subsection "sort_by" +.Vb 2 +\& $json = $json\->sort_by($function_name) +\& $json = $json\->sort_by($subroutine_ref) +.Ve +.PP +If \f(CW$function_name\fR or \f(CW$subroutine_ref\fR are set, its sort routine are used +in encoding \s-1JSON\s0 objects. +.PP +.Vb 2 +\& $js = $pc\->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })\->encode($obj); +\& # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); +\& +\& $js = $pc\->sort_by(\*(Aqown_sort\*(Aq)\->encode($obj); +\& # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); +\& +\& sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } +.Ve +.PP +As the sorting routine runs in the \s-1JSON::PP\s0 scope, the given +subroutine name and the special variables \f(CW$a\fR, \f(CW$b\fR will begin +\&'\s-1JSON::PP::\s0'. +.PP +If \f(CW$integer\fR is set, then the effect is same as \f(CW\*(C`canonical\*(C'\fR on. +.SH "INTERNAL" +.IX Header "INTERNAL" +For developers. +.IP "PP_encode_box" 4 +.IX Item "PP_encode_box" +Returns +.Sp +.Vb 4 +\& { +\& depth => $depth, +\& indent_count => $indent_count, +\& } +.Ve +.IP "PP_decode_box" 4 +.IX Item "PP_decode_box" +Returns +.Sp +.Vb 9 +\& { +\& text => $text, +\& at => $at, +\& ch => $ch, +\& len => $len, +\& depth => $depth, +\& encoding => $encoding, +\& is_valid_utf8 => $is_valid_utf8, +\& }; +.Ve +.SH "MAPPING" +.IX Header "MAPPING" +This section is copied from \s-1JSON::XS\s0 and modified to \f(CW\*(C`JSON::PP\*(C'\fR. +\&\s-1JSON::XS\s0 and \s-1JSON::PP\s0 mapping mechanisms are almost equivalent. +.PP +See to \*(L"\s-1MAPPING\s0\*(R" in \s-1JSON::XS\s0. +.SS "\s-1JSON\s0 \-> \s-1PERL\s0" +.IX Subsection "JSON -> PERL" +.IP "object" 4 +.IX Item "object" +A \s-1JSON\s0 object becomes a reference to a hash in Perl. No ordering of object +keys is preserved (\s-1JSON\s0 does not preserver object key ordering itself). +.IP "array" 4 +.IX Item "array" +A \s-1JSON\s0 array becomes a reference to an array in Perl. +.IP "string" 4 +.IX Item "string" +A \s-1JSON\s0 string becomes a string scalar in Perl \- Unicode codepoints in \s-1JSON\s0 +are represented by the same codepoints in the Perl string, so no manual +decoding is necessary. +.IP "number" 4 +.IX Item "number" +A \s-1JSON\s0 number becomes either an integer, numeric (floating point) or +string scalar in perl, depending on its range and any fractional parts. On +the Perl level, there is no difference between those as Perl handles all +the conversion details, but an integer may take slightly less memory and +might represent more values exactly than floating point numbers. +.Sp +If the number consists of digits only, \f(CW\*(C`JSON\*(C'\fR will try to represent +it as an integer value. If that fails, it will try to represent it as +a numeric (floating point) value if that is possible without loss of +precision. Otherwise it will preserve the number as a string value (in +which case you lose roundtripping ability, as the \s-1JSON\s0 number will be +re-encoded to a \s-1JSON\s0 string). +.Sp +Numbers containing a fractional or exponential part will always be +represented as numeric (floating point) values, possibly at a loss of +precision (in which case you might lose perfect roundtripping ability, but +the \s-1JSON\s0 number will still be re-encoded as a \s-1JSON\s0 number). +.Sp +Note that precision is not accuracy \- binary floating point values cannot +represent most decimal fractions exactly, and when converting from and to +floating point, \f(CW\*(C`JSON\*(C'\fR only guarantees precision up to but not including +the least significant bit. +.Sp +When \f(CW\*(C`allow_bignum\*(C'\fR is enable, the big integers +and the numeric can be optionally converted into Math::BigInt and +Math::BigFloat objects. +.IP "true, false" 4 +.IX Item "true, false" +These \s-1JSON\s0 atoms become \f(CW\*(C`JSON::PP::true\*(C'\fR and \f(CW\*(C`JSON::PP::false\*(C'\fR, +respectively. They are overloaded to act almost exactly like the numbers +\&\f(CW1\fR and \f(CW0\fR. You can check whether a scalar is a \s-1JSON\s0 boolean by using +the \f(CW\*(C`JSON::is_bool\*(C'\fR function. +.Sp +.Vb 4 +\& print JSON::PP::true . "\en"; +\& => true +\& print JSON::PP::true + 1; +\& => 1 +\& +\& ok(JSON::true eq \*(Aq1\*(Aq); +\& ok(JSON::true == 1); +.Ve +.Sp +\&\f(CW\*(C`JSON\*(C'\fR will install these missing overloading features to the backend modules. +.IP "null" 4 +.IX Item "null" +A \s-1JSON\s0 null atom becomes \f(CW\*(C`undef\*(C'\fR in Perl. +.Sp +\&\f(CW\*(C`JSON::PP::null\*(C'\fR returns \f(CW\*(C`undef\*(C'\fR. +.SS "\s-1PERL\s0 \-> \s-1JSON\s0" +.IX Subsection "PERL -> JSON" +The mapping from Perl to \s-1JSON\s0 is slightly more difficult, as Perl is a +truly typeless language, so we can only guess which \s-1JSON\s0 type is meant by +a Perl value. +.IP "hash references" 4 +.IX Item "hash references" +Perl hash references become \s-1JSON\s0 objects. As there is no inherent ordering +in hash keys (or \s-1JSON\s0 objects), they will usually be encoded in a +pseudo-random order that can change between runs of the same program but +stays generally the same within a single run of a program. \f(CW\*(C`JSON\*(C'\fR +optionally sort the hash keys (determined by the \fIcanonical\fR flag), so +the same data structure will serialise to the same \s-1JSON\s0 text (given same +settings and version of \s-1JSON::XS\s0), but this incurs a runtime overhead +and is only rarely useful, e.g. when you want to compare some \s-1JSON\s0 text +against another for equality. +.IP "array references" 4 +.IX Item "array references" +Perl array references become \s-1JSON\s0 arrays. +.IP "other references" 4 +.IX Item "other references" +Other unblessed references are generally not allowed and will cause an +exception to be thrown, except for references to the integers \f(CW0\fR and +\&\f(CW1\fR, which get turned into \f(CW\*(C`false\*(C'\fR and \f(CW\*(C`true\*(C'\fR atoms in \s-1JSON\s0. You can +also use \f(CW\*(C`JSON::false\*(C'\fR and \f(CW\*(C`JSON::true\*(C'\fR to improve readability. +.Sp +.Vb 1 +\& to_json [\e0,JSON::PP::true] # yields [false,true] +.Ve +.IP "JSON::PP::true, JSON::PP::false, JSON::PP::null" 4 +.IX Item "JSON::PP::true, JSON::PP::false, JSON::PP::null" +These special values become \s-1JSON\s0 true and \s-1JSON\s0 false values, +respectively. You can also use \f(CW\*(C`\e1\*(C'\fR and \f(CW\*(C`\e0\*(C'\fR directly if you want. +.Sp +JSON::PP::null returns \f(CW\*(C`undef\*(C'\fR. +.IP "blessed objects" 4 +.IX Item "blessed objects" +Blessed objects are not directly representable in \s-1JSON\s0. See the +\&\f(CW\*(C`allow_blessed\*(C'\fR and \f(CW\*(C`convert_blessed\*(C'\fR methods on various options on +how to deal with this: basically, you can choose between throwing an +exception, encoding the reference as if it weren't blessed, or provide +your own serialiser method. +.Sp +See to convert_blessed. +.IP "simple scalars" 4 +.IX Item "simple scalars" +Simple Perl scalars (any scalar that is not a reference) are the most +difficult objects to encode: \s-1JSON::XS\s0 and \s-1JSON::PP\s0 will encode undefined scalars as +\&\s-1JSON\s0 \f(CW\*(C`null\*(C'\fR values, scalars that have last been used in a string context +before encoding as \s-1JSON\s0 strings, and anything else as number value: +.Sp +.Vb 4 +\& # dump as number +\& encode_json [2] # yields [2] +\& encode_json [\-3.0e17] # yields [\-3e+17] +\& my $value = 5; encode_json [$value] # yields [5] +\& +\& # used as string, so dump as string +\& print $value; +\& encode_json [$value] # yields ["5"] +\& +\& # undef becomes null +\& encode_json [undef] # yields [null] +.Ve +.Sp +You can force the type to be a string by stringifying it: +.Sp +.Vb 4 +\& my $x = 3.1; # some variable containing a number +\& "$x"; # stringified +\& $x .= ""; # another, more awkward way to stringify +\& print $x; # perl does it for you, too, quite often +.Ve +.Sp +You can force the type to be a number by numifying it: +.Sp +.Vb 3 +\& my $x = "3"; # some variable containing a string +\& $x += 0; # numify it, ensuring it will be dumped as a number +\& $x *= 1; # same thing, the choice is yours. +.Ve +.Sp +You can not currently force the type in other, less obscure, ways. +.Sp +Note that numerical precision has the same meaning as under Perl (so +binary to decimal conversion follows the same rules as in Perl, which +can differ to other languages). Also, your perl interpreter might expose +extensions to the floating point numbers of your platform, such as +infinities or NaN's \- these cannot be represented in \s-1JSON\s0, and it is an +error to pass those in. +.IP "Big Number" 4 +.IX Item "Big Number" +When \f(CW\*(C`allow_bignum\*(C'\fR is enable, +\&\f(CW\*(C`encode\*(C'\fR converts \f(CW\*(C`Math::BigInt\*(C'\fR objects and \f(CW\*(C`Math::BigFloat\*(C'\fR +objects into \s-1JSON\s0 numbers. +.SH "UNICODE HANDLING ON PERLS" +.IX Header "UNICODE HANDLING ON PERLS" +If you do not know about Unicode on Perl well, +please check \*(L"A \s-1FEW\s0 \s-1NOTES\s0 \s-1ON\s0 \s-1UNICODE\s0 \s-1AND\s0 \s-1PERL\s0\*(R" in \s-1JSON::XS\s0. +.SS "Perl 5.8 and later" +.IX Subsection "Perl 5.8 and later" +Perl can handle Unicode and the \s-1JSON::PP\s0 de/encode methods also work properly. +.PP +.Vb 2 +\& $json\->allow_nonref\->encode(chr hex 3042); +\& $json\->allow_nonref\->encode(chr hex 12345); +.Ve +.PP +Returns \f(CW"\eu3042"\fR and \f(CW"\eud808\eudf45"\fR respectively. +.PP +.Vb 2 +\& $json\->allow_nonref\->decode(\*(Aq"\eu3042"\*(Aq); +\& $json\->allow_nonref\->decode(\*(Aq"\eud808\eudf45"\*(Aq); +.Ve +.PP +Returns \s-1UTF\-8\s0 encoded strings with \s-1UTF8\s0 flag, regarded as \f(CW\*(C`U+3042\*(C'\fR and \f(CW\*(C`U+12345\*(C'\fR. +.PP +Note that the versions from Perl 5.8.0 to 5.8.2, Perl built-in \f(CW\*(C`join\*(C'\fR was broken, +so \s-1JSON::PP\s0 wraps the \f(CW\*(C`join\*(C'\fR with a subroutine. Thus \s-1JSON::PP\s0 works slow in the versions. +.SS "Perl 5.6" +.IX Subsection "Perl 5.6" +Perl can handle Unicode and the \s-1JSON::PP\s0 de/encode methods also work. +.SS "Perl 5.005" +.IX Subsection "Perl 5.005" +Perl 5.005 is a byte semantics world \*(-- all strings are sequences of bytes. +That means the unicode handling is not available. +.PP +In encoding, +.PP +.Vb 2 +\& $json\->allow_nonref\->encode(chr hex 3042); # hex 3042 is 12354. +\& $json\->allow_nonref\->encode(chr hex 12345); # hex 12345 is 74565. +.Ve +.PP +Returns \f(CW\*(C`B\*(C'\fR and \f(CW\*(C`E\*(C'\fR, as \f(CW\*(C`chr\*(C'\fR takes a value more than 255, it treats +as \f(CW\*(C`$value % 256\*(C'\fR, so the above codes are equivalent to : +.PP +.Vb 2 +\& $json\->allow_nonref\->encode(chr 66); +\& $json\->allow_nonref\->encode(chr 69); +.Ve +.PP +In decoding, +.PP +.Vb 1 +\& $json\->decode(\*(Aq"\eu00e3\eu0081\eu0082"\*(Aq); +.Ve +.PP +The returned is a byte sequence \f(CW\*(C`0xE3 0x81 0x82\*(C'\fR for \s-1UTF\-8\s0 encoded +japanese character (\f(CW\*(C`HIRAGANA LETTER A\*(C'\fR). +And if it is represented in Unicode code point, \f(CW\*(C`U+3042\*(C'\fR. +.PP +Next, +.PP +.Vb 1 +\& $json\->decode(\*(Aq"\eu3042"\*(Aq); +.Ve +.PP +We ordinary expect the returned value is a Unicode character \f(CW\*(C`U+3042\*(C'\fR. +But here is 5.005 world. This is \f(CW\*(C`0xE3 0x81 0x82\*(C'\fR. +.PP +.Vb 1 +\& $json\->decode(\*(Aq"\eud808\eudf45"\*(Aq); +.Ve +.PP +This is not a character \f(CW\*(C`U+12345\*(C'\fR but bytes \- \f(CW\*(C`0xf0 0x92 0x8d 0x85\*(C'\fR. +.SH "TODO" +.IX Header "TODO" +.IP "speed" 4 +.IX Item "speed" +.PD 0 +.IP "memory saving" 4 +.IX Item "memory saving" +.PD +.SH "SEE ALSO" +.IX Header "SEE ALSO" +Most of the document are copied and modified from \s-1JSON::XS\s0 doc. +.PP +\&\s-1JSON::XS\s0 +.PP +\&\s-1RFC4627\s0 (<http://www.ietf.org/rfc/rfc4627.txt>) +.SH "AUTHOR" +.IX Header "AUTHOR" +Makamaka Hannyaharamitu, <makamaka[at]cpan.org> +.SH "COPYRIGHT AND LICENSE" +.IX Header "COPYRIGHT AND LICENSE" +Copyright 2007\-2012 by Makamaka Hannyaharamitu +.PP +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. diff --git a/third_party/JSON/out/man/man3/JSON__backportPP__Boolean.3pm b/third_party/JSON/out/man/man3/JSON__backportPP__Boolean.3pm new file mode 100644 index 0000000..9ddc65d --- /dev/null +++ b/third_party/JSON/out/man/man3/JSON__backportPP__Boolean.3pm @@ -0,0 +1,146 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON::backportPP::Boolean 3pm" +.TH JSON::backportPP::Boolean 3pm "2013-04-05" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON::PP::Boolean \- dummy module providing JSON::PP::Boolean +.SH "SYNOPSIS" +.IX Header "SYNOPSIS" +.Vb 1 +\& # do not "use" yourself +.Ve +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +This module exists only to provide overload resolution for Storable +and similar modules. See \s-1JSON::PP\s0 for more info about this class. +.SH "AUTHOR" +.IX Header "AUTHOR" +This idea is from JSON::XS::Boolean written by +Marc Lehmann <schmorp[at]schmorp.de> diff --git a/third_party/JSON/out/man/man3/JSON__backportPP__Compat5005.3pm b/third_party/JSON/out/man/man3/JSON__backportPP__Compat5005.3pm new file mode 100644 index 0000000..5796269 --- /dev/null +++ b/third_party/JSON/out/man/man3/JSON__backportPP__Compat5005.3pm @@ -0,0 +1,145 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON::backportPP::Compat5005 3pm" +.TH JSON::backportPP::Compat5005 3pm "2013-04-05" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON::PP5005 \- Helper module in using JSON::PP in Perl 5.005 +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +\&\s-1JSON::PP\s0 calls internally. +.SH "AUTHOR" +.IX Header "AUTHOR" +Makamaka Hannyaharamitu, <makamaka[at]cpan.org> +.SH "COPYRIGHT AND LICENSE" +.IX Header "COPYRIGHT AND LICENSE" +Copyright 2007\-2012 by Makamaka Hannyaharamitu +.PP +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. diff --git a/third_party/JSON/out/man/man3/JSON__backportPP__Compat5006.3pm b/third_party/JSON/out/man/man3/JSON__backportPP__Compat5006.3pm new file mode 100644 index 0000000..3186e73 --- /dev/null +++ b/third_party/JSON/out/man/man3/JSON__backportPP__Compat5006.3pm @@ -0,0 +1,145 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. \*(C+ will +.\" give a nicer C++. Capital omega is used to do unbreakable dashes and +.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, +.\" nothing in troff, for use with C<>. +.tr \(*W- +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "JSON::backportPP::Compat5006 3pm" +.TH JSON::backportPP::Compat5006 3pm "2013-04-05" "perl v5.14.2" "User Contributed Perl Documentation" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +JSON::PP56 \- Helper module in using JSON::PP in Perl 5.6 +.SH "DESCRIPTION" +.IX Header "DESCRIPTION" +\&\s-1JSON::PP\s0 calls internally. +.SH "AUTHOR" +.IX Header "AUTHOR" +Makamaka Hannyaharamitu, <makamaka[at]cpan.org> +.SH "COPYRIGHT AND LICENSE" +.IX Header "COPYRIGHT AND LICENSE" +Copyright 2007\-2012 by Makamaka Hannyaharamitu +.PP +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. |