Profile of JSON.pm

← Index
NYTProf Performance Profile «block view•line view•sub view»
For t/app_dpath.t
Run on Tue Jun 5 15:25:28 2012
Reported on Tue Jun 5 15:26:04 2012

Filename | /home/ss5/perl5/perlbrew/perls/perl-5.14.1/lib/site_perl/5.14.1/JSON.pm
Statements | Executed 105 statements in 16.3ms

Subroutines
Calls | P | F | Exclusive Time | Inclusive Time | Subroutine
--- | --- | --- | --- | --- | ---
1 | 1 | 1 | 7.20ms | 33.0ms | JSON::::_load_xs JSON::_load_xs
1 | 1 | 1 | 3.90ms | 4.44ms | JSON::::BEGIN@6 JSON::BEGIN@6
1 | 1 | 1 | 2.23ms | 2.23ms | JSON::::CORE:readline JSON::CORE:readline (opcode)
2 | 2 | 1 | 1.19ms | 1.74ms | JSON::Boolean::::_overrride_overload JSON::Boolean::_overrride_overload
6 | 1 | 1 | 799µs | 1.41ms | JSON::::from_json JSON::from_json
1 | 1 | 1 | 270µs | 270µs | JSON::::_set_module JSON::_set_module
1 | 1 | 1 | 60µs | 491µs | JSON::::import JSON::import
1 | 1 | 1 | 58µs | 75µs | JSON::::BEGIN@4 JSON::BEGIN@4
1 | 1 | 1 | 57µs | 129µs | JSON::::BEGIN@318 JSON::BEGIN@318
1 | 1 | 1 | 33µs | 84µs | JSON::Backend::PP::::BEGIN@383JSON::Backend::PP::BEGIN@383
1 | 1 | 1 | 33µs | 33µs | JSON::::CORE:close JSON::CORE:close (opcode)
1 | 1 | 1 | 23µs | 23µs | JSON::::BEGIN@9 JSON::BEGIN@9
1 | 1 | 1 | 14µs | 14µs | JSON::::BEGIN@5 JSON::BEGIN@5
0 | 0 | 0 | 0s | 0s | JSON::Backend::PP::::__ANON__[:386]JSON::Backend::PP::__ANON__[:386]
0 | 0 | 0 | 0s | 0s | JSON::Backend::PP::::__ANON__[:387]JSON::Backend::PP::__ANON__[:387]
0 | 0 | 0 | 0s | 0s | JSON::Backend::PP::::initJSON::Backend::PP::init
0 | 0 | 0 | 0s | 0s | JSON::::__ANON__[:332] JSON::__ANON__[:332]
0 | 0 | 0 | 0s | 0s | JSON::::_load_pp JSON::_load_pp
0 | 0 | 0 | 0s | 0s | JSON::::backend JSON::backend
0 | 0 | 0 | 0s | 0s | JSON::::false JSON::false
0 | 0 | 0 | 0s | 0s | JSON::::is_pp JSON::is_pp
0 | 0 | 0 | 0s | 0s | JSON::::is_xs JSON::is_xs
0 | 0 | 0 | 0s | 0s | JSON::::jsonToObj JSON::jsonToObj
0 | 0 | 0 | 0s | 0s | JSON::::null JSON::null
0 | 0 | 0 | 0s | 0s | JSON::::objToJson JSON::objToJson
0 | 0 | 0 | 0s | 0s | JSON::::property JSON::property
0 | 0 | 0 | 0s | 0s | JSON::::pureperl_only_methods JSON::pureperl_only_methods
0 | 0 | 0 | 0s | 0s | JSON::::require_xs_version JSON::require_xs_version
0 | 0 | 0 | 0s | 0s | JSON::::to_json JSON::to_json
0 | 0 | 0 | 0s | 0s | JSON::::true JSON::true

Call graph for these subroutines as a Graphviz dot language file.

Line | State ments | Time on line | Calls | Time in subs | Code
--- | --- | --- | --- | --- | ---
1 |  |  |  |  | package JSON;
2 |  |  |  |  |
3 |  |  |  |  |
4 | 2 | 93µs | 2 | 92µs | # spent 75µs (58+17) within JSON::BEGIN@4 which was called: # once (58µs+17µs) by main::BEGIN@9 at line 4 use strict; # spent 75µs making 1 call to JSON::BEGIN@4 # spent 17µs making 1 call to strict::import
5 | 2 | 96µs | 1 | 14µs | # spent 14µs within JSON::BEGIN@5 which was called: # once (14µs+0s) by main::BEGIN@9 at line 5 use Carp (); # spent 14µs making 1 call to JSON::BEGIN@5
6 | 2 | 555µs | 2 | 4.76ms | # spent 4.44ms (3.90+540µs) within JSON::BEGIN@6 which was called: # once (3.90ms+540µs) by main::BEGIN@9 at line 6 use base qw(Exporter); # spent 4.44ms making 1 call to JSON::BEGIN@6 # spent 319µs making 1 call to base::import
7 | 1 | 9µs |  |  | @JSON::EXPORT = qw(from_json to_json jsonToObj objToJson encode_json decode_json);
8 |  |  |  |  |
9 |  |  |  |  | # spent 23µs within JSON::BEGIN@9 which was called: # once (23µs+0s) by main::BEGIN@9 at line 13 BEGIN {
10 | 3 | 20µs |  |  | $JSON::VERSION = '2.53';
11 |  |  |  |  | $JSON::DEBUG = 0 unless (defined $JSON::DEBUG);
12 |  |  |  |  | $JSON::DEBUG = $ENV{ PERL_JSON_DEBUG } if exists $ENV{ PERL_JSON_DEBUG };
13 | 1 | 5.72ms | 1 | 23µs | } # spent 23µs making 1 call to JSON::BEGIN@9
14 |  |  |  |  |
15 | 1 | 2µs |  |  | my $Module_XS = 'JSON::XS';
16 | 1 | 1µs |  |  | my $Module_PP = 'JSON::PP';
17 | 1 | 2µs |  |  | my $Module_bp = 'JSON::backportPP'; # included in JSON distribution
18 | 1 | 1µs |  |  | my $PP_Version = '2.27200';
19 | 1 | 1µs |  |  | my $XS_Version = '2.27';
20 |  |  |  |  |
21 |  |  |  |  |
22 |  |  |  |  | # XS and PP common methods
23 |  |  |  |  |
24 | 1 | 14µs |  |  | my @PublicMethods = qw/
25 |  |  |  |  | ascii latin1 utf8 pretty indent space_before space_after relaxed canonical allow_nonref
26 |  |  |  |  | allow_blessed convert_blessed filter_json_object filter_json_single_key_object
27 |  |  |  |  | shrink max_depth max_size encode decode decode_prefix allow_unknown
28 |  |  |  |  | /;
29 |  |  |  |  |
30 | 1 | 12µs |  |  | my @Properties = qw/
31 |  |  |  |  | ascii latin1 utf8 indent space_before space_after relaxed canonical allow_nonref
32 |  |  |  |  | allow_blessed convert_blessed shrink max_depth max_size allow_unknown
33 |  |  |  |  | /;
34 |  |  |  |  |
35 | 1 | 1µs |  |  | my @XSOnlyMethods = qw//; # Currently nothing
36 |  |  |  |  |
37 | 1 | 7µs |  |  | my @PPOnlyMethods = qw/
38 |  |  |  |  | indent_length sort_by
39 |  |  |  |  | allow_singlequote allow_bignum loose allow_barekey escape_slash as_nonblessed
40 |  |  |  |  | /; # JSON::PP specific
41 |  |  |  |  |
42 |  |  |  |  |
43 |  |  |  |  | # used in _load_xs and _load_pp ($INSTALL_ONLY is not used currently)
44 | 1 | 1µs |  |  | my $_INSTALL_DONT_DIE = 1; # When _load_xs fails to load XS, don't die.
45 | 1 | 600ns |  |  | my $_INSTALL_ONLY = 2; # Don't call _set_methods()
46 | 1 | 600ns |  |  | my $_ALLOW_UNSUPPORTED = 0;
47 | 1 | 600ns |  |  | my $_UNIV_CONV_BLESSED = 0;
48 | 1 | 600ns |  |  | my $_USSING_bpPP = 0;
49 |  |  |  |  |
50 |  |  |  |  |
51 |  |  |  |  | # Check the environment variable to decide worker module.
52 |  |  |  |  |
53 | 4 | 20µs |  |  | unless ($JSON::Backend) {
54 |  |  |  |  | $JSON::DEBUG and Carp::carp("Check used worker module...");
55 |  |  |  |  |
56 |  |  |  |  | my $backend = exists $ENV{PERL_JSON_BACKEND} ? $ENV{PERL_JSON_BACKEND} : 1;
57 |  |  |  |  |
58 |  |  | 1 | 33.0ms | if ($backend eq '1' or $backend =~ /JSON::XS\s*,\s*JSON::PP/) { # spent 33.0ms making 1 call to JSON::_load_xs
59 |  |  |  |  | _load_xs($_INSTALL_DONT_DIE) or _load_pp();
60 |  |  |  |  | }
61 |  |  |  |  | elsif ($backend eq '0' or $backend eq 'JSON::PP') {
62 |  |  |  |  | _load_pp();
63 |  |  |  |  | }
64 |  |  |  |  | elsif ($backend eq '2' or $backend eq 'JSON::XS') {
65 |  |  |  |  | _load_xs();
66 |  |  |  |  | }
67 |  |  |  |  | elsif ($backend eq 'JSON::backportPP') {
68 |  |  |  |  | $_USSING_bpPP = 1;
69 |  |  |  |  | _load_pp();
70 |  |  |  |  | }
71 |  |  |  |  | else {
72 |  |  |  |  | Carp::croak "The value of environmental variable 'PERL_JSON_BACKEND' is invalid.";
73 |  |  |  |  | }
74 |  |  |  |  | }
75 |  |  |  |  |
76 |  |  |  |  |
77 |  |  |  |  | # spent 491µs (60+431) within JSON::import which was called: # once (60µs+431µs) by main::BEGIN@9 at line 9 of t/app_dpath.t sub import {
78 | 6 | 43µs |  |  | my $pkg = shift;
79 |  |  |  |  | my @what_to_export;
80 |  |  |  |  | my $no_export;
81 |  |  |  |  |
82 |  |  |  |  | for my $tag (@_) {
83 |  |  |  |  | if ($tag eq '-support_by_pp') {
84 |  |  |  |  | if (!$_ALLOW_UNSUPPORTED++) {
85 |  |  |  |  | JSON::Backend::XS
86 |  |  |  |  | ->support_by_pp(@PPOnlyMethods) if ($JSON::Backend eq $Module_XS);
87 |  |  |  |  | }
88 |  |  |  |  | next;
89 |  |  |  |  | }
90 |  |  |  |  | elsif ($tag eq '-no_export') {
91 |  |  |  |  | $no_export++, next;
92 |  |  |  |  | }
93 |  |  |  |  | elsif ( $tag eq '-convert_blessed_universally' ) {
94 |  |  |  |  | eval q|
95 |  |  |  |  | require B;
96 |  |  |  |  | *UNIVERSAL::TO_JSON = sub {
97 |  |  |  |  | my $b_obj = B::svref_2object( $_[0] );
98 |  |  |  |  | return $b_obj->isa('B::HV') ? { %{ $_[0] } }
99 |  |  |  |  | : $b_obj->isa('B::AV') ? [ @{ $_[0] } ]
100 |  |  |  |  | : undef
101 |  |  |  |  | ;
102 |  |  |  |  | }
103 |  |  |  |  | | if ( !$_UNIV_CONV_BLESSED++ );
104 |  |  |  |  | next;
105 |  |  |  |  | }
106 |  |  |  |  | push @what_to_export, $tag;
107 |  |  |  |  | }
108 |  |  |  |  |
109 |  |  |  |  | return if ($no_export);
110 |  |  |  |  |
111 |  |  | 1 | 81µs | __PACKAGE__->export_to_level(1, $pkg, @what_to_export); # spent 81µs making 1 call to Exporter::export_to_level
112 |  |  |  |  | }
113 |  |  |  |  |
114 |  |  |  |  |
115 |  |  |  |  | # OBSOLETED
116 |  |  |  |  |
117 |  |  |  |  | sub jsonToObj {
118 |  |  |  |  | my $alternative = 'from_json';
119 |  |  |  |  | if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) {
120 |  |  |  |  | shift @_; $alternative = 'decode';
121 |  |  |  |  | }
122 |  |  |  |  | Carp::carp "'jsonToObj' will be obsoleted. Please use '$alternative' instead.";
123 |  |  |  |  | return JSON::from_json(@_);
124 |  |  |  |  | };
125 |  |  |  |  |
126 |  |  |  |  | sub objToJson {
127 |  |  |  |  | my $alternative = 'to_json';
128 |  |  |  |  | if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) {
129 |  |  |  |  | shift @_; $alternative = 'encode';
130 |  |  |  |  | }
131 |  |  |  |  | Carp::carp "'objToJson' will be obsoleted. Please use '$alternative' instead.";
132 |  |  |  |  | JSON::to_json(@_);
133 |  |  |  |  | };
134 |  |  |  |  |
135 |  |  |  |  |
136 |  |  |  |  | # INTERFACES
137 |  |  |  |  |
138 |  |  |  |  | sub to_json ($@) {
139 |  |  |  |  | if (
140 |  |  |  |  | ref($_[0]) eq 'JSON'
141 |  |  |  |  | or (@_ > 2 and $_[0] eq 'JSON')
142 |  |  |  |  | ) {
143 |  |  |  |  | Carp::croak "to_json should not be called as a method.";
144 |  |  |  |  | }
145 |  |  |  |  | my $json = new JSON;
146 |  |  |  |  |
147 |  |  |  |  | if (@_ == 2 and ref $_[1] eq 'HASH') {
148 |  |  |  |  | my $opt = $_[1];
149 |  |  |  |  | for my $method (keys %$opt) {
150 |  |  |  |  | $json->$method( $opt->{$method} );
151 |  |  |  |  | }
152 |  |  |  |  | }
153 |  |  |  |  |
154 |  |  |  |  | $json->encode($_[0]);
155 |  |  |  |  | }
156 |  |  |  |  |
157 |  |  |  |  |
158 |  |  |  |  | # spent 1.41ms (799µs+611µs) within JSON::from_json which was called 6 times, avg 235µs/call: # 6 times (799µs+611µs) by main::check at line 28 of t/app_dpath.t, avg 235µs/call sub from_json ($@) {
159 | 24 | 1.31ms |  |  | if ( ref($_[0]) eq 'JSON' or $_[0] eq 'JSON' ) {
160 |  |  |  |  | Carp::croak "from_json should not be called as a method.";
161 |  |  |  |  | }
162 |  |  | 6 | 353µs | my $json = new JSON; # spent 353µs making 6 calls to JSON::XS::new, avg 59µs/call
163 |  |  |  |  |
164 |  |  |  |  | if (@_ == 2 and ref $_[1] eq 'HASH') {
165 |  |  |  |  | my $opt = $_[1];
166 |  |  |  |  | for my $method (keys %$opt) {
167 |  |  |  |  | $json->$method( $opt->{$method} );
168 |  |  |  |  | }
169 |  |  |  |  | }
170 |  |  |  |  |
171 |  |  | 6 | 200µs | return $json->decode( $_[0] ); # spent 200µs making 6 calls to JSON::XS::decode, avg 33µs/call
172 |  |  |  |  | }
173 |  |  |  |  |
174 |  |  |  |  |
175 |  |  |  |  | sub true { $JSON::true }
176 |  |  |  |  |
177 |  |  |  |  | sub false { $JSON::false }
178 |  |  |  |  |
179 |  |  |  |  | sub null { undef; }
180 |  |  |  |  |
181 |  |  |  |  |
182 |  |  |  |  | sub require_xs_version { $XS_Version; }
183 |  |  |  |  |
184 |  |  |  |  | sub backend {
185 |  |  |  |  | my $proto = shift;
186 |  |  |  |  | $JSON::Backend;
187 |  |  |  |  | }
188 |  |  |  |  |
189 |  |  |  |  | #*module = *backend;
190 |  |  |  |  |
191 |  |  |  |  |
192 |  |  |  |  | sub is_xs {
193 |  |  |  |  | return $_[0]->module eq $Module_XS;
194 |  |  |  |  | }
195 |  |  |  |  |
196 |  |  |  |  |
197 |  |  |  |  | sub is_pp {
198 |  |  |  |  | return not $_[0]->xs;
199 |  |  |  |  | }
200 |  |  |  |  |
201 |  |  |  |  |
202 |  |  |  |  | sub pureperl_only_methods { @PPOnlyMethods; }
203 |  |  |  |  |
204 |  |  |  |  |
205 |  |  |  |  | sub property {
206 |  |  |  |  | my ($self, $name, $value) = @_;
207 |  |  |  |  |
208 |  |  |  |  | if (@_ == 1) {
209 |  |  |  |  | my %props;
210 |  |  |  |  | for $name (@Properties) {
211 |  |  |  |  | my $method = 'get_' . $name;
212 |  |  |  |  | if ($name eq 'max_size') {
213 |  |  |  |  | my $value = $self->$method();
214 |  |  |  |  | $props{$name} = $value == 1 ? 0 : $value;
215 |  |  |  |  | next;
216 |  |  |  |  | }
217 |  |  |  |  | $props{$name} = $self->$method();
218 |  |  |  |  | }
219 |  |  |  |  | return \%props;
220 |  |  |  |  | }
221 |  |  |  |  | elsif (@_ > 3) {
222 |  |  |  |  | Carp::croak('property() can take only the option within 2 arguments.');
223 |  |  |  |  | }
224 |  |  |  |  | elsif (@_ == 2) {
225 |  |  |  |  | if ( my $method = $self->can('get_' . $name) ) {
226 |  |  |  |  | if ($name eq 'max_size') {
227 |  |  |  |  | my $value = $self->$method();
228 |  |  |  |  | return $value == 1 ? 0 : $value;
229 |  |  |  |  | }
230 |  |  |  |  | $self->$method();
231 |  |  |  |  | }
232 |  |  |  |  | }
233 |  |  |  |  | else {
234 |  |  |  |  | $self->$name($value);
235 |  |  |  |  | }
236 |  |  |  |  |
237 |  |  |  |  | }
238 |  |  |  |  |
- - |  |  |  |  |
241 |  |  |  |  | # INTERNAL
242 |  |  |  |  |
243 |  |  |  |  | # spent 33.0ms (7.20+25.8) within JSON::_load_xs which was called: # once (7.20ms+25.8ms) by main::BEGIN@9 at line 58 sub _load_xs {
244 | 8 | 175µs |  |  | my $opt = shift;
245 |  |  |  |  |
246 |  |  |  |  | $JSON::DEBUG and Carp::carp "Load $Module_XS.";
247 |  |  |  |  |
248 |  |  |  |  | # if called after install module, overload is disable.... why?
249 |  |  | 1 | 968µs | JSON::Boolean::_overrride_overload($Module_XS); # spent 968µs making 1 call to JSON::Boolean::_overrride_overload
250 |  |  | 1 | 773µs | JSON::Boolean::_overrride_overload($Module_PP); # spent 773µs making 1 call to JSON::Boolean::_overrride_overload
251 |  |  |  |  |
252 |  |  |  |  | eval qq| # spent 778µs executing statements in string eval # includes 6.65ms spent executing 1 call to 1 sub defined therein.
253 |  |  |  |  | use $Module_XS $XS_Version ();
254 |  |  |  |  | |;
255 |  |  |  |  |
256 |  |  |  |  | if ($@) {
257 |  |  |  |  | if (defined $opt and $opt & $_INSTALL_DONT_DIE) {
258 |  |  |  |  | $JSON::DEBUG and Carp::carp "Can't load $Module_XS...($@)";
259 |  |  |  |  | return 0;
260 |  |  |  |  | }
261 |  |  |  |  | Carp::croak $@;
262 |  |  |  |  | }
263 |  |  |  |  |
264 | 5 | 4.96ms |  |  | unless (defined $opt and $opt & $_INSTALL_ONLY) {
265 |  |  | 1 | 270µs | _set_module( $JSON::Backend = $Module_XS ); # spent 270µs making 1 call to JSON::_set_module
266 |  |  | 1 | 2.23ms | my $data = join("", <DATA>); # this code is from Jcode 2.xx. # spent 2.23ms making 1 call to JSON::CORE:readline
267 |  |  | 1 | 33µs | close(DATA); # spent 33µs making 1 call to JSON::CORE:close
268 |  |  |  |  | eval $data; # spent 4.94ms executing statements in string eval # includes 5.02ms spent executing 7 calls to 21 subs defined therein.
269 |  |  | 1 | 102µs | JSON::Backend::XS->init; # spent 102µs making 1 call to JSON::Backend::XS::init
270 |  |  |  |  | }
271 |  |  |  |  |
272 |  |  |  |  | return 1;
273 |  |  |  |  | };
274 |  |  |  |  |
275 |  |  |  |  |
276 |  |  |  |  | sub _load_pp {
277 |  |  |  |  | my $opt = shift;
278 |  |  |  |  | my $backend = $_USSING_bpPP ? $Module_bp : $Module_PP;
279 |  |  |  |  |
280 |  |  |  |  | $JSON::DEBUG and Carp::carp "Load $backend.";
281 |  |  |  |  |
282 |  |  |  |  | # if called after install module, overload is disable.... why?
283 |  |  |  |  | JSON::Boolean::_overrride_overload($Module_XS);
284 |  |  |  |  | JSON::Boolean::_overrride_overload($backend);
285 |  |  |  |  |
286 |  |  |  |  | if ( $_USSING_bpPP ) {
287 |  |  |  |  | eval qq| require $backend |;
288 |  |  |  |  | }
289 |  |  |  |  | else {
290 |  |  |  |  | eval qq| use $backend $PP_Version () |;
291 |  |  |  |  | }
292 |  |  |  |  |
293 |  |  |  |  | if ($@) {
294 |  |  |  |  | if ( $backend eq $Module_PP ) {
295 |  |  |  |  | $JSON::DEBUG and Carp::carp "Can't load $Module_PP ($@), so try to load $Module_bp";
296 |  |  |  |  | $_USSING_bpPP++;
297 |  |  |  |  | $backend = $Module_bp;
298 |  |  |  |  | JSON::Boolean::_overrride_overload($backend);
299 |  |  |  |  | local $^W; # if PP installed but invalid version, backportPP redifines methods.
300 |  |  |  |  | eval qq| require $Module_bp |;
301 |  |  |  |  | }
302 |  |  |  |  | Carp::croak $@ if $@;
303 |  |  |  |  | }
304 |  |  |  |  |
305 |  |  |  |  | unless (defined $opt and $opt & $_INSTALL_ONLY) {
306 |  |  |  |  | _set_module( $JSON::Backend = $Module_PP ); # even if backportPP, set $Backend with 'JSON::PP'
307 |  |  |  |  | JSON::Backend::PP->init;
308 |  |  |  |  | }
309 |  |  |  |  | };
310 |  |  |  |  |
311 |  |  |  |  |
312 |  |  |  |  | # spent 270µs within JSON::_set_module which was called: # once (270µs+0s) by JSON::_load_xs at line 265 sub _set_module {
313 | 10 | 138µs |  |  | return if defined $JSON::true;
314 |  |  |  |  |
315 |  |  |  |  | my $module = shift;
316 |  |  |  |  |
317 |  |  |  |  | local $^W;
318 | 2 | 1.17ms | 2 | 201µs | # spent 129µs (57+72) within JSON::BEGIN@318 which was called: # once (57µs+72µs) by main::BEGIN@9 at line 318 no strict qw(refs); # spent 129µs making 1 call to JSON::BEGIN@318 # spent 72µs making 1 call to strict::unimport
319 |  |  |  |  |
320 |  |  |  |  | $JSON::true = ${"$module\::true"};
321 |  |  |  |  | $JSON::false = ${"$module\::false"};
322 |  |  |  |  |
323 |  |  |  |  | push @JSON::ISA, $module;
324 |  |  |  |  | push @{"$module\::Boolean::ISA"}, qw(JSON::Boolean);
325 |  |  |  |  |
326 |  |  |  |  | *{"JSON::is_bool"} = \&{"$module\::is_bool"};
327 |  |  |  |  |
328 |  |  |  |  | for my $method ($module eq $Module_XS ? @PPOnlyMethods : @XSOnlyMethods) {
329 |  |  |  |  | *{"JSON::$method"} = sub {
330 |  |  |  |  | Carp::carp("$method is not supported in $module.");
331 |  |  |  |  | $_[0];
332 | 8 | 139µs |  |  | };
333 |  |  |  |  | }
334 |  |  |  |  |
335 |  |  |  |  | return 1;
336 |  |  |  |  | }
337 |  |  |  |  |
- - |  |  |  |  |
340 |  |  |  |  | #
341 |  |  |  |  | # JSON Boolean
342 |  |  |  |  | #
343 |  |  |  |  |
344 |  |  |  |  | package JSON::Boolean;
345 |  |  |  |  |
346 | 1 | 2µs |  |  | my %Installed;
347 |  |  |  |  |
348 |  |  |  |  | # spent 1.74ms (1.19+547µs) within JSON::Boolean::_overrride_overload which was called 2 times, avg 871µs/call: # once (605µs+364µs) by JSON::_load_xs at line 249 # once (590µs+183µs) by JSON::_load_xs at line 250 sub _overrride_overload {
349 | 10 | 1.18ms |  |  | return if ($Installed{ $_[0] }++);
350 |  |  |  |  |
351 |  |  |  |  | my $boolean = $_[0] . '::Boolean';
352 |  |  |  |  |
353 |  |  |  |  | eval sprintf(q| # spent 89µs executing statements in string eval # includes 91µs spent executing 1 call to 3 subs defined therein. # spent 60µs executing statements in string eval # includes 67µs spent executing 1 call to 3 subs defined therein.
354 |  |  |  |  | package %s;
355 |  |  |  |  | use overload (
356 |  |  |  |  | '""' => sub { ${$_[0]} == 1 ? 'true' : 'false' },
357 |  |  |  |  | 'eq' => sub {
358 |  |  |  |  | my ($obj, $op) = ref ($_[0]) ? ($_[0], $_[1]) : ($_[1], $_[0]);
359 |  |  |  |  | if ($op eq 'true' or $op eq 'false') {
360 |  |  |  |  | return "$obj" eq 'true' ? 'true' eq $op : 'false' eq $op;
361 |  |  |  |  | }
362 |  |  |  |  | else {
363 |  |  |  |  | return $obj ? 1 == $op : 0 == $op;
364 |  |  |  |  | }
365 |  |  |  |  | },
366 |  |  |  |  | );
367 |  |  |  |  | |, $boolean);
368 |  |  |  |  |
369 |  |  |  |  | if ($@) { Carp::croak $@; }
370 |  |  |  |  |
371 |  |  |  |  | return 1;
372 |  |  |  |  | }
373 |  |  |  |  |
374 |  |  |  |  |
375 |  |  |  |  | #
376 |  |  |  |  | # Helper classes for Backend Module (PP)
377 |  |  |  |  | #
378 |  |  |  |  |
379 |  |  |  |  | package JSON::Backend::PP;
380 |  |  |  |  |
381 |  |  |  |  | sub init {
382 |  |  |  |  | local $^W;
383 | 2 | 492µs | 2 | 135µs | # spent 84µs (33+51) within JSON::Backend::PP::BEGIN@383 which was called: # once (33µs+51µs) by main::BEGIN@9 at line 383 no strict qw(refs); # this routine may be called after JSON::Backend::XS init was called. # spent 84µs making 1 call to JSON::Backend::PP::BEGIN@383 # spent 51µs making 1 call to strict::unimport
384 |  |  |  |  | *{"JSON::decode_json"} = \&{"JSON::PP::decode_json"};
385 |  |  |  |  | *{"JSON::encode_json"} = \&{"JSON::PP::encode_json"};
386 |  |  |  |  | *{"JSON::PP::is_xs"} = sub { 0 };
387 |  |  |  |  | *{"JSON::PP::is_pp"} = sub { 1 };
388 |  |  |  |  | return 1;
389 |  |  |  |  | }
390 |  |  |  |  |
391 |  |  |  |  | #
392 |  |  |  |  | # To save memory, the below lines are read only when XS backend is used.
393 |  |  |  |  | #
394 |  |  |  |  |
395 |  |  |  |  | package JSON;
396 |  |  |  |  |
397 | 1 | 121µs |  |  | 1;
398 |  |  |  |  | __DATA__
|  |  |  |  | # spent 33µs within JSON::CORE:close which was called: # once (33µs+0s) by JSON::_load_xs at line 267 sub JSON::CORE:close; # opcode
|  |  |  |  | # spent 2.23ms within JSON::CORE:readline which was called: # once (2.23ms+0s) by JSON::_load_xs at line 266 sub JSON::CORE:readline; # opcode