← Index
NYTProf Performance Profile   « line view »
For ../prof.pl
  Run on Thu Dec 15 15:23:56 2022
Reported on Thu Dec 15 15:27:02 2022

Filename/Users/ether/.perlbrew/libs/36.0@std/lib/perl5/Module/Runtime.pm
StatementsExecuted 416 statements in 8.59ms
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
303322.3ms77.1msModule::Runtime::::require_moduleModule::Runtime::require_module
3011135µs323µsModule::Runtime::::is_module_nameModule::Runtime::is_module_name
3011135µs587µsModule::Runtime::::module_notional_filenameModule::Runtime::module_notional_filename
331100µs100µsModule::Runtime::::CORE:regcompModule::Runtime::CORE:regcomp (opcode)
352189µs89µsModule::Runtime::::CORE:matchModule::Runtime::CORE:match (opcode)
163188µs54.8msModule::Runtime::::use_moduleModule::Runtime::use_module
301179µs79µsModule::Runtime::::_is_stringModule::Runtime::_is_string
301169µs392µsModule::Runtime::::check_module_nameModule::Runtime::check_module_name
301160µs60µsModule::Runtime::::CORE:substModule::Runtime::CORE:subst (opcode)
44443µs45µsModule::Runtime::::importModule::Runtime::import
11119µs19µsModule::Runtime::::BEGIN@113Module::Runtime::BEGIN@113
1116µs6µsModule::Runtime::::BEGIN@286Module::Runtime::BEGIN@286
1113µs3µsModule::Runtime::::BEGIN@117Module::Runtime::BEGIN@117
1113µs3µsModule::Runtime::::BEGIN@293Module::Runtime::BEGIN@293
6612µs2µsModule::Runtime::::CORE:qrModule::Runtime::CORE:qr (opcode)
0000s0sModule::Runtime::::check_module_specModule::Runtime::check_module_spec
0000s0sModule::Runtime::::compose_module_nameModule::Runtime::compose_module_name
0000s0sModule::Runtime::::is_module_specModule::Runtime::is_module_spec
0000s0sModule::Runtime::::use_package_optimisticallyModule::Runtime::use_package_optimistically
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1=head1 NAME
2
3Module::Runtime - runtime module handling
4
5=head1 SYNOPSIS
6
7 use Module::Runtime qw(
8 $module_name_rx is_module_name check_module_name
9 module_notional_filename require_module);
10
11 if($module_name =~ /\A$module_name_rx\z/o) { ...
12 if(is_module_name($module_name)) { ...
13 check_module_name($module_name);
14
15 $notional_filename = module_notional_filename($module_name);
16 require_module($module_name);
17
18 use Module::Runtime qw(use_module use_package_optimistically);
19
20 $bi = use_module("Math::BigInt", 1.31)->new("1_234");
21 $widget = use_package_optimistically("Local::Widget")->new;
22
23 use Module::Runtime qw(
24 $top_module_spec_rx $sub_module_spec_rx
25 is_module_spec check_module_spec
26 compose_module_name);
27
28 if($spec =~ /\A$top_module_spec_rx\z/o) { ...
29 if($spec =~ /\A$sub_module_spec_rx\z/o) { ...
30 if(is_module_spec("Standard::Prefix", $spec)) { ...
31 check_module_spec("Standard::Prefix", $spec);
32
33 $module_name = compose_module_name("Standard::Prefix", $spec);
34
35=head1 DESCRIPTION
36
37The functions exported by this module deal with runtime handling of
38Perl modules, which are normally handled at compile time. This module
39avoids using any other modules, so that it can be used in low-level
40infrastructure.
41
42The parts of this module that work with module names apply the same syntax
43that is used for barewords in Perl source. In principle this syntax
44can vary between versions of Perl, and this module applies the syntax of
45the Perl on which it is running. In practice the usable syntax hasn't
46changed yet. There's some intent for Unicode module names to be supported
47in the future, but this hasn't yet amounted to any consistent facility.
48
49The functions of this module whose purpose is to load modules include
50workarounds for three old Perl core bugs regarding C<require>. These
51workarounds are applied on any Perl version where the bugs exist, except
52for a case where one of the bugs cannot be adequately worked around in
53pure Perl.
54
55=head2 Module name syntax
56
57The usable module name syntax has not changed from Perl 5.000 up to
58Perl 5.19.8. The syntax is composed entirely of ASCII characters.
59From Perl 5.6 onwards there has been some attempt to allow the use of
60non-ASCII Unicode characters in Perl source, but it was fundamentally
61broken (like the entirety of Perl 5.6's Unicode handling) and remained
62pretty much entirely unusable until it got some attention in the Perl
635.15 series. Although Unicode is now consistently accepted by the
64parser in some places, it remains broken for module names. Furthermore,
65there has not yet been any work on how to map Unicode module names into
66filenames, so in that respect also Unicode module names are unusable.
67
68The module name syntax is, precisely: the string must consist of one or
69more segments separated by C<::>; each segment must consist of one or more
70identifier characters (ASCII alphanumerics plus "_"); the first character
71of the string must not be a digit. Thus "C<IO::File>", "C<warnings>",
72and "C<foo::123::x_0>" are all valid module names, whereas "C<IO::>"
73and "C<1foo::bar>" are not. C<'> separators are not permitted by this
74module, though they remain usable in Perl source, being translated to
75C<::> in the parser.
76
77=head2 Core bugs worked around
78
79The first bug worked around is core bug [perl #68590], which causes
80lexical state in one file to leak into another that is C<require>d/C<use>d
81from it. This bug is present from Perl 5.6 up to Perl 5.10, and is
82fixed in Perl 5.11.0. From Perl 5.9.4 up to Perl 5.10.0 no satisfactory
83workaround is possible in pure Perl. The workaround means that modules
84loaded via this module don't suffer this pollution of their lexical
85state. Modules loaded in other ways, or via this module on the Perl
86versions where the pure Perl workaround is impossible, remain vulnerable.
87The module L<Lexical::SealRequireHints> provides a complete workaround
88for this bug.
89
90The second bug worked around causes some kinds of failure in module
91loading, principally compilation errors in the loaded module, to be
92recorded in C<%INC> as if they were successful, so later attempts to load
93the same module immediately indicate success. This bug is present up
94to Perl 5.8.9, and is fixed in Perl 5.9.0. The workaround means that a
95compilation error in a module loaded via this module won't be cached as
96a success. Modules loaded in other ways remain liable to produce bogus
97C<%INC> entries, and if a bogus entry exists then it will mislead this
98module if it is used to re-attempt loading.
99
100The third bug worked around causes the wrong context to be seen at
101file scope of a loaded module, if C<require> is invoked in a location
102that inherits context from a higher scope. This bug is present up to
103Perl 5.11.2, and is fixed in Perl 5.11.3. The workaround means that
104a module loaded via this module will always see the correct context.
105Modules loaded in other ways remain vulnerable.
106
107=cut
108
109package Module::Runtime;
110
111# Don't "use 5.006" here, because Perl 5.15.6 will load feature.pm if
112# the version check is done that way.
113132µs119µs
# spent 19µs within Module::Runtime::BEGIN@113 which was called: # once (19µs+0s) by JSON::Schema::Modern::BEGIN@28 at line 113
BEGIN { require 5.006; }
# spent 19µs making 1 call to Module::Runtime::BEGIN@113
114# Don't "use warnings" here, to avoid dependencies. Do standardise the
115# warning status by lexical override; unfortunately the only safe bitset
116# to build in is the empty set, equivalent to "no warnings".
1171788µs13µs
# spent 3µs within Module::Runtime::BEGIN@117 which was called: # once (3µs+0s) by JSON::Schema::Modern::BEGIN@28 at line 117
BEGIN { ${^WARNING_BITS} = ""; }
# spent 3µs making 1 call to Module::Runtime::BEGIN@117
118# Don't "use strict" here, to avoid dependencies.
119
12010sour $VERSION = "0.016";
121
122# Don't use Exporter here, to avoid dependencies.
12311µsour @EXPORT_OK = qw(
124 $module_name_rx is_module_name is_valid_module_name check_module_name
125 module_notional_filename require_module
126 use_module use_package_optimistically
127 $top_module_spec_rx $sub_module_spec_rx
128 is_module_spec is_valid_module_spec check_module_spec
129 compose_module_name
130);
13116µsmy %export_ok = map { ($_ => undef) } @EXPORT_OK;
132
# spent 45µs (43+2) within Module::Runtime::import which was called 4 times, avg 11µs/call: # once (13µs+0s) by JSON::Schema::Modern::BEGIN@28 at line 28 of /Users/ether/git/JSON-Schema-Modern/lib/JSON/Schema/Modern.pm # once (12µs+1000ns) by MooX::HandlesVia::BEGIN@9 at line 9 of MooX/HandlesVia.pm # once (9µs+1µs) by Module::Implementation::BEGIN@8 at line 8 of Module/Implementation.pm # once (9µs+0s) by Data::Perl::Role::Collection::Hash::BEGIN@9 at line 9 of Data/Perl/Role/Collection/Hash.pm
sub import {
13340s my $me = shift;
13442µs my $callpkg = caller(0);
13543µs my $errs = "";
13642µs foreach(@_) {
13752µs if(exists $export_ok{$_}) {
138 # We would need to do "no strict 'refs'" here
139 # if we had enabled strict at file scope.
140514µs52µs if(/\A\$(.*)\z/s) {
# spent 2µs making 5 calls to Module::Runtime::CORE:match, avg 400ns/call
141 *{$callpkg."::".$1} = \$$1;
142 } else {
143517µs *{$callpkg."::".$_} = \&$_;
144 }
145 } else {
146 $errs .= "\"$_\" is not exported by the $me module\n";
147 }
148 }
14949µs if($errs ne "") {
150 die "${errs}Can't continue after import errors ".
151 "at @{[(caller(0))[1]]} line @{[(caller(0))[2]]}.\n";
152 }
153}
154
155# Logic duplicated from Params::Classify. Duplicating it here avoids
156# an extensive and potentially circular dependency graph.
157
# spent 79µs within Module::Runtime::_is_string which was called 30 times, avg 3µs/call: # 30 times (79µs+0s) by Module::Runtime::is_module_name at line 219, avg 3µs/call
sub _is_string($) {
1583016µs my($arg) = @_;
1593082µs return defined($arg) && ref(\$arg) eq "SCALAR";
160}
161
162=head1 REGULAR EXPRESSIONS
163
164These regular expressions do not include any anchors, so to check
165whether an entire string matches a syntax item you must supply the
166anchors yourself.
167
168=over
169
170=item $module_name_rx
171
172Matches a valid Perl module name in bareword syntax.
173
174=cut
175
17617µs12µsour $module_name_rx = qr/[A-Z_a-z][0-9A-Z_a-z]*(?:::[0-9A-Z_a-z]+)*/;
# spent 2µs making 1 call to Module::Runtime::CORE:qr
177
178=item $top_module_spec_rx
179
180Matches a module specification for use with L</compose_module_name>,
181where no prefix is being used.
182
183=cut
184
18512µs10smy $qual_module_spec_rx =
# spent 0s making 1 call to Module::Runtime::CORE:qr
186 qr#(?:/|::)[A-Z_a-z][0-9A-Z_a-z]*(?:(?:/|::)[0-9A-Z_a-z]+)*#;
187
18812µs10smy $unqual_top_module_spec_rx =
# spent 0s making 1 call to Module::Runtime::CORE:qr
189 qr#[A-Z_a-z][0-9A-Z_a-z]*(?:(?:/|::)[0-9A-Z_a-z]+)*#;
190
191153µs248µsour $top_module_spec_rx = qr/$qual_module_spec_rx|$unqual_top_module_spec_rx/o;
# spent 48µs making 1 call to Module::Runtime::CORE:regcomp # spent 0s making 1 call to Module::Runtime::CORE:qr
192
193=item $sub_module_spec_rx
194
195Matches a module specification for use with L</compose_module_name>,
196where a prefix is being used.
197
198=cut
199
20012µs10smy $unqual_sub_module_spec_rx = qr#[0-9A-Z_a-z]+(?:(?:/|::)[0-9A-Z_a-z]+)*#;
# spent 0s making 1 call to Module::Runtime::CORE:qr
201
202134µs230µsour $sub_module_spec_rx = qr/$qual_module_spec_rx|$unqual_sub_module_spec_rx/o;
# spent 30µs making 1 call to Module::Runtime::CORE:regcomp # spent 0s making 1 call to Module::Runtime::CORE:qr
203
204=back
205
206=head1 FUNCTIONS
207
208=head2 Basic module handling
209
210=over
211
212=item is_module_name(ARG)
213
214Returns a truth value indicating whether I<ARG> is a plain string
215satisfying Perl module name syntax as described for L</$module_name_rx>.
216
217=cut
218
21930244µs61188µs
# spent 323µs (135+188) within Module::Runtime::is_module_name which was called 30 times, avg 11µs/call: # 30 times (135µs+188µs) by Module::Runtime::check_module_name at line 238, avg 11µs/call
sub is_module_name($) { _is_string($_[0]) && $_[0] =~ /\A$module_name_rx\z/o }
# spent 87µs making 30 calls to Module::Runtime::CORE:match, avg 3µs/call # spent 79µs making 30 calls to Module::Runtime::_is_string, avg 3µs/call # spent 22µs making 1 call to Module::Runtime::CORE:regcomp
220
221=item is_valid_module_name(ARG)
222
223Deprecated alias for L</is_module_name>.
224
225=cut
226
22711µs*is_valid_module_name = \&is_module_name;
228
229=item check_module_name(ARG)
230
231Check whether I<ARG> is a plain string
232satisfying Perl module name syntax as described for L</$module_name_rx>.
233Return normally if it is, or C<die> if it is not.
234
235=cut
236
237
# spent 392µs (69+323) within Module::Runtime::check_module_name which was called 30 times, avg 13µs/call: # 30 times (69µs+323µs) by Module::Runtime::module_notional_filename at line 261, avg 13µs/call
sub check_module_name($) {
2383064µs30323µs unless(&is_module_name) {
# spent 323µs making 30 calls to Module::Runtime::is_module_name, avg 11µs/call
239 die +(_is_string($_[0]) ? "`$_[0]'" : "argument").
240 " is not a module name\n";
241 }
242}
243
244=item module_notional_filename(NAME)
245
246Generates a notional relative filename for a module, which is used in
247some Perl core interfaces.
248The I<NAME> is a string, which should be a valid module name (one or
249more C<::>-separated segments). If it is not a valid name, the function
250C<die>s.
251
252The notional filename for the named module is generated and returned.
253This filename is always in Unix style, with C</> directory separators
254and a C<.pm> suffix. This kind of filename can be used as an argument to
255C<require>, and is the key that appears in C<%INC> to identify a module,
256regardless of actual local filename syntax.
257
258=cut
259
260
# spent 587µs (135+452) within Module::Runtime::module_notional_filename which was called 30 times, avg 20µs/call: # 30 times (135µs+452µs) by Module::Runtime::require_module at line 314, avg 20µs/call
sub module_notional_filename($) {
2613036µs30392µs &check_module_name;
# spent 392µs making 30 calls to Module::Runtime::check_module_name, avg 13µs/call
262309µs my($name) = @_;
2633092µs3060µs $name =~ s!::!/!g;
# spent 60µs making 30 calls to Module::Runtime::CORE:subst, avg 2µs/call
2643072µs return $name.".pm";
265}
266
267=item require_module(NAME)
268
269This is essentially the bareword form of C<require>, in runtime form.
270The I<NAME> is a string, which should be a valid module name (one or
271more C<::>-separated segments). If it is not a valid name, the function
272C<die>s.
273
274The module specified by I<NAME> is loaded, if it hasn't been already,
275in the manner of the bareword form of C<require>. That means that a
276search through C<@INC> is performed, and a byte-compiled form of the
277module will be used if available.
278
279The return value is as for C<require>. That is, it is the value returned
280by the module itself if the module is loaded anew, or C<1> if the module
281was already loaded.
282
283=cut
284
285# Don't "use constant" here, to avoid dependencies.
286
# spent 6µs within Module::Runtime::BEGIN@286 which was called: # once (6µs+0s) by JSON::Schema::Modern::BEGIN@28 at line 291
BEGIN {
287 *_WORK_AROUND_HINT_LEAKAGE =
288 "$]" < 5.011 && !("$]" >= 5.009004 && "$]" < 5.010001)
28913µs ? sub(){1} : sub(){0};
29014µs *_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0};
291128µs16µs}
# spent 6µs making 1 call to Module::Runtime::BEGIN@286
292
29313µs
# spent 3µs within Module::Runtime::BEGIN@293 which was called: # once (3µs+0s) by JSON::Schema::Modern::BEGIN@28 at line 298
BEGIN { if(_WORK_AROUND_BROKEN_MODULE_STATE) { eval q{
294 sub Module::Runtime::__GUARD__::DESTROY {
295 delete $INC{$_[0]->[0]} if @{$_[0]};
296 }
297 1;
2981369µs13µs}; die $@ if $@ ne ""; } }
# spent 3µs making 1 call to Module::Runtime::BEGIN@293
299
300
# spent 77.1ms (22.3+54.8) within Module::Runtime::require_module which was called 30 times, avg 2.57ms/call: # 16 times (18.3ms+36.4ms) by Module::Runtime::use_module at line 345, avg 3.42ms/call # 12 times (2.47ms+7.49ms) by MooX::HandlesVia::process_has at line 53 of MooX/HandlesVia.pm, avg 829µs/call # 2 times (1.45ms+11.0ms) by Module::Implementation::try {...} at line 93 of Module/Implementation.pm, avg 6.20ms/call
sub require_module($) {
301 # Localise %^H to work around [perl #68590], where the bug exists
302 # and this is a satisfactory workaround. The bug consists of
303 # %^H state leaking into each required module, polluting the
304 # module's lexical state.
305 local %^H if _WORK_AROUND_HINT_LEAKAGE;
306307µs if(_WORK_AROUND_BROKEN_MODULE_STATE) {
307 my $notional_filename = &module_notional_filename;
308 my $guard = bless([ $notional_filename ],
309 "Module::Runtime::__GUARD__");
310 my $result = CORE::require($notional_filename);
311 pop @$guard;
312 return $result;
313 } else {
314306.49ms30587µs return scalar(CORE::require(&module_notional_filename));
# spent 587µs making 30 calls to Module::Runtime::module_notional_filename, avg 20µs/call
315 }
316}
317
318=back
319
320=head2 Structured module use
321
322=over
323
324=item use_module(NAME[, VERSION])
325
326This is essentially C<use> in runtime form, but without the importing
327feature (which is fundamentally a compile-time thing). The I<NAME> is
328handled just like in C<require_module> above: it must be a module name,
329and the named module is loaded as if by the bareword form of C<require>.
330
331If a I<VERSION> is specified, the C<VERSION> method of the loaded module is
332called with the specified I<VERSION> as an argument. This normally serves to
333ensure that the version loaded is at least the version required. This is
334the same functionality provided by the I<VERSION> parameter of C<use>.
335
336On success, the name of the module is returned. This is unlike
337L</require_module>, and is done so that the entire call to L</use_module>
338can be used as a class name to call a constructor, as in the example in
339the synopsis.
340
341=cut
342
343
# spent 54.8ms (88µs+54.7) within Module::Runtime::use_module which was called 16 times, avg 3.43ms/call: # 8 times (67µs+51.4ms) by JSON::Schema::Modern::__ANON__[/Users/ether/git/JSON-Schema-Modern/lib/JSON/Schema/Modern.pm:709] at line 705 of /Users/ether/git/JSON-Schema-Modern/lib/JSON/Schema/Modern.pm, avg 6.43ms/call # 7 times (11µs+72µs) by JSON::Schema::Modern::__ANON__[/Users/ether/git/JSON-Schema-Modern/lib/JSON/Schema/Modern.pm:751] at line 743 of /Users/ether/git/JSON-Schema-Modern/lib/JSON/Schema/Modern.pm, avg 12µs/call # once (10µs+3.28ms) by JSON::Schema::Modern::add_vocabulary at line 715 of /Users/ether/git/JSON-Schema-Modern/lib/JSON/Schema/Modern.pm
sub use_module($;$) {
344166µs my($name, $version) = @_;
3451635µs1654.7ms require_module($name);
# spent 54.7ms making 16 calls to Module::Runtime::require_module, avg 3.42ms/call
346167µs $name->VERSION($version) if @_ >= 2;
3471633µs return $name;
348}
349
350=item use_package_optimistically(NAME[, VERSION])
351
352This is an analogue of L</use_module> for the situation where there is
353uncertainty as to whether a package/class is defined in its own module
354or by some other means. It attempts to arrange for the named package to
355be available, either by loading a module or by doing nothing and hoping.
356
357An attempt is made to load the named module (as if by the bareword form
358of C<require>). If the module cannot be found then it is assumed that
359the package was actually already loaded by other means, and no error
360is signalled. That's the optimistic bit.
361
362I<Warning:> this optional module loading is liable to cause unreliable
363behaviour, including security problems. It interacts especially badly
364with having C<.> in C<@INC>, which was the default state of affairs in
365Perls prior to 5.25.11. If a package is actually defined by some means
366other than a module, then applying this function to it causes a spurious
367attempt to load a module that is expected to be non-existent. If a
368module actually exists under that name then it will be unintentionally
369loaded. If C<.> is in C<@INC> and this code is ever run with the current
370directory being one writable by a malicious user (such as F</tmp>), then
371the malicious user can easily cause the victim to run arbitrary code, by
372creating a module file under the predictable spuriously-loaded name in the
373writable directory. Generally, optional module loading should be avoided.
374
375This is mostly the same operation that is performed by the L<base> pragma
376to ensure that the specified base classes are available. The behaviour
377of L<base> was simplified in version 2.18, and later improved in version
3782.20, and on both occasions this function changed to match.
379
380If a I<VERSION> is specified, the C<VERSION> method of the loaded package is
381called with the specified I<VERSION> as an argument. This normally serves
382to ensure that the version loaded is at least the version required.
383On success, the name of the package is returned. These aspects of the
384function work just like L</use_module>.
385
386=cut
387
388sub use_package_optimistically($;$) {
389 my($name, $version) = @_;
390 my $fn = module_notional_filename($name);
391 eval { local $SIG{__DIE__}; require_module($name); };
392 die $@ if $@ ne "" &&
393 ($@ !~ /\ACan't locate \Q$fn\E .+ at \Q@{[__FILE__]}\E line/s ||
394 $@ =~ /^Compilation\ failed\ in\ require
395 \ at\ \Q@{[__FILE__]}\E\ line/xm);
396 $name->VERSION($version) if @_ >= 2;
397 return $name;
398}
399
400=back
401
402=head2 Module name composition
403
404=over
405
406=item is_module_spec(PREFIX, SPEC)
407
408Returns a truth value indicating
409whether I<SPEC> is valid input for L</compose_module_name>.
410See below for what that entails. Whether a I<PREFIX> is supplied affects
411the validity of I<SPEC>, but the exact value of the prefix is unimportant,
412so this function treats I<PREFIX> as a truth value.
413
414=cut
415
416sub is_module_spec($$) {
417 my($prefix, $spec) = @_;
418 return _is_string($spec) &&
419 $spec =~ ($prefix ? qr/\A$sub_module_spec_rx\z/o :
420 qr/\A$top_module_spec_rx\z/o);
421}
422
423=item is_valid_module_spec(PREFIX, SPEC)
424
425Deprecated alias for L</is_module_spec>.
426
427=cut
428
42911µs*is_valid_module_spec = \&is_module_spec;
430
431=item check_module_spec(PREFIX, SPEC)
432
433Check whether I<SPEC> is valid input for L</compose_module_name>.
434Return normally if it is, or C<die> if it is not.
435
436=cut
437
438sub check_module_spec($$) {
439 unless(&is_module_spec) {
440 die +(_is_string($_[1]) ? "`$_[1]'" : "argument").
441 " is not a module specification\n";
442 }
443}
444
445=item compose_module_name(PREFIX, SPEC)
446
447This function is intended to make it more convenient for a user to specify
448a Perl module name at runtime. Users have greater need for abbreviations
449and context-sensitivity than programmers, and Perl module names get a
450little unwieldy. I<SPEC> is what the user specifies, and this function
451translates it into a module name in standard form, which it returns.
452
453I<SPEC> has syntax approximately that of a standard module name: it
454should consist of one or more name segments, each of which consists
455of one or more identifier characters. However, C</> is permitted as a
456separator, in addition to the standard C<::>. The two separators are
457entirely interchangeable.
458
459Additionally, if I<PREFIX> is not C<undef> then it must be a module
460name in standard form, and it is prefixed to the user-specified name.
461The user can inhibit the prefix addition by starting I<SPEC> with a
462separator (either C</> or C<::>).
463
464=cut
465
466sub compose_module_name($$) {
467 my($prefix, $spec) = @_;
468 check_module_name($prefix) if defined $prefix;
469 &check_module_spec;
470 if($spec =~ s#\A(?:/|::)##) {
471 # OK
472 } else {
473 $spec = $prefix."::".$spec if defined $prefix;
474 }
475 $spec =~ s#/#::#g;
476 return $spec;
477}
478
479=back
480
481=head1 BUGS
482
483On Perl versions 5.7.2 to 5.8.8, if C<require> is overridden by the
484C<CORE::GLOBAL> mechanism, it is likely to break the heuristics used by
485L</use_package_optimistically>, making it signal an error for a missing
486module rather than assume that it was already loaded. From Perl 5.8.9
487onwards, and on 5.7.1 and earlier, this module can avoid being confused
488by such an override. On the affected versions, a C<require> override
489might be installed by L<Lexical::SealRequireHints>, if something requires
490its bugfix but for some reason its XS implementation isn't available.
491
492=head1 SEE ALSO
493
494L<Lexical::SealRequireHints>,
495L<base>,
496L<perlfunc/require>,
497L<perlfunc/use>
498
499=head1 AUTHOR
500
501Andrew Main (Zefram) <zefram@fysh.org>
502
503=head1 COPYRIGHT
504
505Copyright (C) 2004, 2006, 2007, 2009, 2010, 2011, 2012, 2014, 2017
506Andrew Main (Zefram) <zefram@fysh.org>
507
508=head1 LICENSE
509
510This module is free software; you can redistribute it and/or modify it
511under the same terms as Perl itself.
512
513=cut
514
515112µs1;
 
# spent 89µs within Module::Runtime::CORE:match which was called 35 times, avg 3µs/call: # 30 times (87µs+0s) by Module::Runtime::is_module_name at line 219, avg 3µs/call # 5 times (2µs+0s) by Module::Runtime::import at line 140, avg 400ns/call
sub Module::Runtime::CORE:match; # opcode
# spent 2µs within Module::Runtime::CORE:qr which was called 6 times, avg 333ns/call: # once (2µs+0s) by JSON::Schema::Modern::BEGIN@28 at line 176 # once (0s+0s) by JSON::Schema::Modern::BEGIN@28 at line 188 # once (0s+0s) by JSON::Schema::Modern::BEGIN@28 at line 185 # once (0s+0s) by JSON::Schema::Modern::BEGIN@28 at line 202 # once (0s+0s) by JSON::Schema::Modern::BEGIN@28 at line 191 # once (0s+0s) by JSON::Schema::Modern::BEGIN@28 at line 200
sub Module::Runtime::CORE:qr; # opcode
# spent 100µs within Module::Runtime::CORE:regcomp which was called 3 times, avg 33µs/call: # once (48µs+0s) by JSON::Schema::Modern::BEGIN@28 at line 191 # once (30µs+0s) by JSON::Schema::Modern::BEGIN@28 at line 202 # once (22µs+0s) by Module::Runtime::is_module_name at line 219
sub Module::Runtime::CORE:regcomp; # opcode
# spent 60µs within Module::Runtime::CORE:subst which was called 30 times, avg 2µs/call: # 30 times (60µs+0s) by Module::Runtime::module_notional_filename at line 263, avg 2µs/call
sub Module::Runtime::CORE:subst; # opcode
Report produced by the NYTProf 6.12 Perl profiler, developed by Tim Bunce based on work by Adam Kaplan and Salvador Fandiño García.