Profile of JSON.pm

Filename	/usr/share/perl5/JSON.pm
Statements	Executed 98 statements in 4.37ms

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
1	1	1	1.65ms	6.40ms	JSON::::_load_xs JSON::_load_xs
1	1	1	527µs	527µs	JSON::::CORE:readline JSON::CORE:readline (opcode)
2	2	1	346µs	438µs	JSON::Boolean::::_overrride_overload JSON::Boolean::_overrride_overload
3	3	3	250µs	305µs	JSON::::import JSON::import
1	1	1	72µs	72µs	JSON::::_set_module JSON::_set_module
1	1	1	35µs	35µs	JSON::::CORE:close JSON::CORE:close (opcode)
1	1	1	20µs	27µs	JSON::Backend::PP::::BEGIN@398JSON::Backend::PP::BEGIN@398
1	1	1	14µs	24µs	JSON::::BEGIN@4 JSON::BEGIN@4
1	1	1	12µs	25µs	JSON::::BEGIN@318 JSON::BEGIN@318
1	1	1	11µs	61µs	JSON::::BEGIN@6 JSON::BEGIN@6
1	1	1	6µs	6µs	JSON::::BEGIN@9 JSON::BEGIN@9
1	1	1	4µs	4µs	JSON::::BEGIN@5 JSON::BEGIN@5
0	0	0	0s	0s	JSON::Backend::PP::::__ANON__[:401]JSON::Backend::PP::__ANON__[:401]
0	0	0	0s	0s	JSON::Backend::PP::::__ANON__[:402]JSON::Backend::PP::__ANON__[:402]
0	0	0	0s	0s	JSON::Backend::PP::::initJSON::Backend::PP::init
0	0	0	0s	0s	JSON::Boolean::::__ANON__[:375] JSON::Boolean::__ANON__[:375]
0	0	0	0s	0s	JSON::Boolean::::__ANON__[:376] JSON::Boolean::__ANON__[:376]
0	0	0	0s	0s	JSON::Boolean::::__ANON__[:382] JSON::Boolean::__ANON__[:382]
0	0	0	0s	0s	JSON::Boolean::::__ANON__[:383] JSON::Boolean::__ANON__[:383]
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::::from_json JSON::from_json
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	40µs	2	35µs	# spent 24µs (14+10) within JSON::BEGIN@4 which was called: # once (14µs+10µs) by C4::Auth::BEGIN@23 at line 4 use strict; # spent 24µs making 1 call to JSON::BEGIN@4 # spent 10µs making 1 call to strict::import
5	2	24µs	1	4µs	# spent 4µs within JSON::BEGIN@5 which was called: # once (4µs+0s) by C4::Auth::BEGIN@23 at line 5 use Carp (); # spent 4µs making 1 call to JSON::BEGIN@5
6	2	128µs	2	112µs	# spent 61µs (11+51) within JSON::BEGIN@6 which was called: # once (11µs+51µs) by C4::Auth::BEGIN@23 at line 6 use base qw(Exporter); # spent 61µs making 1 call to JSON::BEGIN@6 # spent 51µs making 1 call to base::import
7	1	2µs			@JSON::EXPORT = qw(from_json to_json jsonToObj objToJson encode_json decode_json);
8
9					# spent 6µs within JSON::BEGIN@9 which was called: # once (6µs+0s) by C4::Auth::BEGIN@23 at line 13 BEGIN {
10	1	400ns			$JSON::VERSION = '2.61';
11	1	300ns			$JSON::DEBUG = 0 unless (defined $JSON::DEBUG);
12	1	4µs			$JSON::DEBUG = $ENV{ PERL_JSON_DEBUG } if exists $ENV{ PERL_JSON_DEBUG };
13	1	1.54ms	1	6µs	} # spent 6µs making 1 call to JSON::BEGIN@9
14
15	1	300ns			my $Module_XS = 'JSON::XS';
16	1	200ns			my $Module_PP = 'JSON::PP';
17	1	200ns			my $Module_bp = 'JSON::backportPP'; # included in JSON distribution
18	1	100ns			my $PP_Version = '2.27203';
19	1	200ns			my $XS_Version = '2.34';
20
21
22					# XS and PP common methods
23
24	1	2µ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	2µ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	200ns			my @XSOnlyMethods = qw//; # Currently nothing
36
37	1	900ns			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	200ns			my $_INSTALL_DONT_DIE = 1; # When _load_xs fails to load XS, don't die.
45	1	0s			my $_INSTALL_ONLY = 2; # Don't call _set_methods()
46	1	100ns			my $_ALLOW_UNSUPPORTED = 0;
47	1	100ns			my $_UNIV_CONV_BLESSED = 0;
48	1	100ns			my $_USSING_bpPP = 0;
49
50
51					# Check the environment variable to decide worker module.
52
53	1	400ns			unless ($JSON::Backend) {
54	1	100ns			$JSON::DEBUG and Carp::carp("Check used worker module...");
55
56	1	1µs			my $backend = exists $ENV{PERL_JSON_BACKEND} ? $ENV{PERL_JSON_BACKEND} : 1;
57
58	1	3µs	1	6.40ms	if ($backend eq '1' or $backend =~ /JSON::XS\s,\sJSON::PP/) { # spent 6.40ms 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 305µs (250+56) within JSON::import which was called 3 times, avg 102µs/call: # once (109µs+19µs) by C4::Auth::BEGIN@23 at line 23 of C4/Auth.pm # once (76µs+18µs) by Koha::Template::Plugin::AudioAlerts::BEGIN@23 at line 23 of Koha/Template/Plugin/AudioAlerts.pm # once (64µs+19µs) by C4::Search::History::BEGIN@9 at line 9 of C4/Search/History.pm sub import {
78	3	2µs			my $pkg = shift;
79	3	1µs			my @what_to_export;
80					my $no_export;
81
82	3	4µs			for my $tag (@_) {
83	3	2µs			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	3	3µs			push @what_to_export, $tag;
107					}
108
109	3	800ns			return if ($no_export);
110
111	3	301µs	3	56µs	__PACKAGE__->export_to_level(1, $pkg, @what_to_export); # spent 56µs making 3 calls to Exporter::export_to_level, avg 19µs/call
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 = JSON->new;
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					sub from_json ($@) {
159					if ( ref($_[0]) eq 'JSON' or $_[0] eq 'JSON' ) {
160					Carp::croak "from_json should not be called as a method.";
161					}
162					my $json = JSON->new;
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					return $json->decode( $_[0] );
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]->backend eq $Module_XS;
194					}
195
196
197					sub is_pp {
198					return not $_[0]->is_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 6.40ms (1.65+4.75) within JSON::_load_xs which was called: # once (1.65ms+4.75ms) by C4::Auth::BEGIN@23 at line 58 sub _load_xs {
244	1	300ns			my $opt = shift;
245
246	1	200ns			$JSON::DEBUG and Carp::carp "Load $Module_XS.";
247
248					# if called after install module, overload is disable.... why?
249	1	800ns	1	231µs	JSON::Boolean::_overrride_overload($Module_XS); # spent 231µs making 1 call to JSON::Boolean::_overrride_overload
250	1	1µs	1	207µs	JSON::Boolean::_overrride_overload($Module_PP); # spent 207µs making 1 call to JSON::Boolean::_overrride_overload
251
252	1	44µs			eval qq\| # spent 220µs executing statements in string eval # includes 1.55ms spent executing 1 call to 1 sub defined therein.
253					use $Module_XS $XS_Version ();
254					\|;
255
256	1	400ns			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	1	1µs			unless (defined $opt and $opt & $_INSTALL_ONLY) {
265	1	3µs	1	72µs	_set_module( $JSON::Backend = $Module_XS ); # spent 72µs making 1 call to JSON::_set_module
266	1	680µs	1	527µs	my $data = join("", <DATA>); # this code is from Jcode 2.xx. # spent 527µs making 1 call to JSON::CORE:readline
267	1	40µs	1	35µs	close(DATA); # spent 35µs making 1 call to JSON::CORE:close
268	1	339µs			eval $data; # spent 1.26ms executing statements in string eval # includes 89µs spent executing 7 calls to 21 subs defined therein.
269	1	4µs	1	19µs	JSON::Backend::XS->init; # spent 19µs making 1 call to JSON::Backend::XS::init
270					}
271
272	1	3µs			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 redefines 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 72µs within JSON::_set_module which was called: # once (72µs+0s) by JSON::_load_xs at line 265 sub _set_module {
313	1	500ns			return if defined $JSON::true;
314
315	1	500ns			my $module = shift;
316
317	1	3µs			local $^W;
318	2	572µs	2	39µs	# spent 25µs (12+14) within JSON::BEGIN@318 which was called: # once (12µs+14µs) by C4::Auth::BEGIN@23 at line 318 no strict qw(refs); # spent 25µs making 1 call to JSON::BEGIN@318 # spent 14µs making 1 call to strict::unimport
319
320	1	2µs			$JSON::true = ${"$module\::true"};
321	1	1µs			$JSON::false = ${"$module\::false"};
322
323	1	13µs			push @JSON::ISA, $module;
324	1	7µs			push @{"$module\::Boolean::ISA"}, qw(JSON::Boolean);
325
326	1	4µs			*{"JSON::is_bool"} = \&{"$module\::is_bool"};
327
328	1	2µs			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	37µs			};
333					}
334
335	1	5µs			return 1;
336					}
337
- -
340					#
341					# JSON Boolean
342					#
343
344					package JSON::Boolean;
345
346	1	300ns			my %Installed;
347
348					# spent 438µs (346+92) within JSON::Boolean::_overrride_overload which was called 2 times, avg 219µs/call: # once (173µs+58µs) by JSON::_load_xs at line 249 # once (173µs+34µs) by JSON::_load_xs at line 250 sub _overrride_overload {
349	2	2µs			return if ($Installed{ $_[0] }++);
350
351	2	2µs			my $boolean = $_[0] . '::Boolean';
352
353	2	335µs			eval sprintf(q\| # spent 57µs executing statements in string eval # includes 23µs spent executing 1 call to 3 subs defined therein. # spent 38µs executing statements in string eval # includes 14µ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	2	200ns			if ($@) { Carp::croak $@; }
370
371	2	3µs			if ( exists $INC{'JSON/XS.pm'} and $boolean eq 'JSON::XS::Boolean' ) {
372					local $^W;
373					my $true = do { bless \(my $dummy = 1), $boolean };
374					my $false = do { bless \(my $dummy = 0), $boolean };
375					*JSON::XS::true = sub () { $true };
376					*JSON::XS::false = sub () { $false };
377					}
378					elsif ( exists $INC{'JSON/PP.pm'} and $boolean eq 'JSON::PP::Boolean' ) {
379					local $^W;
380					my $true = do { bless \(my $dummy = 1), $boolean };
381					my $false = do { bless \(my $dummy = 0), $boolean };
382					*JSON::PP::true = sub { $true };
383					*JSON::PP::false = sub { $false };
384					}
385
386	2	10µs			return 1;
387					}
388
389
390					#
391					# Helper classes for Backend Module (PP)
392					#
393
394					package JSON::Backend::PP;
395
396					sub init {
397					local $^W;
398	2	163µs	2	34µs	# spent 27µs (20+7) within JSON::Backend::PP::BEGIN@398 which was called: # once (20µs+7µs) by C4::Auth::BEGIN@23 at line 398 no strict qw(refs); # this routine may be called after JSON::Backend::XS init was called. # spent 27µs making 1 call to JSON::Backend::PP::BEGIN@398 # spent 7µs making 1 call to strict::unimport
399					*{"JSON::decode_json"} = \&{"JSON::PP::decode_json"};
400					*{"JSON::encode_json"} = \&{"JSON::PP::encode_json"};
401					*{"JSON::PP::is_xs"} = sub { 0 };
402					*{"JSON::PP::is_pp"} = sub { 1 };
403					return 1;
404					}
405
406					#
407					# To save memory, the below lines are read only when XS backend is used.
408					#
409
410					package JSON;
411
412	1	25µs			1;
413					__DATA__

					# spent 35µs within JSON::CORE:close which was called: # once (35µs+0s) by JSON::_load_xs at line 267 sub JSON::CORE:close; # opcode
					# spent 527µs within JSON::CORE:readline which was called: # once (527µs+0s) by JSON::_load_xs at line 266 sub JSON::CORE:readline; # opcode