diff options
| author | Jocelyn Turcotte <jocelyn.turcotte@digia.com> | 2014-08-08 14:30:41 +0200 |
|---|---|---|
| committer | Jocelyn Turcotte <jocelyn.turcotte@digia.com> | 2014-08-12 13:49:54 +0200 |
| commit | ab0a50979b9eb4dfa3320eff7e187e41efedf7a9 (patch) | |
| tree | 498dfb8a97ff3361a9f7486863a52bb4e26bb898 /chromium/third_party/JSON | |
| parent | 4ce69f7403811819800e7c5ae1318b2647e778d1 (diff) | |
Update Chromium to beta version 37.0.2062.68
Change-Id: I188e3b5aff1bec75566014291b654eb19f5bc8ca
Reviewed-by: Andras Becsi <andras.becsi@digia.com>
Diffstat (limited to 'chromium/third_party/JSON')
109 files changed, 0 insertions, 30655 deletions
diff --git a/chromium/third_party/JSON/JSON-2.59.tar.gz.sha1 b/chromium/third_party/JSON/JSON-2.59.tar.gz.sha1 deleted file mode 100644 index a2772e0c511..00000000000 --- a/chromium/third_party/JSON/JSON-2.59.tar.gz.sha1 +++ /dev/null @@ -1 +0,0 @@ -8a82c442088ffa0d605747fd5e65f51e037aad94 JSON-2.59.tar.gz diff --git a/chromium/third_party/JSON/JSON-2.59/Changes b/chromium/third_party/JSON/JSON-2.59/Changes deleted file mode 100644 index ee2e784b6d1..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/Changes +++ /dev/null @@ -1,372 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/MANIFEST b/chromium/third_party/JSON/JSON-2.59/MANIFEST deleted file mode 100644 index d4f803b5344..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/MANIFEST +++ /dev/null @@ -1,71 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/META.json b/chromium/third_party/JSON/JSON-2.59/META.json deleted file mode 100644 index 8f023469f7e..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/META.json +++ /dev/null @@ -1,49 +0,0 @@ -{ - "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/chromium/third_party/JSON/JSON-2.59/META.yml b/chromium/third_party/JSON/JSON-2.59/META.yml deleted file mode 100644 index c85fce1c02c..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/META.yml +++ /dev/null @@ -1,26 +0,0 @@ ---- -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/chromium/third_party/JSON/JSON-2.59/MYMETA.yml b/chromium/third_party/JSON/JSON-2.59/MYMETA.yml deleted file mode 100644 index 2b513fd367e..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/MYMETA.yml +++ /dev/null @@ -1,27 +0,0 @@ ---- -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/chromium/third_party/JSON/JSON-2.59/Makefile b/chromium/third_party/JSON/JSON-2.59/Makefile deleted file mode 100644 index 62326eff50e..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/Makefile +++ /dev/null @@ -1,823 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/Makefile.PL b/chromium/third_party/JSON/JSON-2.59/Makefile.PL deleted file mode 100644 index a14ee3c7713..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/Makefile.PL +++ /dev/null @@ -1,77 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/README b/chromium/third_party/JSON/JSON-2.59/README deleted file mode 100644 index 839c46212f4..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/README +++ /dev/null @@ -1,1566 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/blib/arch/.exists b/chromium/third_party/JSON/JSON-2.59/blib/arch/.exists deleted file mode 100644 index e69de29bb2d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/arch/.exists +++ /dev/null diff --git a/chromium/third_party/JSON/JSON-2.59/blib/arch/auto/JSON/.exists b/chromium/third_party/JSON/JSON-2.59/blib/arch/auto/JSON/.exists deleted file mode 100644 index e69de29bb2d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/arch/auto/JSON/.exists +++ /dev/null diff --git a/chromium/third_party/JSON/JSON-2.59/blib/bin/.exists b/chromium/third_party/JSON/JSON-2.59/blib/bin/.exists deleted file mode 100644 index e69de29bb2d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/bin/.exists +++ /dev/null diff --git a/chromium/third_party/JSON/JSON-2.59/blib/lib/.exists b/chromium/third_party/JSON/JSON-2.59/blib/lib/.exists deleted file mode 100644 index e69de29bb2d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/lib/.exists +++ /dev/null diff --git a/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON.pm b/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON.pm deleted file mode 100644 index bd39cd8c746..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON.pm +++ /dev/null @@ -1,2292 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP.pm b/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP.pm deleted file mode 100644 index cdf0c76df1b..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP.pm +++ /dev/null @@ -1,2803 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Boolean.pm b/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Boolean.pm deleted file mode 100644 index 38be6a3817b..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Boolean.pm +++ /dev/null @@ -1,27 +0,0 @@ -=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/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5005.pm b/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5005.pm deleted file mode 100644 index 139990edff0..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5005.pm +++ /dev/null @@ -1,131 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5006.pm b/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5006.pm deleted file mode 100644 index 7736fd8debc..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/lib/JSON/backportPP/Compat5006.pm +++ /dev/null @@ -1,173 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/blib/lib/auto/JSON/.exists b/chromium/third_party/JSON/JSON-2.59/blib/lib/auto/JSON/.exists deleted file mode 100644 index e69de29bb2d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/lib/auto/JSON/.exists +++ /dev/null diff --git a/chromium/third_party/JSON/JSON-2.59/blib/man1/.exists b/chromium/third_party/JSON/JSON-2.59/blib/man1/.exists deleted file mode 100644 index e69de29bb2d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/man1/.exists +++ /dev/null diff --git a/chromium/third_party/JSON/JSON-2.59/blib/man3/.exists b/chromium/third_party/JSON/JSON-2.59/blib/man3/.exists deleted file mode 100644 index e69de29bb2d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/man3/.exists +++ /dev/null diff --git a/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON.3pm b/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON.3pm deleted file mode 100644 index 4a73a04eb77..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON.3pm +++ /dev/null @@ -1,1876 +0,0 @@ -.\" 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/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP.3pm b/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP.3pm deleted file mode 100644 index 60015fbcf00..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP.3pm +++ /dev/null @@ -1,1379 +0,0 @@ -.\" 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/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Boolean.3pm b/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Boolean.3pm deleted file mode 100644 index 9ddc65dcc55..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Boolean.3pm +++ /dev/null @@ -1,146 +0,0 @@ -.\" 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/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5005.3pm b/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5005.3pm deleted file mode 100644 index 57962697798..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5005.3pm +++ /dev/null @@ -1,145 +0,0 @@ -.\" 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/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5006.3pm b/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5006.3pm deleted file mode 100644 index 3186e731477..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/man3/JSON__backportPP__Compat5006.3pm +++ /dev/null @@ -1,145 +0,0 @@ -.\" 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/chromium/third_party/JSON/JSON-2.59/blib/script/.exists b/chromium/third_party/JSON/JSON-2.59/blib/script/.exists deleted file mode 100644 index e69de29bb2d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/blib/script/.exists +++ /dev/null diff --git a/chromium/third_party/JSON/JSON-2.59/eg/bench_decode.pl b/chromium/third_party/JSON/JSON-2.59/eg/bench_decode.pl deleted file mode 100755 index cfa0f5f3e87..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/eg/bench_decode.pl +++ /dev/null @@ -1,70 +0,0 @@ -#!/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/chromium/third_party/JSON/JSON-2.59/eg/bench_encode.pl b/chromium/third_party/JSON/JSON-2.59/eg/bench_encode.pl deleted file mode 100755 index d360a5c3e88..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/eg/bench_encode.pl +++ /dev/null @@ -1,86 +0,0 @@ -#!/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/chromium/third_party/JSON/JSON-2.59/lib/JSON.pm b/chromium/third_party/JSON/JSON-2.59/lib/JSON.pm deleted file mode 100644 index bd39cd8c746..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/lib/JSON.pm +++ /dev/null @@ -1,2292 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP.pm b/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP.pm deleted file mode 100644 index cdf0c76df1b..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP.pm +++ /dev/null @@ -1,2803 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Boolean.pm b/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Boolean.pm deleted file mode 100644 index 38be6a3817b..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Boolean.pm +++ /dev/null @@ -1,27 +0,0 @@ -=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/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5005.pm b/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5005.pm deleted file mode 100644 index 139990edff0..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5005.pm +++ /dev/null @@ -1,131 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5006.pm b/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5006.pm deleted file mode 100644 index 7736fd8debc..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/lib/JSON/backportPP/Compat5006.pm +++ /dev/null @@ -1,173 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/pm_to_blib b/chromium/third_party/JSON/JSON-2.59/pm_to_blib deleted file mode 100644 index e69de29bb2d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/pm_to_blib +++ /dev/null diff --git a/chromium/third_party/JSON/JSON-2.59/t/00_load.t b/chromium/third_party/JSON/JSON-2.59/t/00_load.t deleted file mode 100644 index 916c826b15a..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/00_load.t +++ /dev/null @@ -1,15 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/00_pod.t b/chromium/third_party/JSON/JSON-2.59/t/00_pod.t deleted file mode 100644 index e8e30825130..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/00_pod.t +++ /dev/null @@ -1,8 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/01_utf8.t b/chromium/third_party/JSON/JSON-2.59/t/01_utf8.t deleted file mode 100644 index 442fc4091a0..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/01_utf8.t +++ /dev/null @@ -1,36 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/02_error.t b/chromium/third_party/JSON/JSON-2.59/t/02_error.t deleted file mode 100644 index 0c757d357c8..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/02_error.t +++ /dev/null @@ -1,51 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/03_types.t b/chromium/third_party/JSON/JSON-2.59/t/03_types.t deleted file mode 100644 index f22c09bcca5..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/03_types.t +++ /dev/null @@ -1,60 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/06_pc_pretty.t b/chromium/third_party/JSON/JSON-2.59/t/06_pc_pretty.t deleted file mode 100644 index 8c90e288114..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/06_pc_pretty.t +++ /dev/null @@ -1,68 +0,0 @@ - -# 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/chromium/third_party/JSON/JSON-2.59/t/07_pc_esc.t b/chromium/third_party/JSON/JSON-2.59/t/07_pc_esc.t deleted file mode 100644 index d5158019ab8..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/07_pc_esc.t +++ /dev/null @@ -1,93 +0,0 @@ -# -# このファイルのエンコーディングは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/chromium/third_party/JSON/JSON-2.59/t/08_pc_base.t b/chromium/third_party/JSON/JSON-2.59/t/08_pc_base.t deleted file mode 100644 index ca060920c4b..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/08_pc_base.t +++ /dev/null @@ -1,99 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/09_pc_extra_number.t b/chromium/third_party/JSON/JSON-2.59/t/09_pc_extra_number.t deleted file mode 100644 index ce60ee59cfb..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/09_pc_extra_number.t +++ /dev/null @@ -1,39 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/10_pc_keysort.t b/chromium/third_party/JSON/JSON-2.59/t/10_pc_keysort.t deleted file mode 100644 index 823e5a6842a..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/10_pc_keysort.t +++ /dev/null @@ -1,20 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/11_pc_expo.t b/chromium/third_party/JSON/JSON-2.59/t/11_pc_expo.t deleted file mode 100644 index 5e587d8c103..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/11_pc_expo.t +++ /dev/null @@ -1,47 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/12_blessed.t b/chromium/third_party/JSON/JSON-2.59/t/12_blessed.t deleted file mode 100644 index ddd79077965..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/12_blessed.t +++ /dev/null @@ -1,53 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/13_limit.t b/chromium/third_party/JSON/JSON-2.59/t/13_limit.t deleted file mode 100644 index 4ca8b0c363b..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/13_limit.t +++ /dev/null @@ -1,34 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/14_latin1.t b/chromium/third_party/JSON/JSON-2.59/t/14_latin1.t deleted file mode 100644 index 238a88b9c34..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/14_latin1.t +++ /dev/null @@ -1,27 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/15_prefix.t b/chromium/third_party/JSON/JSON-2.59/t/15_prefix.t deleted file mode 100644 index 3071be277f8..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/15_prefix.t +++ /dev/null @@ -1,16 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/16_tied.t b/chromium/third_party/JSON/JSON-2.59/t/16_tied.t deleted file mode 100644 index 50d7272b4b2..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/16_tied.t +++ /dev/null @@ -1,23 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/17_relaxed.t b/chromium/third_party/JSON/JSON-2.59/t/17_relaxed.t deleted file mode 100644 index e87a966593f..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/17_relaxed.t +++ /dev/null @@ -1,30 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/18_json_checker.t b/chromium/third_party/JSON/JSON-2.59/t/18_json_checker.t deleted file mode 100644 index 5b9945abeb2..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/18_json_checker.t +++ /dev/null @@ -1,174 +0,0 @@ - -# 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/chromium/third_party/JSON/JSON-2.59/t/19_incr.t b/chromium/third_party/JSON/JSON-2.59/t/19_incr.t deleted file mode 100644 index 771a01ace26..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/19_incr.t +++ /dev/null @@ -1,182 +0,0 @@ - -# 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/chromium/third_party/JSON/JSON-2.59/t/20_unknown.t b/chromium/third_party/JSON/JSON-2.59/t/20_unknown.t deleted file mode 100644 index 7686929ee0a..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/20_unknown.t +++ /dev/null @@ -1,54 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/21_evans_bugrep.t b/chromium/third_party/JSON/JSON-2.59/t/21_evans_bugrep.t deleted file mode 100644 index 2e6200da67e..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/21_evans_bugrep.t +++ /dev/null @@ -1,50 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/22_comment_at_eof.t b/chromium/third_party/JSON/JSON-2.59/t/22_comment_at_eof.t deleted file mode 100644 index a388a78d78c..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/22_comment_at_eof.t +++ /dev/null @@ -1,47 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/99_binary.t b/chromium/third_party/JSON/JSON-2.59/t/99_binary.t deleted file mode 100644 index 254b08ea7fa..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/99_binary.t +++ /dev/null @@ -1,53 +0,0 @@ -# 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/chromium/third_party/JSON/JSON-2.59/t/_unicode_handling.pm b/chromium/third_party/JSON/JSON-2.59/t/_unicode_handling.pm deleted file mode 100644 index 28e0861d2e4..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/_unicode_handling.pm +++ /dev/null @@ -1,28 +0,0 @@ -#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/chromium/third_party/JSON/JSON-2.59/t/e00_func.t b/chromium/third_party/JSON/JSON-2.59/t/e00_func.t deleted file mode 100644 index c291d059afe..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e00_func.t +++ /dev/null @@ -1,17 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e01_property.t b/chromium/third_party/JSON/JSON-2.59/t/e01_property.t deleted file mode 100644 index 2418ff354ad..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e01_property.t +++ /dev/null @@ -1,67 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e02_bool.t b/chromium/third_party/JSON/JSON-2.59/t/e02_bool.t deleted file mode 100644 index 12b7eb0d5d1..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e02_bool.t +++ /dev/null @@ -1,32 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e03_bool2.t b/chromium/third_party/JSON/JSON-2.59/t/e03_bool2.t deleted file mode 100644 index 9daee6bbf52..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e03_bool2.t +++ /dev/null @@ -1,43 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/e04_sortby.t b/chromium/third_party/JSON/JSON-2.59/t/e04_sortby.t deleted file mode 100644 index 853b2603562..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e04_sortby.t +++ /dev/null @@ -1,24 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e05_esc_slash.t b/chromium/third_party/JSON/JSON-2.59/t/e05_esc_slash.t deleted file mode 100644 index 6e50cb0a64c..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e05_esc_slash.t +++ /dev/null @@ -1,15 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e06_allow_barekey.t b/chromium/third_party/JSON/JSON-2.59/t/e06_allow_barekey.t deleted file mode 100644 index 3aad65d8b7e..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e06_allow_barekey.t +++ /dev/null @@ -1,19 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e07_allow_singlequote.t b/chromium/third_party/JSON/JSON-2.59/t/e07_allow_singlequote.t deleted file mode 100644 index 5591fc4f67d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e07_allow_singlequote.t +++ /dev/null @@ -1,20 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e08_decode.t b/chromium/third_party/JSON/JSON-2.59/t/e08_decode.t deleted file mode 100644 index 3782dfd8832..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e08_decode.t +++ /dev/null @@ -1,41 +0,0 @@ -# -# 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/chromium/third_party/JSON/JSON-2.59/t/e09_encode.t b/chromium/third_party/JSON/JSON-2.59/t/e09_encode.t deleted file mode 100644 index 05acb15fb26..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e09_encode.t +++ /dev/null @@ -1,39 +0,0 @@ -# -# 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/chromium/third_party/JSON/JSON-2.59/t/e10_bignum.t b/chromium/third_party/JSON/JSON-2.59/t/e10_bignum.t deleted file mode 100644 index 5774f7d20ae..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e10_bignum.t +++ /dev/null @@ -1,41 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e11_conv_blessed_univ.t b/chromium/third_party/JSON/JSON-2.59/t/e11_conv_blessed_univ.t deleted file mode 100644 index 18d09d43fb0..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e11_conv_blessed_univ.t +++ /dev/null @@ -1,45 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e12_upgrade.t b/chromium/third_party/JSON/JSON-2.59/t/e12_upgrade.t deleted file mode 100644 index 820eed8be9b..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e12_upgrade.t +++ /dev/null @@ -1,32 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/e13_overloaded_eq.t b/chromium/third_party/JSON/JSON-2.59/t/e13_overloaded_eq.t deleted file mode 100644 index 2956aac0521..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e13_overloaded_eq.t +++ /dev/null @@ -1,65 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e14_decode_prefix.t b/chromium/third_party/JSON/JSON-2.59/t/e14_decode_prefix.t deleted file mode 100644 index 4ba39abf28b..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e14_decode_prefix.t +++ /dev/null @@ -1,28 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e15_tie_ixhash.t b/chromium/third_party/JSON/JSON-2.59/t/e15_tie_ixhash.t deleted file mode 100644 index 9e8991d2f36..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e15_tie_ixhash.t +++ /dev/null @@ -1,44 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e16_incr_parse_fixed.t b/chromium/third_party/JSON/JSON-2.59/t/e16_incr_parse_fixed.t deleted file mode 100644 index d148552e5db..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e16_incr_parse_fixed.t +++ /dev/null @@ -1,28 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/e90_misc.t b/chromium/third_party/JSON/JSON-2.59/t/e90_misc.t deleted file mode 100644 index a5a68182dcb..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/e90_misc.t +++ /dev/null @@ -1,18 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/x00_load.t b/chromium/third_party/JSON/JSON-2.59/t/x00_load.t deleted file mode 100644 index bb870f3bc6d..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/x00_load.t +++ /dev/null @@ -1,14 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/x02_error.t b/chromium/third_party/JSON/JSON-2.59/t/x02_error.t deleted file mode 100644 index b4f9a807302..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/x02_error.t +++ /dev/null @@ -1,61 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/x12_blessed.t b/chromium/third_party/JSON/JSON-2.59/t/x12_blessed.t deleted file mode 100644 index b6df13aef79..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/x12_blessed.t +++ /dev/null @@ -1,54 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/x16_tied.t b/chromium/third_party/JSON/JSON-2.59/t/x16_tied.t deleted file mode 100644 index f219fc21559..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/x16_tied.t +++ /dev/null @@ -1,26 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/x17_strange_overload.t b/chromium/third_party/JSON/JSON-2.59/t/x17_strange_overload.t deleted file mode 100644 index 440bfe24a00..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/x17_strange_overload.t +++ /dev/null @@ -1,20 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/xe01_property.t b/chromium/third_party/JSON/JSON-2.59/t/xe01_property.t deleted file mode 100644 index 6b894cd9600..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe01_property.t +++ /dev/null @@ -1,56 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/xe02_bool.t b/chromium/third_party/JSON/JSON-2.59/t/xe02_bool.t deleted file mode 100644 index 04eacd7533a..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe02_bool.t +++ /dev/null @@ -1,33 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/xe03_bool2.t b/chromium/third_party/JSON/JSON-2.59/t/xe03_bool2.t deleted file mode 100644 index 7d68b32d9b0..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe03_bool2.t +++ /dev/null @@ -1,47 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/xe04support_by_pp.t b/chromium/third_party/JSON/JSON-2.59/t/xe04support_by_pp.t deleted file mode 100644 index f8c88734e2a..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe04support_by_pp.t +++ /dev/null @@ -1,22 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/xe05_indent_length.t b/chromium/third_party/JSON/JSON-2.59/t/xe05_indent_length.t deleted file mode 100644 index fc28fa35103..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe05_indent_length.t +++ /dev/null @@ -1,76 +0,0 @@ -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/chromium/third_party/JSON/JSON-2.59/t/xe08_decode.t b/chromium/third_party/JSON/JSON-2.59/t/xe08_decode.t deleted file mode 100644 index ed78fbbc30f..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe08_decode.t +++ /dev/null @@ -1,45 +0,0 @@ -# -# 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/chromium/third_party/JSON/JSON-2.59/t/xe10_bignum.t b/chromium/third_party/JSON/JSON-2.59/t/xe10_bignum.t deleted file mode 100644 index d72b8ad16e0..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe10_bignum.t +++ /dev/null @@ -1,36 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/xe11_conv_blessed_univ.t b/chromium/third_party/JSON/JSON-2.59/t/xe11_conv_blessed_univ.t deleted file mode 100644 index 8ccc0c1384a..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe11_conv_blessed_univ.t +++ /dev/null @@ -1,48 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/xe12_boolean.t b/chromium/third_party/JSON/JSON-2.59/t/xe12_boolean.t deleted file mode 100644 index 1d790d507d7..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe12_boolean.t +++ /dev/null @@ -1,35 +0,0 @@ - -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/chromium/third_party/JSON/JSON-2.59/t/xe19_xs_and_suportbypp.t b/chromium/third_party/JSON/JSON-2.59/t/xe19_xs_and_suportbypp.t deleted file mode 100644 index 1c9e2f57dc3..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe19_xs_and_suportbypp.t +++ /dev/null @@ -1,33 +0,0 @@ - -# 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/chromium/third_party/JSON/JSON-2.59/t/xe20_croak_message.t b/chromium/third_party/JSON/JSON-2.59/t/xe20_croak_message.t deleted file mode 100644 index 1af44dd0dc7..00000000000 --- a/chromium/third_party/JSON/JSON-2.59/t/xe20_croak_message.t +++ /dev/null @@ -1,21 +0,0 @@ - -# 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/chromium/third_party/JSON/LICENSE b/chromium/third_party/JSON/LICENSE deleted file mode 100644 index ed4ee193685..00000000000 --- a/chromium/third_party/JSON/LICENSE +++ /dev/null @@ -1,1092 +0,0 @@ -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/chromium/third_party/JSON/OWNERS b/chromium/third_party/JSON/OWNERS deleted file mode 100644 index c8840a3da12..00000000000 --- a/chromium/third_party/JSON/OWNERS +++ /dev/null @@ -1,2 +0,0 @@ -haraken@chromium.org -nbarth@chromium.org diff --git a/chromium/third_party/JSON/README.chromium b/chromium/third_party/JSON/README.chromium deleted file mode 100644 index d4b9008f205..00000000000 --- a/chromium/third_party/JSON/README.chromium +++ /dev/null @@ -1,21 +0,0 @@ -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 Android Compatible: yes -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/chromium/third_party/JSON/get_and_build_json_pm.sh b/chromium/third_party/JSON/get_and_build_json_pm.sh deleted file mode 100755 index 9f86967fb79..00000000000 --- a/chromium/third_party/JSON/get_and_build_json_pm.sh +++ /dev/null @@ -1,80 +0,0 @@ -#!/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/chromium/third_party/JSON/out/lib/perl5/JSON.pm b/chromium/third_party/JSON/out/lib/perl5/JSON.pm deleted file mode 100644 index bd39cd8c746..00000000000 --- a/chromium/third_party/JSON/out/lib/perl5/JSON.pm +++ /dev/null @@ -1,2292 +0,0 @@ -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/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP.pm b/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP.pm deleted file mode 100644 index cdf0c76df1b..00000000000 --- a/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP.pm +++ /dev/null @@ -1,2803 +0,0 @@ -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/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP/Boolean.pm b/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP/Boolean.pm deleted file mode 100644 index 38be6a3817b..00000000000 --- a/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP/Boolean.pm +++ /dev/null @@ -1,27 +0,0 @@ -=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/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5005.pm b/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5005.pm deleted file mode 100644 index 139990edff0..00000000000 --- a/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5005.pm +++ /dev/null @@ -1,131 +0,0 @@ -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/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5006.pm b/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5006.pm deleted file mode 100644 index 7736fd8debc..00000000000 --- a/chromium/third_party/JSON/out/lib/perl5/JSON/backportPP/Compat5006.pm +++ /dev/null @@ -1,173 +0,0 @@ -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/chromium/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/auto/JSON/.packlist b/chromium/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/auto/JSON/.packlist deleted file mode 100644 index fa91737a7fd..00000000000 --- a/chromium/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/auto/JSON/.packlist +++ /dev/null @@ -1,14 +0,0 @@ -/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/chromium/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/perllocal.pod b/chromium/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/perllocal.pod deleted file mode 100644 index 5df3e8a0fb0..00000000000 --- a/chromium/third_party/JSON/out/lib/perl5/x86_64-linux-gnu-thread-multi/perllocal.pod +++ /dev/null @@ -1,66 +0,0 @@ -=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/chromium/third_party/JSON/out/man/man3/JSON.3pm b/chromium/third_party/JSON/out/man/man3/JSON.3pm deleted file mode 100644 index 4a73a04eb77..00000000000 --- a/chromium/third_party/JSON/out/man/man3/JSON.3pm +++ /dev/null @@ -1,1876 +0,0 @@ -.\" 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/chromium/third_party/JSON/out/man/man3/JSON__backportPP.3pm b/chromium/third_party/JSON/out/man/man3/JSON__backportPP.3pm deleted file mode 100644 index 60015fbcf00..00000000000 --- a/chromium/third_party/JSON/out/man/man3/JSON__backportPP.3pm +++ /dev/null @@ -1,1379 +0,0 @@ -.\" 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/chromium/third_party/JSON/out/man/man3/JSON__backportPP__Boolean.3pm b/chromium/third_party/JSON/out/man/man3/JSON__backportPP__Boolean.3pm deleted file mode 100644 index 9ddc65dcc55..00000000000 --- a/chromium/third_party/JSON/out/man/man3/JSON__backportPP__Boolean.3pm +++ /dev/null @@ -1,146 +0,0 @@ -.\" 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/chromium/third_party/JSON/out/man/man3/JSON__backportPP__Compat5005.3pm b/chromium/third_party/JSON/out/man/man3/JSON__backportPP__Compat5005.3pm deleted file mode 100644 index 57962697798..00000000000 --- a/chromium/third_party/JSON/out/man/man3/JSON__backportPP__Compat5005.3pm +++ /dev/null @@ -1,145 +0,0 @@ -.\" 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/chromium/third_party/JSON/out/man/man3/JSON__backportPP__Compat5006.3pm b/chromium/third_party/JSON/out/man/man3/JSON__backportPP__Compat5006.3pm deleted file mode 100644 index 3186e731477..00000000000 --- a/chromium/third_party/JSON/out/man/man3/JSON__backportPP__Compat5006.3pm +++ /dev/null @@ -1,145 +0,0 @@ -.\" 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. |