Filename | /usr/local/share/perl/5.18.2/Module/Runtime.pm |
Statements | Executed 1409172 statements in 7.73s |
Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
---|---|---|---|---|---|
100752 | 1 | 1 | 1.86s | 3.03s | is_module_name | Module::Runtime::
100741 | 7 | 5 | 1.47s | 5.52s | module_notional_filename | Module::Runtime::
100094 | 3 | 3 | 1.10s | 7.88s | use_module (recurses: max depth 3, inclusive time 38.4ms) | Module::Runtime::
100432 | 6 | 5 | 896ms | 7.22s | require_module (recurses: max depth 5, inclusive time 378ms) | Module::Runtime::
100780 | 3 | 1 | 608ms | 608ms | CORE:match (opcode) | Module::Runtime::
100752 | 3 | 2 | 591ms | 3.63s | check_module_name | Module::Runtime::
100752 | 1 | 1 | 496ms | 496ms | _is_string | Module::Runtime::
100741 | 1 | 1 | 422ms | 422ms | CORE:subst (opcode) | Module::Runtime::
100762 | 4 | 1 | 70.7ms | 70.7ms | CORE:regcomp (opcode) | Module::Runtime::
226 | 6 | 4 | 6.54ms | 595ms | use_package_optimistically (recurses: max depth 1, inclusive time 8.59ms) | Module::Runtime::
15 | 15 | 15 | 193µs | 206µs | import | Module::Runtime::
1 | 1 | 1 | 10µs | 10µs | BEGIN@116 | Module::Runtime::
1 | 1 | 1 | 6µs | 6µs | BEGIN@289 | Module::Runtime::
6 | 6 | 1 | 6µs | 6µs | CORE:qr (opcode) | Module::Runtime::
1 | 1 | 1 | 4µs | 4µs | BEGIN@296 | Module::Runtime::
1 | 1 | 1 | 3µs | 3µs | BEGIN@120 | Module::Runtime::
0 | 0 | 0 | 0s | 0s | check_module_spec | Module::Runtime::
0 | 0 | 0 | 0s | 0s | compose_module_name | Module::Runtime::
0 | 0 | 0 | 0s | 0s | is_module_spec | Module::Runtime::
Line | State ments |
Time on line |
Calls | Time in subs |
Code |
---|---|---|---|---|---|
1 | =head1 NAME | ||||
2 | |||||
3 | Module::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 | |||||
40 | The functions exported by this module deal with runtime handling of | ||||
41 | Perl modules, which are normally handled at compile time. This module | ||||
42 | avoids using any other modules, so that it can be used in low-level | ||||
43 | infrastructure. | ||||
44 | |||||
45 | The parts of this module that work with module names apply the same syntax | ||||
46 | that is used for barewords in Perl source. In principle this syntax | ||||
47 | can vary between versions of Perl, and this module applies the syntax of | ||||
48 | the Perl on which it is running. In practice the usable syntax hasn't | ||||
49 | changed yet. There's some intent for Unicode module names to be supported | ||||
50 | in the future, but this hasn't yet amounted to any consistent facility. | ||||
51 | |||||
52 | The functions of this module whose purpose is to load modules include | ||||
53 | workarounds for three old Perl core bugs regarding C<require>. These | ||||
54 | workarounds are applied on any Perl version where the bugs exist, except | ||||
55 | for a case where one of the bugs cannot be adequately worked around in | ||||
56 | pure Perl. | ||||
57 | |||||
58 | =head2 Module name syntax | ||||
59 | |||||
60 | The usable module name syntax has not changed from Perl 5.000 up to | ||||
61 | Perl 5.19.8. The syntax is composed entirely of ASCII characters. | ||||
62 | From Perl 5.6 onwards there has been some attempt to allow the use of | ||||
63 | non-ASCII Unicode characters in Perl source, but it was fundamentally | ||||
64 | broken (like the entirety of Perl 5.6's Unicode handling) and remained | ||||
65 | pretty much entirely unusable until it got some attention in the Perl | ||||
66 | 5.15 series. Although Unicode is now consistently accepted by the | ||||
67 | parser in some places, it remains broken for module names. Furthermore, | ||||
68 | there has not yet been any work on how to map Unicode module names into | ||||
69 | filenames, so in that respect also Unicode module names are unusable. | ||||
70 | |||||
71 | The module name syntax is, precisely: the string must consist of one or | ||||
72 | more segments separated by C<::>; each segment must consist of one or more | ||||
73 | identifier characters (ASCII alphanumerics plus "_"); the first character | ||||
74 | of the string must not be a digit. Thus "C<IO::File>", "C<warnings>", | ||||
75 | and "C<foo::123::x_0>" are all valid module names, whereas "C<IO::>" | ||||
76 | and "C<1foo::bar>" are not. C<'> separators are not permitted by this | ||||
77 | module, though they remain usable in Perl source, being translated to | ||||
78 | C<::> in the parser. | ||||
79 | |||||
80 | =head2 Core bugs worked around | ||||
81 | |||||
82 | The first bug worked around is core bug [perl #68590], which causes | ||||
83 | lexical state in one file to leak into another that is C<require>d/C<use>d | ||||
84 | from it. This bug is present from Perl 5.6 up to Perl 5.10, and is | ||||
85 | fixed in Perl 5.11.0. From Perl 5.9.4 up to Perl 5.10.0 no satisfactory | ||||
86 | workaround is possible in pure Perl. The workaround means that modules | ||||
87 | loaded via this module don't suffer this pollution of their lexical | ||||
88 | state. Modules loaded in other ways, or via this module on the Perl | ||||
89 | versions where the pure Perl workaround is impossible, remain vulnerable. | ||||
90 | The module L<Lexical::SealRequireHints> provides a complete workaround | ||||
91 | for this bug. | ||||
92 | |||||
93 | The second bug worked around causes some kinds of failure in module | ||||
94 | loading, principally compilation errors in the loaded module, to be | ||||
95 | recorded in C<%INC> as if they were successful, so later attempts to load | ||||
96 | the same module immediately indicate success. This bug is present up | ||||
97 | to Perl 5.8.9, and is fixed in Perl 5.9.0. The workaround means that a | ||||
98 | compilation error in a module loaded via this module won't be cached as | ||||
99 | a success. Modules loaded in other ways remain liable to produce bogus | ||||
100 | C<%INC> entries, and if a bogus entry exists then it will mislead this | ||||
101 | module if it is used to re-attempt loading. | ||||
102 | |||||
103 | The third bug worked around causes the wrong context to be seen at | ||||
104 | file scope of a loaded module, if C<require> is invoked in a location | ||||
105 | that inherits context from a higher scope. This bug is present up to | ||||
106 | Perl 5.11.2, and is fixed in Perl 5.11.3. The workaround means that | ||||
107 | a module loaded via this module will always see the correct context. | ||||
108 | Modules loaded in other ways remain vulnerable. | ||||
109 | |||||
110 | =cut | ||||
111 | |||||
112 | package 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. | ||||
116 | 1 | 27µs | 1 | 10µs | # spent 10µs within Module::Runtime::BEGIN@116 which was called:
# once (10µs+0s) by Module::Implementation::BEGIN@12 at line 116 # spent 10µ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". | ||||
120 | 1 | 527µs | 1 | 3µs | # spent 3µs within Module::Runtime::BEGIN@120 which was called:
# once (3µs+0s) by Module::Implementation::BEGIN@12 at line 120 # spent 3µs making 1 call to Module::Runtime::BEGIN@120 |
121 | # Don't "use strict" here, to avoid dependencies. | ||||
122 | |||||
123 | 1 | 400ns | our $VERSION = "0.014"; | ||
124 | |||||
125 | # Don't use Exporter here, to avoid dependencies. | ||||
126 | 1 | 2µs | our @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 | ); | ||||
134 | 1 | 8µs | my %export_ok = map { ($_ => undef) } @EXPORT_OK; | ||
135 | # spent 206µs (193+12) within Module::Runtime::import which was called 15 times, avg 14µs/call:
# once (20µs+1000ns) by Class::Load::BEGIN@12 at line 12 of Class/Load.pm
# once (20µs+1µs) by Moose::Util::BEGIN@7 at line 7 of Moose/Util.pm
# once (16µs+1µs) by metaclass::BEGIN@7 at line 7 of metaclass.pm
# once (14µs+900ns) by Moose::Meta::Attribute::Native::BEGIN@6 at line 6 of Moose/Meta/Attribute/Native.pm
# once (13µs+1µs) by Moose::Meta::Attribute::Native::Trait::BEGIN@5 at line 5 of Moose/Meta/Attribute/Native/Trait.pm
# once (14µs+900ns) by Class::MOP::Class::Immutable::Trait::BEGIN@8 at line 8 of Class/MOP/Class/Immutable/Trait.pm
# once (14µs+800ns) by Class::MOP::MiniTrait::BEGIN@7 at line 7 of Class/MOP/MiniTrait.pm
# once (13µs+1µs) by HTTP::Headers::ActionPack::BEGIN@15 at line 15 of HTTP/Headers/ActionPack.pm
# once (13µs+500ns) by Class::MOP::Mixin::BEGIN@8 at line 8 of Class/MOP/Mixin.pm
# once (12µs+700ns) by Moose::Role::BEGIN@9 at line 9 of Moose/Role.pm
# once (12µs+700ns) by Moose::BEGIN@11 at line 11 of Moose.pm
# once (10µs+1µs) by Module::Implementation::BEGIN@12 at line 12 of Module/Implementation.pm
# once (10µs+400ns) by Class::MOP::Package::BEGIN@9 at line 9 of Class/MOP/Package.pm
# once (9µs+500ns) by Class::MOP::Class::BEGIN@14 at line 14 of Class/MOP/Class.pm
# once (4µs+0s) by Class::MOP::Object::BEGIN@9 at line 9 of Class/MOP/Object.pm | ||||
136 | 15 | 8µs | my $me = shift; | ||
137 | 15 | 9µs | my $callpkg = caller(0); | ||
138 | 15 | 4µs | my $errs = ""; | ||
139 | 15 | 14µs | foreach(@_) { | ||
140 | 20 | 23µs | if(exists $export_ok{$_}) { | ||
141 | # We would need to do "no strict 'refs'" here | ||||
142 | # if we had enabled strict at file scope. | ||||
143 | 20 | 59µs | 20 | 12µs | if(/\A\$(.*)\z/s) { # spent 12µs making 20 calls to Module::Runtime::CORE:match, avg 615ns/call |
144 | *{$callpkg."::".$1} = \$$1; | ||||
145 | } else { | ||||
146 | 20 | 64µs | *{$callpkg."::".$_} = \&$_; | ||
147 | } | ||||
148 | } else { | ||||
149 | $errs .= "\"$_\" is not exported by the $me module\n"; | ||||
150 | } | ||||
151 | } | ||||
152 | 15 | 52µ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 496ms within Module::Runtime::_is_string which was called 100752 times, avg 5µs/call:
# 100752 times (496ms+0s) by Module::Runtime::is_module_name at line 222, avg 5µs/call | ||||
161 | 100752 | 96.4ms | my($arg) = @_; | ||
162 | 100752 | 732ms | return defined($arg) && ref(\$arg) eq "SCALAR"; | ||
163 | } | ||||
164 | |||||
165 | =head1 REGULAR EXPRESSIONS | ||||
166 | |||||
167 | These regular expressions do not include any anchors, so to check | ||||
168 | whether an entire string matches a syntax item you must supply the | ||||
169 | anchors yourself. | ||||
170 | |||||
171 | =over | ||||
172 | |||||
173 | =item $module_name_rx | ||||
174 | |||||
175 | Matches a valid Perl module name in bareword syntax. | ||||
176 | |||||
177 | =cut | ||||
178 | |||||
179 | 1 | 8µs | 1 | 3µs | our $module_name_rx = qr/[A-Z_a-z][0-9A-Z_a-z]*(?:::[0-9A-Z_a-z]+)*/; # spent 3µs making 1 call to Module::Runtime::CORE:qr |
180 | |||||
181 | =item $top_module_spec_rx | ||||
182 | |||||
183 | Matches a module specification for use with L</compose_module_name>, | ||||
184 | where no prefix is being used. | ||||
185 | |||||
186 | =cut | ||||
187 | |||||
188 | 1 | 3µs | 1 | 800ns | my $qual_module_spec_rx = # spent 800ns 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 | |||||
191 | 1 | 2µs | 1 | 400ns | my $unqual_top_module_spec_rx = # spent 400ns 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 | |||||
194 | 1 | 32µs | 2 | 27µs | our $top_module_spec_rx = qr/$qual_module_spec_rx|$unqual_top_module_spec_rx/o; # spent 26µs making 1 call to Module::Runtime::CORE:regcomp
# spent 700ns making 1 call to Module::Runtime::CORE:qr |
195 | |||||
196 | =item $sub_module_spec_rx | ||||
197 | |||||
198 | Matches a module specification for use with L</compose_module_name>, | ||||
199 | where a prefix is being used. | ||||
200 | |||||
201 | =cut | ||||
202 | |||||
203 | 1 | 3µs | 1 | 500ns | my $unqual_sub_module_spec_rx = qr#[0-9A-Z_a-z]+(?:(?:/|::)[0-9A-Z_a-z]+)*#; # spent 500ns making 1 call to Module::Runtime::CORE:qr |
204 | |||||
205 | 1 | 23µs | 2 | 19µs | our $sub_module_spec_rx = qr/$qual_module_spec_rx|$unqual_sub_module_spec_rx/o; # spent 18µs making 1 call to Module::Runtime::CORE:regcomp
# spent 700ns 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 | |||||
217 | Returns a truth value indicating whether I<ARG> is a plain string | ||||
218 | satisfying Perl module name syntax as described for L</$module_name_rx>. | ||||
219 | |||||
220 | =cut | ||||
221 | |||||
222 | 100752 | 2.48s | 302256 | 1.18s | # spent 3.03s (1.86+1.18) within Module::Runtime::is_module_name which was called 100752 times, avg 30µs/call:
# 100752 times (1.86s+1.18s) by Module::Runtime::check_module_name at line 241, avg 30µs/call # spent 608ms making 100752 calls to Module::Runtime::CORE:match, avg 6µs/call
# spent 496ms making 100752 calls to Module::Runtime::_is_string, avg 5µs/call
# spent 70.6ms making 100752 calls to Module::Runtime::CORE:regcomp, avg 701ns/call |
223 | |||||
224 | =item is_valid_module_name(ARG) | ||||
225 | |||||
226 | Deprecated alias for L</is_module_name>. | ||||
227 | |||||
228 | =cut | ||||
229 | |||||
230 | 1 | 900ns | *is_valid_module_name = \&is_module_name; | ||
231 | |||||
232 | =item check_module_name(ARG) | ||||
233 | |||||
234 | Check whether I<ARG> is a plain string | ||||
235 | satisfying Perl module name syntax as described for L</$module_name_rx>. | ||||
236 | Return normally if it is, or C<die> if it is not. | ||||
237 | |||||
238 | =cut | ||||
239 | |||||
240 | # spent 3.63s (591ms+3.03) within Module::Runtime::check_module_name which was called 100752 times, avg 36µs/call:
# 100741 times (591ms+3.03s) by Module::Runtime::module_notional_filename at line 264, avg 36µs/call
# 10 times (23µs+108µs) by Class::Load::try_load_class at line 141 of Class/Load.pm, avg 13µs/call
# once (3µs+15µs) by Class::Load::load_optional_class at line 121 of Class/Load.pm | ||||
241 | 100752 | 670ms | 100752 | 3.03s | unless(&is_module_name) { # spent 3.03s making 100752 calls to Module::Runtime::is_module_name, avg 30µ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 | |||||
249 | Generates a notional relative filename for a module, which is used in | ||||
250 | some Perl core interfaces. | ||||
251 | The I<NAME> is a string, which should be a valid module name (one or | ||||
252 | more C<::>-separated segments). If it is not a valid name, the function | ||||
253 | C<die>s. | ||||
254 | |||||
255 | The notional filename for the named module is generated and returned. | ||||
256 | This filename is always in Unix style, with C</> directory separators | ||||
257 | and a C<.pm> suffix. This kind of filename can be used as an argument to | ||||
258 | C<require>, and is the key that appears in C<%INC> to identify a module, | ||||
259 | regardless of actual local filename syntax. | ||||
260 | |||||
261 | =cut | ||||
262 | |||||
263 | # spent 5.52s (1.47+4.05) within Module::Runtime::module_notional_filename which was called 100741 times, avg 55µs/call:
# 100432 times (1.47s+4.04s) by Module::Runtime::require_module at line 317, avg 55µs/call
# 226 times (1.12ms+8.70ms) by Module::Runtime::use_package_optimistically at line 380, avg 43µs/call
# 35 times (177µs+547µs) by Moose::Role::init_meta at line 144 of Moose/Role.pm, avg 21µs/call
# 28 times (173µs+475µs) by Moose::init_meta at line 204 of Moose.pm, avg 23µs/call
# 12 times (71µs+190µs) by Class::MOP::Package::create at line 68 of Class/MOP/Package.pm, avg 22µs/call
# 7 times (37µs+78µs) by Class::Load::try_load_class at line 160 of Class/Load.pm, avg 16µs/call
# once (4µs+11µs) by Class::Load::_nonexistent_fail_re at line 100 of Class/Load.pm | ||||
264 | 100741 | 211ms | 100741 | 3.63s | &check_module_name; # spent 3.63s making 100741 calls to Module::Runtime::check_module_name, avg 36µs/call |
265 | 100741 | 94.3ms | my($name) = @_; | ||
266 | 100741 | 932ms | 100741 | 422ms | $name =~ s!::!/!g; # spent 422ms making 100741 calls to Module::Runtime::CORE:subst, avg 4µs/call |
267 | 100741 | 645ms | return $name.".pm"; | ||
268 | } | ||||
269 | |||||
270 | =item require_module(NAME) | ||||
271 | |||||
272 | This is essentially the bareword form of C<require>, in runtime form. | ||||
273 | The I<NAME> is a string, which should be a valid module name (one or | ||||
274 | more C<::>-separated segments). If it is not a valid name, the function | ||||
275 | C<die>s. | ||||
276 | |||||
277 | The module specified by I<NAME> is loaded, if it hasn't been already, | ||||
278 | in the manner of the bareword form of C<require>. That means that a | ||||
279 | search through C<@INC> is performed, and a byte-compiled form of the | ||||
280 | module will be used if available. | ||||
281 | |||||
282 | The return value is as for C<require>. That is, it is the value returned | ||||
283 | by the module itself if the module is loaded anew, or C<1> if the module | ||||
284 | was already loaded. | ||||
285 | |||||
286 | =cut | ||||
287 | |||||
288 | # Don't "use constant" here, to avoid dependencies. | ||||
289 | # spent 6µs within Module::Runtime::BEGIN@289 which was called:
# once (6µs+0s) by Module::Implementation::BEGIN@12 at line 294 | ||||
290 | *_WORK_AROUND_HINT_LEAKAGE = | ||||
291 | "$]" < 5.011 && !("$]" >= 5.009004 && "$]" < 5.010001) | ||||
292 | 1 | 2µs | ? sub(){1} : sub(){0}; | ||
293 | 1 | 5µs | *_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0}; | ||
294 | 1 | 34µs | 1 | 6µs | } # spent 6µs making 1 call to Module::Runtime::BEGIN@289 |
295 | |||||
296 | 1 | 3µs | # spent 4µs within Module::Runtime::BEGIN@296 which was called:
# once (4µs+0s) by Module::Implementation::BEGIN@12 at line 301 | ||
297 | sub Module::Runtime::__GUARD__::DESTROY { | ||||
298 | delete $INC{$_[0]->[0]} if @{$_[0]}; | ||||
299 | } | ||||
300 | 1; | ||||
301 | 1 | 396µs | 1 | 4µs | }; die $@ if $@ ne ""; } } # spent 4µs making 1 call to Module::Runtime::BEGIN@296 |
302 | |||||
303 | # spent 7.22s (896ms+6.33) within Module::Runtime::require_module which was called 100432 times, avg 72µs/call:
# 100094 times (885ms+5.72s) by Module::Runtime::use_module at line 348, avg 66µs/call
# 226 times (3.37ms+560ms) by Module::Runtime::use_package_optimistically at line 381, avg 2.49ms/call
# 100 times (3.21ms+-2.20ms) by Moose::Meta::Attribute::Native::Trait::_native_accessor_class_for at line 135 of Moose/Meta/Attribute/Native/Trait.pm, avg 10µs/call
# 7 times (3.35ms+46.1ms) by Class::Load::try {...} at line 179 of Class/Load.pm, avg 7.06ms/call
# 3 times (932µs+2.38ms) by Module::Implementation::try {...} at line 88 of Module/Implementation.pm, avg 1.10ms/call
# 2 times (436µs+-436µs) by Moose::Meta::Attribute::Custom::Trait::Array::register_implementation or Moose::Meta::Attribute::Custom::Trait::Hash::register_implementation at line 24 of Moose/Meta/Attribute/Native.pm, avg 0s/call | ||||
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; | ||||
309 | 100432 | 43.7ms | 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 { | ||||
317 | 100432 | 892ms | 100432 | 5.51s | return scalar(CORE::require(&module_notional_filename)); # spent 5.51s making 100432 calls to Module::Runtime::module_notional_filename, avg 55µs/call |
318 | } | ||||
319 | } | ||||
320 | |||||
321 | =back | ||||
322 | |||||
323 | =head2 Structured module use | ||||
324 | |||||
325 | =over | ||||
326 | |||||
327 | =item use_module(NAME[, VERSION]) | ||||
328 | |||||
329 | This is essentially C<use> in runtime form, but without the importing | ||||
330 | feature (which is fundamentally a compile-time thing). The I<NAME> is | ||||
331 | handled just like in C<require_module> above: it must be a module name, | ||||
332 | and the named module is loaded as if by the bareword form of C<require>. | ||||
333 | |||||
334 | If a I<VERSION> is specified, the C<VERSION> method of the loaded module is | ||||
335 | called with the specified I<VERSION> as an argument. This normally serves to | ||||
336 | ensure that the version loaded is at least the version required. This is | ||||
337 | the same functionality provided by the I<VERSION> parameter of C<use>. | ||||
338 | |||||
339 | On success, the name of the module is returned. This is unlike | ||||
340 | L</require_module>, and is done so that the entire call to L</use_module> | ||||
341 | can be used as a class name to call a constructor, as in the example in | ||||
342 | the synopsis. | ||||
343 | |||||
344 | =cut | ||||
345 | |||||
346 | # spent 7.88s (1.10+6.78) within Module::Runtime::use_module which was called 100094 times, avg 79µs/call:
# 100001 times (1.10s+6.39s) by HTTP::Headers::ActionPack::create_header at line 100 of HTTP/Headers/ActionPack.pm, avg 75µs/call
# 92 times (395µs+245ms) by Moose::Util::_apply_all_roles at line 147 of Moose/Util.pm, avg 2.67ms/call
# once (7µs+143ms) by PONAPI::Server::_load_dao at line 88 of lib/PONAPI/Server.pm | ||||
347 | 100094 | 83.2ms | my($name, $version) = @_; | ||
348 | 100094 | 223ms | 100094 | 6.61s | require_module($name); # spent 6.82s making 100094 calls to Module::Runtime::require_module, avg 68µs/call, recursion: max depth 5, sum of overlapping time 211ms |
349 | 100094 | 85.8ms | $name->VERSION($version) if @_ >= 2; | ||
350 | 100094 | 538ms | return $name; | ||
351 | } | ||||
352 | |||||
353 | =item use_package_optimistically(NAME[, VERSION]) | ||||
354 | |||||
355 | This is an analogue of L</use_module> for the situation where there is | ||||
356 | uncertainty as to whether a package/class is defined in its own module | ||||
357 | or by some other means. It attempts to arrange for the named package to | ||||
358 | be available, either by loading a module or by doing nothing and hoping. | ||||
359 | |||||
360 | An attempt is made to load the named module (as if by the bareword form | ||||
361 | of C<require>). If the module cannot be found then it is assumed that | ||||
362 | the package was actually already loaded by other means, and no error | ||||
363 | is signalled. That's the optimistic bit. | ||||
364 | |||||
365 | This is mostly the same operation that is performed by the L<base> pragma | ||||
366 | to ensure that the specified base classes are available. The behaviour | ||||
367 | of L<base> was simplified in version 2.18, and later improved in version | ||||
368 | 2.20, and on both occasions this function changed to match. | ||||
369 | |||||
370 | If a I<VERSION> is specified, the C<VERSION> method of the loaded package is | ||||
371 | called with the specified I<VERSION> as an argument. This normally serves | ||||
372 | to ensure that the version loaded is at least the version required. | ||||
373 | On success, the name of the package is returned. These aspects of the | ||||
374 | function work just like L</use_module>. | ||||
375 | |||||
376 | =cut | ||||
377 | |||||
378 | # spent 595ms (6.54+588) within Module::Runtime::use_package_optimistically which was called 226 times, avg 2.63ms/call:
# 121 times (5.34ms+579ms) by Moose::Util::_load_user_class at line 349 of Moose/Util.pm, avg 4.83ms/call
# 58 times (631µs+6.96ms) by Class::MOP::Class::_inline_constructor at line 1450 of Class/MOP/Class.pm, avg 131µs/call
# 28 times (315µs+703µs) by Class::MOP::Class::_inline_destructor at line 1491 of Class/MOP/Class.pm, avg 36µs/call
# 12 times (137µs+1.41ms) by Class::MOP::MiniTrait::apply at line 13 of Class/MOP/MiniTrait.pm, avg 129µs/call
# 6 times (106µs+-106µs) by Moose::Util::resolve_metaclass_alias at line 239 of Moose/Util.pm, avg 0s/call
# once (7µs+33µs) by metaclass::import at line 22 of metaclass.pm | ||||
379 | 226 | 98µs | my($name, $version) = @_; | ||
380 | 226 | 268µs | 226 | 9.82ms | my $fn = module_notional_filename($name); # spent 9.82ms making 226 calls to Module::Runtime::module_notional_filename, avg 43µs/call |
381 | 678 | 987µs | 226 | 564ms | eval { local $SIG{__DIE__}; require_module($name); }; # spent 587ms making 226 calls to Module::Runtime::require_module, avg 2.60ms/call, recursion: max depth 5, sum of overlapping time 23.3ms |
382 | die $@ if $@ ne "" && | ||||
383 | ($@ !~ /\ACan't locate \Q$fn\E .+ at \Q@{[__FILE__]}\E line/s || | ||||
384 | 226 | 216µs | 16 | 93µs | $@ =~ /^Compilation\ failed\ in\ require # spent 81µs making 8 calls to Module::Runtime::CORE:regcomp, avg 10µs/call
# spent 12µs making 8 calls to Module::Runtime::CORE:match, avg 1µs/call |
385 | \ at\ \Q@{[__FILE__]}\E\ line/xm); | ||||
386 | 226 | 87µs | $name->VERSION($version) if @_ >= 2; | ||
387 | 226 | 415µ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 | |||||
398 | Returns a truth value indicating | ||||
399 | whether I<SPEC> is valid input for L</compose_module_name>. | ||||
400 | See below for what that entails. Whether a I<PREFIX> is supplied affects | ||||
401 | the validity of I<SPEC>, but the exact value of the prefix is unimportant, | ||||
402 | so this function treats I<PREFIX> as a truth value. | ||||
403 | |||||
404 | =cut | ||||
405 | |||||
406 | sub 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 | |||||
415 | Deprecated alias for L</is_module_spec>. | ||||
416 | |||||
417 | =cut | ||||
418 | |||||
419 | 1 | 300ns | *is_valid_module_spec = \&is_module_spec; | ||
420 | |||||
421 | =item check_module_spec(PREFIX, SPEC) | ||||
422 | |||||
423 | Check whether I<SPEC> is valid input for L</compose_module_name>. | ||||
424 | Return normally if it is, or C<die> if it is not. | ||||
425 | |||||
426 | =cut | ||||
427 | |||||
428 | sub 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 | |||||
437 | This function is intended to make it more convenient for a user to specify | ||||
438 | a Perl module name at runtime. Users have greater need for abbreviations | ||||
439 | and context-sensitivity than programmers, and Perl module names get a | ||||
440 | little unwieldy. I<SPEC> is what the user specifies, and this function | ||||
441 | translates it into a module name in standard form, which it returns. | ||||
442 | |||||
443 | I<SPEC> has syntax approximately that of a standard module name: it | ||||
444 | should consist of one or more name segments, each of which consists | ||||
445 | of one or more identifier characters. However, C</> is permitted as a | ||||
446 | separator, in addition to the standard C<::>. The two separators are | ||||
447 | entirely interchangeable. | ||||
448 | |||||
449 | Additionally, if I<PREFIX> is not C<undef> then it must be a module | ||||
450 | name in standard form, and it is prefixed to the user-specified name. | ||||
451 | The user can inhibit the prefix addition by starting I<SPEC> with a | ||||
452 | separator (either C</> or C<::>). | ||||
453 | |||||
454 | =cut | ||||
455 | |||||
456 | sub 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 | |||||
473 | On Perl versions 5.7.2 to 5.8.8, if C<require> is overridden by the | ||||
474 | C<CORE::GLOBAL> mechanism, it is likely to break the heuristics used by | ||||
475 | L</use_package_optimistically>, making it signal an error for a missing | ||||
476 | module rather than assume that it was already loaded. From Perl 5.8.9 | ||||
477 | onwards, and on 5.7.1 and earlier, this module can avoid being confused | ||||
478 | by such an override. On the affected versions, a C<require> override | ||||
479 | might be installed by L<Lexical::SealRequireHints>, if something requires | ||||
480 | its bugfix but for some reason its XS implementation isn't available. | ||||
481 | |||||
482 | =head1 SEE ALSO | ||||
483 | |||||
484 | L<Lexical::SealRequireHints>, | ||||
485 | L<base>, | ||||
486 | L<perlfunc/require>, | ||||
487 | L<perlfunc/use> | ||||
488 | |||||
489 | =head1 AUTHOR | ||||
490 | |||||
491 | Andrew Main (Zefram) <zefram@fysh.org> | ||||
492 | |||||
493 | =head1 COPYRIGHT | ||||
494 | |||||
495 | Copyright (C) 2004, 2006, 2007, 2009, 2010, 2011, 2012, 2014 | ||||
496 | Andrew Main (Zefram) <zefram@fysh.org> | ||||
497 | |||||
498 | =head1 LICENSE | ||||
499 | |||||
500 | This module is free software; you can redistribute it and/or modify it | ||||
501 | under the same terms as Perl itself. | ||||
502 | |||||
503 | =cut | ||||
504 | |||||
505 | 1 | 10µs | 1; | ||
# spent 608ms within Module::Runtime::CORE:match which was called 100780 times, avg 6µs/call:
# 100752 times (608ms+0s) by Module::Runtime::is_module_name at line 222, avg 6µs/call
# 20 times (12µs+0s) by Module::Runtime::import at line 143, avg 615ns/call
# 8 times (12µs+0s) by Module::Runtime::use_package_optimistically at line 384, avg 1µs/call | |||||
# spent 6µs within Module::Runtime::CORE:qr which was called 6 times, avg 1µs/call:
# once (3µs+0s) by Module::Implementation::BEGIN@12 at line 179
# once (800ns+0s) by Module::Implementation::BEGIN@12 at line 188
# once (700ns+0s) by Module::Implementation::BEGIN@12 at line 205
# once (700ns+0s) by Module::Implementation::BEGIN@12 at line 194
# once (500ns+0s) by Module::Implementation::BEGIN@12 at line 203
# once (400ns+0s) by Module::Implementation::BEGIN@12 at line 191 | |||||
# spent 70.7ms within Module::Runtime::CORE:regcomp which was called 100762 times, avg 702ns/call:
# 100752 times (70.6ms+0s) by Module::Runtime::is_module_name at line 222, avg 701ns/call
# 8 times (81µs+0s) by Module::Runtime::use_package_optimistically at line 384, avg 10µs/call
# once (26µs+0s) by Module::Implementation::BEGIN@12 at line 194
# once (18µs+0s) by Module::Implementation::BEGIN@12 at line 205 | |||||
# spent 422ms within Module::Runtime::CORE:subst which was called 100741 times, avg 4µs/call:
# 100741 times (422ms+0s) by Module::Runtime::module_notional_filename at line 266, avg 4µs/call |