← Index
NYTProf Performance Profile   « block view • line view • sub view »
For bin/pan_genome_post_analysis
  Run on Fri Mar 27 11:43:32 2015
Reported on Fri Mar 27 11:45:55 2015

Filename/Users/ap13/perl5/lib/perl5/Module/Runtime.pm
StatementsExecuted 2910 statements in 11.0ms
Subroutines
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
103323.97ms33.3msModule::Runtime::::require_moduleModule::Runtime::require_module (recurses: max depth 1, inclusive time 34µs)
222541.57ms5.69msModule::Runtime::::module_notional_filenameModule::Runtime::module_notional_filename
97541.47ms15.3msModule::Runtime::::use_package_optimisticallyModule::Runtime::use_package_optimistically (recurses: max depth 1, inclusive time 87µs)
222111.35ms2.77msModule::Runtime::::is_module_nameModule::Runtime::is_module_name
24021830µs830µsModule::Runtime::::CORE:matchModule::Runtime::CORE:match (opcode)
22211710µs710µsModule::Runtime::::CORE:substModule::Runtime::CORE:subst (opcode)
22211636µs3.41msModule::Runtime::::check_module_nameModule::Runtime::check_module_name
22211598µs598µsModule::Runtime::::_is_stringModule::Runtime::_is_string
131313320µs339µsModule::Runtime::::importModule::Runtime::import
331113µs113µsModule::Runtime::::CORE:regcompModule::Runtime::CORE:regcomp (opcode)
66138µs38µsModule::Runtime::::CORE:qrModule::Runtime::CORE:qr (opcode)
11136µs36µsModule::Runtime::::BEGIN@116Module::Runtime::BEGIN@116
41132µs20.7msModule::Runtime::::use_moduleModule::Runtime::use_module
11116µs16µsModule::Runtime::::BEGIN@289Module::Runtime::BEGIN@289
1116µs6µsModule::Runtime::::BEGIN@120Module::Runtime::BEGIN@120
1115µs5µsModule::Runtime::::BEGIN@296Module::Runtime::BEGIN@296
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
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
12 if($module_name =~ /\A$module_name_rx\z/o) { ...
13 if(is_module_name($module_name)) { ...
14 check_module_name($module_name);
15
16 $notional_filename = module_notional_filename($module_name);
17 require_module($module_name);
18
19 use Module::Runtime qw(use_module use_package_optimistically);
20
21 $bi = use_module("Math::BigInt", 1.31)->new("1_234");
22 $widget = use_package_optimistically("Local::Widget")->new;
23
24 use Module::Runtime qw(
25 $top_module_spec_rx $sub_module_spec_rx
26 is_module_spec check_module_spec
27 compose_module_name
28 );
29
30 if($spec =~ /\A$top_module_spec_rx\z/o) { ...
31 if($spec =~ /\A$sub_module_spec_rx\z/o) { ...
32 if(is_module_spec("Standard::Prefix", $spec)) { ...
33 check_module_spec("Standard::Prefix", $spec);
34
35 $module_name =
36 compose_module_name("Standard::Prefix", $spec);
37
38=head1 DESCRIPTION
39
40The functions exported by this module deal with runtime handling of
41Perl modules, which are normally handled at compile time. This module
42avoids using any other modules, so that it can be used in low-level
43infrastructure.
44
45The parts of this module that work with module names apply the same syntax
46that is used for barewords in Perl source. In principle this syntax
47can vary between versions of Perl, and this module applies the syntax of
48the Perl on which it is running. In practice the usable syntax hasn't
49changed yet. There's some intent for Unicode module names to be supported
50in the future, but this hasn't yet amounted to any consistent facility.
51
52The functions of this module whose purpose is to load modules include
53workarounds for three old Perl core bugs regarding C<require>. These
54workarounds are applied on any Perl version where the bugs exist, except
55for a case where one of the bugs cannot be adequately worked around in
56pure Perl.
57
58=head2 Module name syntax
59
60The usable module name syntax has not changed from Perl 5.000 up to
61Perl 5.19.8. The syntax is composed entirely of ASCII characters.
62From Perl 5.6 onwards there has been some attempt to allow the use of
63non-ASCII Unicode characters in Perl source, but it was fundamentally
64broken (like the entirety of Perl 5.6's Unicode handling) and remained
65pretty much entirely unusable until it got some attention in the Perl
665.15 series. Although Unicode is now consistently accepted by the
67parser in some places, it remains broken for module names. Furthermore,
68there has not yet been any work on how to map Unicode module names into
69filenames, so in that respect also Unicode module names are unusable.
70
71The module name syntax is, precisely: the string must consist of one or
72more segments separated by C<::>; each segment must consist of one or more
73identifier characters (ASCII alphanumerics plus "_"); the first character
74of the string must not be a digit. Thus "C<IO::File>", "C<warnings>",
75and "C<foo::123::x_0>" are all valid module names, whereas "C<IO::>"
76and "C<1foo::bar>" are not. C<'> separators are not permitted by this
77module, though they remain usable in Perl source, being translated to
78C<::> in the parser.
79
80=head2 Core bugs worked around
81
82The first bug worked around is core bug [perl #68590], which causes
83lexical state in one file to leak into another that is C<require>d/C<use>d
84from it. This bug is present from Perl 5.6 up to Perl 5.10, and is
85fixed in Perl 5.11.0. From Perl 5.9.4 up to Perl 5.10.0 no satisfactory
86workaround is possible in pure Perl. The workaround means that modules
87loaded via this module don't suffer this pollution of their lexical
88state. Modules loaded in other ways, or via this module on the Perl
89versions where the pure Perl workaround is impossible, remain vulnerable.
90The module L<Lexical::SealRequireHints> provides a complete workaround
91for this bug.
92
93The second bug worked around causes some kinds of failure in module
94loading, principally compilation errors in the loaded module, to be
95recorded in C<%INC> as if they were successful, so later attempts to load
96the same module immediately indicate success. This bug is present up
97to Perl 5.8.9, and is fixed in Perl 5.9.0. The workaround means that a
98compilation error in a module loaded via this module won't be cached as
99a success. Modules loaded in other ways remain liable to produce bogus
100C<%INC> entries, and if a bogus entry exists then it will mislead this
101module if it is used to re-attempt loading.
102
103The third bug worked around causes the wrong context to be seen at
104file scope of a loaded module, if C<require> is invoked in a location
105that inherits context from a higher scope. This bug is present up to
106Perl 5.11.2, and is fixed in Perl 5.11.3. The workaround means that
107a module loaded via this module will always see the correct context.
108Modules loaded in other ways remain vulnerable.
109
110=cut
111
112package Module::Runtime;
113
114# Don't "use 5.006" here, because Perl 5.15.6 will load feature.pm if
115# the version check is done that way.
116168µs136µs
# spent 36µs within Module::Runtime::BEGIN@116 which was called: # once (36µs+0s) by Moose::BEGIN@11 at line 116
BEGIN { require 5.006; }
# spent 36µs making 1 call to Module::Runtime::BEGIN@116
117# Don't "use warnings" here, to avoid dependencies. Do standardise the
118# warning status by lexical override; unfortunately the only safe bitset
119# to build in is the empty set, equivalent to "no warnings".
12011.06ms16µs
# spent 6µs within Module::Runtime::BEGIN@120 which was called: # once (6µs+0s) by Moose::BEGIN@11 at line 120
BEGIN { ${^WARNING_BITS} = ""; }
# spent 6µs making 1 call to Module::Runtime::BEGIN@120
121# Don't "use strict" here, to avoid dependencies.
122
12311µsour $VERSION = "0.014";
124
125# Don't use Exporter here, to avoid dependencies.
12617µsour @EXPORT_OK = qw(
127 $module_name_rx is_module_name is_valid_module_name check_module_name
128 module_notional_filename require_module
129 use_module use_package_optimistically
130 $top_module_spec_rx $sub_module_spec_rx
131 is_module_spec is_valid_module_spec check_module_spec
132 compose_module_name
133);
134122µsmy %export_ok = map { ($_ => undef) } @EXPORT_OK;
135
# spent 339µs (320+19) within Module::Runtime::import which was called 13 times, avg 26µs/call: # once (49µs+2µs) by Class::Load::BEGIN@10 at line 15 of Class/Load.pm # once (43µs+3µs) by Moose::Util::BEGIN@7 at line 7 of Moose/Util.pm # once (37µs+2µs) by metaclass::BEGIN@7 at line 7 of metaclass.pm # once (30µs+2µs) by Moose::BEGIN@11 at line 11 of Moose.pm # once (27µs+2µs) by Module::Implementation::BEGIN@9 at line 9 of Module/Implementation.pm # once (25µs+1µs) by Class::MOP::MiniTrait::BEGIN@7 at line 7 of Class/MOP/MiniTrait.pm # once (23µs+1µs) by Class::MOP::Class::Immutable::Trait::BEGIN@8 at line 8 of Class/MOP/Class/Immutable/Trait.pm # once (19µs+800ns) by Class::MOP::Package::BEGIN@9 at line 9 of Class/MOP/Package.pm # once (17µs+1µs) by Moose::Role::BEGIN@9 at line 9 of Moose/Role.pm # once (16µs+1µs) by Moose::Meta::Attribute::Native::BEGIN@6 at line 6 of Moose/Meta/Attribute/Native.pm # once (16µs+700ns) by Class::MOP::Class::BEGIN@14 at line 14 of Class/MOP/Class.pm # once (15µs+800ns) by Class::MOP::Mixin::BEGIN@8 at line 8 of Class/MOP/Mixin.pm # once (4µs+0s) by Class::MOP::Object::BEGIN@9 at line 9 of Class/MOP/Object.pm
sub import {
1361310µs my $me = shift;
1371318µs my $callpkg = caller(0);
138135µs my $errs = "";
1391322µs foreach(@_) {
1401837µs if(exists $export_ok{$_}) {
141 # We would need to do "no strict 'refs'" here
142 # if we had enabled strict at file scope.
1431889µs1818µs if(/\A\$(.*)\z/s) {
# spent 18µs making 18 calls to Module::Runtime::CORE:match, avg 1µs/call
144 *{$callpkg."::".$1} = \$$1;
145 } else {
14618100µs *{$callpkg."::".$_} = \&$_;
147 }
148 } else {
149 $errs .= "\"$_\" is not exported by the $me module\n";
150 }
151 }
1521374µs if($errs ne "") {
153 die "${errs}Can't continue after import errors ".
154 "at @{[(caller(0))[1]]} line @{[(caller(0))[2]]}.\n";
155 }
156}
157
158# Logic duplicated from Params::Classify. Duplicating it here avoids
159# an extensive and potentially circular dependency graph.
160
# spent 598µs within Module::Runtime::_is_string which was called 222 times, avg 3µs/call: # 222 times (598µs+0s) by Module::Runtime::is_module_name at line 222, avg 3µs/call
sub _is_string($) {
161222139µs my($arg) = @_;
162222701µs return defined($arg) && ref(\$arg) eq "SCALAR";
163}
164
165=head1 REGULAR EXPRESSIONS
166
167These regular expressions do not include any anchors, so to check
168whether an entire string matches a syntax item you must supply the
169anchors yourself.
170
171=over
172
173=item $module_name_rx
174
175Matches a valid Perl module name in bareword syntax.
176
177=cut
178
179133µs123µsour $module_name_rx = qr/[A-Z_a-z][0-9A-Z_a-z]*(?:::[0-9A-Z_a-z]+)*/;
# spent 23µs making 1 call to Module::Runtime::CORE:qr
180
181=item $top_module_spec_rx
182
183Matches a module specification for use with L</compose_module_name>,
184where no prefix is being used.
185
186=cut
187
18817µs12µsmy $qual_module_spec_rx =
# spent 2µs 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
19116µs12µsmy $unqual_top_module_spec_rx =
# spent 2µs making 1 call to Module::Runtime::CORE:qr
192 qr#[A-Z_a-z][0-9A-Z_a-z]*(?:(?:/|::)[0-9A-Z_a-z]+)*#;
193
194169µs256µsour $top_module_spec_rx = qr/$qual_module_spec_rx|$unqual_top_module_spec_rx/o;
# spent 54µs making 1 call to Module::Runtime::CORE:regcomp # spent 2µs making 1 call to Module::Runtime::CORE:qr
195
196=item $sub_module_spec_rx
197
198Matches a module specification for use with L</compose_module_name>,
199where a prefix is being used.
200
201=cut
202
203110µs16µsmy $unqual_sub_module_spec_rx = qr#[0-9A-Z_a-z]+(?:(?:/|::)[0-9A-Z_a-z]+)*#;
# spent 6µs making 1 call to Module::Runtime::CORE:qr
204
205152µs243µsour $sub_module_spec_rx = qr/$qual_module_spec_rx|$unqual_sub_module_spec_rx/o;
# spent 41µs making 1 call to Module::Runtime::CORE:regcomp # spent 2µs making 1 call to Module::Runtime::CORE:qr
206
207=back
208
209=head1 FUNCTIONS
210
211=head2 Basic module handling
212
213=over
214
215=item is_module_name(ARG)
216
217Returns a truth value indicating whether I<ARG> is a plain string
218satisfying Perl module name syntax as described for L</$module_name_rx>.
219
220=cut
221
2222222.04ms4451.43ms
# spent 2.77ms (1.35+1.43) within Module::Runtime::is_module_name which was called 222 times, avg 12µs/call: # 222 times (1.35ms+1.43ms) by Module::Runtime::check_module_name at line 241, avg 12µs/call
sub is_module_name($) { _is_string($_[0]) && $_[0] =~ /\A$module_name_rx\z/o }
# spent 811µs making 222 calls to Module::Runtime::CORE:match, avg 4µs/call # spent 598µs making 222 calls to Module::Runtime::_is_string, avg 3µs/call # spent 18µs making 1 call to Module::Runtime::CORE:regcomp
223
224=item is_valid_module_name(ARG)
225
226Deprecated alias for L</is_module_name>.
227
228=cut
229
23013µs*is_valid_module_name = \&is_module_name;
231
232=item check_module_name(ARG)
233
234Check whether I<ARG> is a plain string
235satisfying Perl module name syntax as described for L</$module_name_rx>.
236Return normally if it is, or C<die> if it is not.
237
238=cut
239
240
# spent 3.41ms (636µs+2.77) within Module::Runtime::check_module_name which was called 222 times, avg 15µs/call: # 222 times (636µs+2.77ms) by Module::Runtime::module_notional_filename at line 264, avg 15µs/call
sub check_module_name($) {
241222607µs2222.77ms unless(&is_module_name) {
# spent 2.77ms making 222 calls to Module::Runtime::is_module_name, avg 12µs/call
242 die +(_is_string($_[0]) ? "`$_[0]'" : "argument").
243 " is not a module name\n";
244 }
245}
246
247=item module_notional_filename(NAME)
248
249Generates a notional relative filename for a module, which is used in
250some Perl core interfaces.
251The I<NAME> is a string, which should be a valid module name (one or
252more C<::>-separated segments). If it is not a valid name, the function
253C<die>s.
254
255The notional filename for the named module is generated and returned.
256This filename is always in Unix style, with C</> directory separators
257and a C<.pm> suffix. This kind of filename can be used as an argument to
258C<require>, and is the key that appears in C<%INC> to identify a module,
259regardless of actual local filename syntax.
260
261=cut
262
263
# spent 5.69ms (1.57+4.12) within Module::Runtime::module_notional_filename which was called 222 times, avg 26µs/call: # 103 times (576µs+1.39ms) by Module::Runtime::require_module at line 317, avg 19µs/call # 97 times (791µs+2.24ms) by Module::Runtime::use_package_optimistically at line 380, avg 31µs/call # 17 times (154µs+381µs) by Moose::init_meta at line 204 of Moose.pm, avg 32µs/call # 3 times (22µs+56µs) by Moose::Role::init_meta at line 144 of Moose/Role.pm, avg 26µs/call # 2 times (22µs+52µs) by Class::MOP::Package::create at line 68 of Class/MOP/Package.pm, avg 37µs/call
sub module_notional_filename($) {
264222314µs2223.41ms &check_module_name;
# spent 3.41ms making 222 calls to Module::Runtime::check_module_name, avg 15µs/call
265222118µs my($name) = @_;
2662221.14ms222710µs $name =~ s!::!/!g;
# spent 710µs making 222 calls to Module::Runtime::CORE:subst, avg 3µs/call
267222618µs return $name.".pm";
268}
269
270=item require_module(NAME)
271
272This is essentially the bareword form of C<require>, in runtime form.
273The I<NAME> is a string, which should be a valid module name (one or
274more C<::>-separated segments). If it is not a valid name, the function
275C<die>s.
276
277The module specified by I<NAME> is loaded, if it hasn't been already,
278in the manner of the bareword form of C<require>. That means that a
279search through C<@INC> is performed, and a byte-compiled form of the
280module will be used if available.
281
282The return value is as for C<require>. That is, it is the value returned
283by the module itself if the module is loaded anew, or C<1> if the module
284was already loaded.
285
286=cut
287
288# Don't "use constant" here, to avoid dependencies.
289
# spent 16µs within Module::Runtime::BEGIN@289 which was called: # once (16µs+0s) by Moose::BEGIN@11 at line 294
BEGIN {
290 *_WORK_AROUND_HINT_LEAKAGE =
291 "$]" < 5.011 && !("$]" >= 5.009004 && "$]" < 5.010001)
29216µs ? sub(){1} : sub(){0};
293111µs *_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0};
294186µs116µs}
# spent 16µs making 1 call to Module::Runtime::BEGIN@289
295
29617µs
# spent 5µs within Module::Runtime::BEGIN@296 which was called: # once (5µs+0s) by Moose::BEGIN@11 at line 301
BEGIN { if(_WORK_AROUND_BROKEN_MODULE_STATE) { eval q{
297 sub Module::Runtime::__GUARD__::DESTROY {
298 delete $INC{$_[0]->[0]} if @{$_[0]};
299 }
300 1;
3011798µs15µs}; die $@ if $@ ne ""; } }
# spent 5µs making 1 call to Module::Runtime::BEGIN@296
302
303
# spent 33.3ms (3.97+29.3) within Module::Runtime::require_module which was called 103 times, avg 323µs/call: # 97 times (2.27ms+8.54ms) by Module::Runtime::use_package_optimistically at line 381, avg 111µs/call # 4 times (988µs+19.7ms) by Module::Runtime::use_module at line 348, avg 5.17ms/call # 2 times (713µs+1.13ms) by Module::Implementation::try {...} at line 85 of Module/Implementation.pm, avg 920µs/call
sub require_module($) {
304 # Localise %^H to work around [perl #68590], where the bug exists
305 # and this is a satisfactory workaround. The bug consists of
306 # %^H state leaking into each required module, polluting the
307 # module's lexical state.
308 local %^H if _WORK_AROUND_HINT_LEAKAGE;
30910325µs if(_WORK_AROUND_BROKEN_MODULE_STATE) {
310 my $notional_filename = &module_notional_filename;
311 my $guard = bless([ $notional_filename ],
312 "Module::Runtime::__GUARD__");
313 my $result = CORE::require($notional_filename);
314 pop @$guard;
315 return $result;
316 } else {
3171031.40ms1031.97ms return scalar(CORE::require(&module_notional_filename));
# spent 1.97ms making 103 calls to Module::Runtime::module_notional_filename, avg 19µs/call
318 }
319}
320
321=back
322
323=head2 Structured module use
324
325=over
326
327=item use_module(NAME[, VERSION])
328
329This is essentially C<use> in runtime form, but without the importing
330feature (which is fundamentally a compile-time thing). The I<NAME> is
331handled just like in C<require_module> above: it must be a module name,
332and the named module is loaded as if by the bareword form of C<require>.
333
334If a I<VERSION> is specified, the C<VERSION> method of the loaded module is
335called with the specified I<VERSION> as an argument. This normally serves to
336ensure that the version loaded is at least the version required. This is
337the same functionality provided by the I<VERSION> parameter of C<use>.
338
339On success, the name of the module is returned. This is unlike
340L</require_module>, and is done so that the entire call to L</use_module>
341can be used as a class name to call a constructor, as in the example in
342the synopsis.
343
344=cut
345
346
# spent 20.7ms (32µs+20.7) within Module::Runtime::use_module which was called 4 times, avg 5.17ms/call: # 4 times (32µs+20.7ms) by Moose::Util::_apply_all_roles at line 147 of Moose/Util.pm, avg 5.17ms/call
sub use_module($;$) {
34744µs my($name, $version) = @_;
34849µs420.7ms require_module($name);
# spent 20.7ms making 4 calls to Module::Runtime::require_module, avg 5.17ms/call
34943µs $name->VERSION($version) if @_ >= 2;
350410µs return $name;
351}
352
353=item use_package_optimistically(NAME[, VERSION])
354
355This is an analogue of L</use_module> for the situation where there is
356uncertainty as to whether a package/class is defined in its own module
357or by some other means. It attempts to arrange for the named package to
358be available, either by loading a module or by doing nothing and hoping.
359
360An attempt is made to load the named module (as if by the bareword form
361of C<require>). If the module cannot be found then it is assumed that
362the package was actually already loaded by other means, and no error
363is signalled. That's the optimistic bit.
364
365This is mostly the same operation that is performed by the L<base> pragma
366to ensure that the specified base classes are available. The behaviour
367of L<base> was simplified in version 2.18, and later improved in version
3682.20, and on both occasions this function changed to match.
369
370If a I<VERSION> is specified, the C<VERSION> method of the loaded package is
371called with the specified I<VERSION> as an argument. This normally serves
372to ensure that the version loaded is at least the version required.
373On success, the name of the package is returned. These aspects of the
374function work just like L</use_module>.
375
376=cut
377
378
# spent 15.3ms (1.47+13.8) within Module::Runtime::use_package_optimistically which was called 97 times, avg 157µs/call: # 46 times (661µs+2.57ms) by Class::MOP::Class::_inline_constructor at line 1450 of Class/MOP/Class.pm, avg 70µs/call # 22 times (330µs+7.83ms) by Moose::Util::_load_user_class at line 349 of Moose/Util.pm, avg 371µs/call # 16 times (264µs+899µs) by Class::MOP::Class::_inline_destructor at line 1491 of Class/MOP/Class.pm, avg 73µs/call # 12 times (194µs+2.44ms) by Class::MOP::MiniTrait::apply at line 13 of Class/MOP/MiniTrait.pm, avg 219µs/call # once (18µs+53µs) by metaclass::import at line 22 of metaclass.pm
sub use_package_optimistically($;$) {
3799780µs my($name, $version) = @_;
38097198µs973.03ms my $fn = module_notional_filename($name);
# spent 3.03ms making 97 calls to Module::Runtime::module_notional_filename, avg 31µs/call
381291592µs9710.8ms eval { local $SIG{__DIE__}; require_module($name); };
# spent 10.8ms making 97 calls to Module::Runtime::require_module, avg 112µs/call, recursion: max depth 1, sum of overlapping time 34µs
382 die $@ if $@ ne "" &&
383 ($@ !~ /\ACan't locate \Q$fn\E .+ at \Q@{[__FILE__]}\E line/s ||
3849744µs $@ =~ /^Compilation\ failed\ in\ require
385 \ at\ \Q@{[__FILE__]}\E\ line/xm);
3869750µs $name->VERSION($version) if @_ >= 2;
38797255µs return $name;
388}
389
390=back
391
392=head2 Module name composition
393
394=over
395
396=item is_module_spec(PREFIX, SPEC)
397
398Returns a truth value indicating
399whether I<SPEC> is valid input for L</compose_module_name>.
400See below for what that entails. Whether a I<PREFIX> is supplied affects
401the validity of I<SPEC>, but the exact value of the prefix is unimportant,
402so this function treats I<PREFIX> as a truth value.
403
404=cut
405
406sub is_module_spec($$) {
407 my($prefix, $spec) = @_;
408 return _is_string($spec) &&
409 $spec =~ ($prefix ? qr/\A$sub_module_spec_rx\z/o :
410 qr/\A$top_module_spec_rx\z/o);
411}
412
413=item is_valid_module_spec(PREFIX, SPEC)
414
415Deprecated alias for L</is_module_spec>.
416
417=cut
418
4191800ns*is_valid_module_spec = \&is_module_spec;
420
421=item check_module_spec(PREFIX, SPEC)
422
423Check whether I<SPEC> is valid input for L</compose_module_name>.
424Return normally if it is, or C<die> if it is not.
425
426=cut
427
428sub check_module_spec($$) {
429 unless(&is_module_spec) {
430 die +(_is_string($_[1]) ? "`$_[1]'" : "argument").
431 " is not a module specification\n";
432 }
433}
434
435=item compose_module_name(PREFIX, SPEC)
436
437This function is intended to make it more convenient for a user to specify
438a Perl module name at runtime. Users have greater need for abbreviations
439and context-sensitivity than programmers, and Perl module names get a
440little unwieldy. I<SPEC> is what the user specifies, and this function
441translates it into a module name in standard form, which it returns.
442
443I<SPEC> has syntax approximately that of a standard module name: it
444should consist of one or more name segments, each of which consists
445of one or more identifier characters. However, C</> is permitted as a
446separator, in addition to the standard C<::>. The two separators are
447entirely interchangeable.
448
449Additionally, if I<PREFIX> is not C<undef> then it must be a module
450name in standard form, and it is prefixed to the user-specified name.
451The user can inhibit the prefix addition by starting I<SPEC> with a
452separator (either C</> or C<::>).
453
454=cut
455
456sub compose_module_name($$) {
457 my($prefix, $spec) = @_;
458 check_module_name($prefix) if defined $prefix;
459 &check_module_spec;
460 if($spec =~ s#\A(?:/|::)##) {
461 # OK
462 } else {
463 $spec = $prefix."::".$spec if defined $prefix;
464 }
465 $spec =~ s#/#::#g;
466 return $spec;
467}
468
469=back
470
471=head1 BUGS
472
473On Perl versions 5.7.2 to 5.8.8, if C<require> is overridden by the
474C<CORE::GLOBAL> mechanism, it is likely to break the heuristics used by
475L</use_package_optimistically>, making it signal an error for a missing
476module rather than assume that it was already loaded. From Perl 5.8.9
477onwards, and on 5.7.1 and earlier, this module can avoid being confused
478by such an override. On the affected versions, a C<require> override
479might be installed by L<Lexical::SealRequireHints>, if something requires
480its bugfix but for some reason its XS implementation isn't available.
481
482=head1 SEE ALSO
483
484L<Lexical::SealRequireHints>,
485L<base>,
486L<perlfunc/require>,
487L<perlfunc/use>
488
489=head1 AUTHOR
490
491Andrew Main (Zefram) <zefram@fysh.org>
492
493=head1 COPYRIGHT
494
495Copyright (C) 2004, 2006, 2007, 2009, 2010, 2011, 2012, 2014
496Andrew Main (Zefram) <zefram@fysh.org>
497
498=head1 LICENSE
499
500This module is free software; you can redistribute it and/or modify it
501under the same terms as Perl itself.
502
503=cut
504
505142µs1;
 
# spent 830µs within Module::Runtime::CORE:match which was called 240 times, avg 3µs/call: # 222 times (811µs+0s) by Module::Runtime::is_module_name at line 222, avg 4µs/call # 18 times (18µs+0s) by Module::Runtime::import at line 143, avg 1µs/call
sub Module::Runtime::CORE:match; # opcode
# spent 38µs within Module::Runtime::CORE:qr which was called 6 times, avg 6µs/call: # once (23µs+0s) by Moose::BEGIN@11 at line 179 # once (6µs+0s) by Moose::BEGIN@11 at line 203 # once (2µs+0s) by Moose::BEGIN@11 at line 188 # once (2µs+0s) by Moose::BEGIN@11 at line 205 # once (2µs+0s) by Moose::BEGIN@11 at line 194 # once (2µs+0s) by Moose::BEGIN@11 at line 191
sub Module::Runtime::CORE:qr; # opcode
# spent 113µs within Module::Runtime::CORE:regcomp which was called 3 times, avg 38µs/call: # once (54µs+0s) by Moose::BEGIN@11 at line 194 # once (41µs+0s) by Moose::BEGIN@11 at line 205 # once (18µs+0s) by Module::Runtime::is_module_name at line 222
sub Module::Runtime::CORE:regcomp; # opcode
# spent 710µs within Module::Runtime::CORE:subst which was called 222 times, avg 3µs/call: # 222 times (710µs+0s) by Module::Runtime::module_notional_filename at line 266, avg 3µs/call
sub Module::Runtime::CORE:subst; # opcode