Profile of JSON.pm

Filename	/usr/share/perl5/JSON.pm
Statements	Executed 95 statements in 3.79ms

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
1	1	1	1.32ms	25.7ms	JSON::::_load_xs JSON::_load_xs
1	1	1	1.31ms	1.31ms	JSON::::CORE:readline JSON::CORE:readline (opcode)
2	2	1	247µs	318µs	JSON::Boolean::::_overrride_overload JSON::Boolean::_overrride_overload
1	1	1	46µs	46µs	JSON::::_set_module JSON::_set_module
1	1	1	32µs	47µs	JSON::::to_json JSON::to_json
2	2	2	29µs	224µs	JSON::::import JSON::import
1	1	1	11µs	23µs	JSON::::BEGIN@4 JSON::BEGIN@4
1	1	1	10µs	19µs	JSON::Backend::PP::::BEGIN@398JSON::Backend::PP::BEGIN@398
1	1	1	8µs	20µs	JSON::::BEGIN@318 JSON::BEGIN@318
1	1	1	8µs	70µs	JSON::::BEGIN@6 JSON::BEGIN@6
1	1	1	5µs	5µs	JSON::::CORE:close JSON::CORE:close (opcode)
1	1	1	4µs	4µ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::::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	23µs	2	35µs	# spent 23µs (11+12) within JSON::BEGIN@4 which was called: # once (11µs+12µs) by C4::Auth::BEGIN@23 at line 4 use strict; # spent 23µs making 1 call to JSON::BEGIN@4 # spent 12µs making 1 call to strict::import
5	2	19µ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	55µs	2	132µs	# spent 70µs (8+62) within JSON::BEGIN@6 which was called: # once (8µs+62µs) by C4::Auth::BEGIN@23 at line 6 use base qw(Exporter); # spent 70µs making 1 call to JSON::BEGIN@6 # spent 62µs making 1 call to base::import
7	1	1µs			@JSON::EXPORT = qw(from_json to_json jsonToObj objToJson encode_json decode_json);
8
9					# spent 4µs within JSON::BEGIN@9 which was called: # once (4µs+0s) by C4::Auth::BEGIN@23 at line 13 BEGIN {
10	1	300ns			$JSON::VERSION = '2.61';
11	1	200ns			$JSON::DEBUG = 0 unless (defined $JSON::DEBUG);
12	1	3µs			$JSON::DEBUG = $ENV{ PERL_JSON_DEBUG } if exists $ENV{ PERL_JSON_DEBUG };
13	1	1.06ms	1	4µs	} # spent 4µs making 1 call to JSON::BEGIN@9
14
15	1	200ns			my $Module_XS = 'JSON::XS';
16	1	100ns			my $Module_PP = 'JSON::PP';
17	1	100ns			my $Module_bp = 'JSON::backportPP'; # included in JSON distribution
18	1	100ns			my $PP_Version = '2.27203';
19	1	100ns			my $XS_Version = '2.34';
20
21
22					# XS and PP common methods
23
24	1	1µ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	900ns			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	100ns			my @XSOnlyMethods = qw//; # Currently nothing
36
37	1	500ns			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	100ns			my $_INSTALL_DONT_DIE = 1; # When _load_xs fails to load XS, don't die.
45	1	100ns			my $_INSTALL_ONLY = 2; # Don't call _set_methods()
46	1	0s			my $_ALLOW_UNSUPPORTED = 0;
47	1	0s			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	200ns			unless ($JSON::Backend) {
54	1	100ns			$JSON::DEBUG and Carp::carp("Check used worker module...");
55
56	1	700ns			my $backend = exists $ENV{PERL_JSON_BACKEND} ? $ENV{PERL_JSON_BACKEND} : 1;
57
58	1	2µs	1	25.7ms	if ($backend eq '1' or $backend =~ /JSON::XS\s,\sJSON::PP/) { # spent 25.7ms 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 224µs (29+194) within JSON::import which was called 2 times, avg 112µs/call: # once (19µs+116µs) by C4::Auth::BEGIN@23 at line 23 of C4/Auth.pm # once (10µs+79µs) by C4::Output::JSONStream::BEGIN@42 at line 42 of C4/Output/JSONStream.pm sub import {
78	2	1µs			my $pkg = shift;
79	2	700ns			my @what_to_export;
80					my $no_export;
81
82	2	2µs			for my $tag (@_) {
83	2	1µ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	2	1µs			push @what_to_export, $tag;
107					}
108
109	2	500ns			return if ($no_export);
110
111	2	15µs	2	38µs	__PACKAGE__->export_to_level(1, $pkg, @what_to_export); # spent 38µs making 2 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					# spent 47µs (32+15) within JSON::to_json which was called: # once (32µs+15µs) by C4::Output::JSONStream::output at line 71 of C4/Output/JSONStream.pm sub to_json ($@) {
139	1	2µs			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	1	16µs	1	6µs	my $json = JSON->new; # spent 6µs making 1 call to JSON::XS::new
146
147	1	500ns			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	1	30µs	1	8µs	$json->encode($_[0]); # spent 8µs making 1 call to JSON::XS::encode
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 25.7ms (1.32+24.3) within JSON::_load_xs which was called: # once (1.32ms+24.3ms) by C4::Auth::BEGIN@23 at line 58 sub _load_xs {
244	1	200ns			my $opt = shift;
245
246	1	100ns			$JSON::DEBUG and Carp::carp "Load $Module_XS.";
247
248					# if called after install module, overload is disable.... why?
249	1	500ns	1	165µs	JSON::Boolean::_overrride_overload($Module_XS); # spent 165µs making 1 call to JSON::Boolean::_overrride_overload
250	1	800ns	1	153µs	JSON::Boolean::_overrride_overload($Module_PP); # spent 153µs making 1 call to JSON::Boolean::_overrride_overload
251
252	1	36µs			eval qq\| # spent 9.13ms executing statements in string eval # includes 10.1ms spent executing 1 call to 1 sub defined therein.
253					use $Module_XS $XS_Version ();
254					\|;
255
256	1	300ns			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	900ns			unless (defined $opt and $opt & $_INSTALL_ONLY) {
265	1	2µs	1	46µs	_set_module( $JSON::Backend = $Module_XS ); # spent 46µs making 1 call to JSON::_set_module
266	1	1.43ms	1	1.31ms	my $data = join("", <DATA>); # this code is from Jcode 2.xx. # spent 1.31ms making 1 call to JSON::CORE:readline
267	1	11µs	1	5µs	close(DATA); # spent 5µs making 1 call to JSON::CORE:close
268	1	273µs			eval $data; # spent 912µs executing statements in string eval # includes 68µs spent executing 7 calls to 21 subs defined therein.
269	1	3µs	1	16µs	JSON::Backend::XS->init; # spent 16µ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 46µs within JSON::_set_module which was called: # once (46µs+0s) by JSON::_load_xs at line 265 sub _set_module {
313	1	200ns			return if defined $JSON::true;
314
315	1	300ns			my $module = shift;
316
317	1	2µs			local $^W;
318	2	358µs	2	31µs	# spent 20µs (8+11) within JSON::BEGIN@318 which was called: # once (8µs+11µs) by C4::Auth::BEGIN@23 at line 318 no strict qw(refs); # spent 20µs making 1 call to JSON::BEGIN@318 # spent 11µs making 1 call to strict::unimport
319
320	1	2µs			$JSON::true = ${"$module\::true"};
321	1	600ns			$JSON::false = ${"$module\::false"};
322
323	1	9µs			push @JSON::ISA, $module;
324	1	7µs			push @{"$module\::Boolean::ISA"}, qw(JSON::Boolean);
325
326	1	3µs			*{"JSON::is_bool"} = \&{"$module\::is_bool"};
327
328	1	1µ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	19µs			};
333					}
334
335	1	4µs			return 1;
336					}
337
- -
340					#
341					# JSON Boolean
342					#
343
344					package JSON::Boolean;
345
346	1	200ns			my %Installed;
347
348					# spent 318µs (247+71) within JSON::Boolean::_overrride_overload which was called 2 times, avg 159µs/call: # once (122µs+43µs) by JSON::_load_xs at line 249 # once (124µs+28µs) by JSON::_load_xs at line 250 sub _overrride_overload {
349	2	1µs			return if ($Installed{ $_[0] }++);
350
351	2	1µs			my $boolean = $_[0] . '::Boolean';
352
353	2	237µs			eval sprintf(q\| # spent 15µs executing statements in string eval # includes 14µs spent executing 1 call to 3 subs defined therein. # spent 11µs executing statements in string eval # includes 10µ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	1µ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	7µ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	107µs	2	28µs	# spent 19µs (10+9) within JSON::Backend::PP::BEGIN@398 which was called: # once (10µs+9µ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 19µs making 1 call to JSON::Backend::PP::BEGIN@398 # spent 9µ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	22µs			1;
413					__DATA__

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