]> git.vpit.fr Git - perl/modules/subs-auto.git/blob - auto.pm
e804cf57c45be09e50df7f8dd95d02c557321d5c
[perl/modules/subs-auto.git] / auto.pm
1 package subs::auto;
2
3 use 5.010;
4
5 use strict;
6 use warnings;
7
8 =head1 NAME
9
10 subs::auto - Read barewords as subroutine names.
11
12 =head1 VERSION
13
14 Version 0.07
15
16 =cut
17
18 our $VERSION;
19 BEGIN {
20  $VERSION = '0.07';
21 }
22
23 =head1 SYNOPSIS
24
25     {
26      use subs::auto;
27      foo;             # Compile to "foo()"     instead of "'foo'"
28                       #                        or croaking on strict subs
29      foo $x;          # Compile to "foo($x)"   instead of "$x->foo"
30      foo 1;           # Compile to "foo(1)"    instead of croaking
31      foo 1, 2;        # Compile to "foo(1, 2)" instead of croaking
32      foo(@a);         # Still ok
33      foo->meth;       # "'foo'->meth" if you have use'd foo somewhere,
34                       #  or "foo()->meth" otherwise
35      print foo 'wut'; # print to the filehandle foo if it's actually one,
36                       #  or "print(foo('wut'))" otherwise
37     } # ... but function calls will fail at run-time if you don't
38       # actually define foo somewhere
39     
40     foo; # BANG
41
42 =head1 DESCRIPTION
43
44 This pragma lexically enables the parsing of any bareword as a subroutine name, except those which corresponds to an entry in C<%INC> (expected to be class names) or whose symbol table entry has an IO slot (expected to be filehandles).
45
46 You can pass options to C<import> as key / value pairs :
47
48 =over 4
49
50 =item *
51
52 C<< in => $pkg >>
53
54 Specifies on which package the pragma should act.
55 Setting C<$pkg> to C<Some::Package> allows you to resolve all functions name of the type C<Some::Package::func ...> in the current scope.
56 You can use the pragma several times with different package names to allow resolution of all the corresponding barewords.
57
58 Defaults to the current package.
59
60 =back
61
62 This module is B<not> a source filter.
63
64 =cut
65
66 use B;
67
68 use B::Keywords;
69
70 use Variable::Magic 0.31 qw<wizard cast dispell getdata>;
71
72 BEGIN {
73  unless (Variable::Magic::VMG_UVAR) {
74   require Carp;
75   Carp::croak('uvar magic not available');
76  }
77  require XSLoader;
78  XSLoader::load(__PACKAGE__, $VERSION);
79 }
80
81 my %core;
82 @core{
83  @B::Keywords::Barewords,
84  @B::Keywords::Functions,
85  'DATA',
86 } = ();
87 delete @core{qw<my local>};
88
89 BEGIN {
90  *_REFCNT_PLACEHOLDERS = eval 'sub () { ' . ($] < 5.011002 ? 0 : 1) . '}'
91 }
92
93 my $tag = wizard data => sub { \(my $data = _REFCNT_PLACEHOLDERS ? 2 : 1) };
94
95 sub _reset {
96  my $fqn = join '::', @_;
97
98  my $cb = do {
99   no strict 'refs';
100   no warnings 'once';
101   *$fqn{CODE};
102  };
103
104  if ($cb and defined(my $data = getdata(&$cb, $tag))) {
105   $$data--;
106   return if $$data > 0;
107
108   _delete_sub($fqn);
109  }
110 }
111
112 sub _fetch {
113  (undef, my $data, my $name) = @_;
114
115  return if $data->{guard};
116  local $data->{guard} = 1;
117
118  return if $name =~ /::/
119         or exists $core{$name};
120
121  my $op_name = $_[-1] || '';
122  return if $op_name =~ /method/;
123
124  my $pkg = $data->{pkg};
125
126  my $hints = (caller 0)[10];
127  if ($hints and $hints->{+(__PACKAGE__)}) {
128   my $pm = $name . '.pm';
129   return if exists $INC{$pm};
130
131   my $fqn = $pkg . '::' . $name;
132   my $cb  = do { no strict 'refs'; *$fqn{CODE} };
133   if ($cb) {
134    if (_REFCNT_PLACEHOLDERS and defined(my $data = getdata(&$cb, $tag))) {
135     ++$$data;
136    }
137    return;
138   }
139   return if do { no strict 'refs'; *$fqn{IO} };
140
141   $cb = sub {
142    my ($file, $line) = (caller 0)[1, 2];
143    ($file, $line) = ('(eval 0)', 0) unless $file && $line;
144    die "Undefined subroutine &$fqn called at $file line $line\n";
145   };
146   cast &$cb, $tag;
147
148   no strict 'refs';
149   *$fqn = $cb;
150  } else {
151   _reset($pkg, $name);
152  }
153
154  return;
155 }
156
157 sub _store {
158  (undef, my $data, my $name) = @_;
159
160  return if $data->{guard};
161  local $data->{guard} = 1;
162
163  _reset($data->{pkg}, $name);
164
165  return;
166 }
167
168 my $wiz = wizard data    => sub { +{ pkg => $_[1], guard => 0 } },
169                  fetch   => \&_fetch,
170                  store   => \&_store,
171                  op_info => Variable::Magic::VMG_OP_INFO_NAME;
172
173 my %pkgs;
174
175 my $pkg_rx = qr/
176  ^(?:
177      ::
178     |
179      (?:::)?
180      [A-Za-z_][A-Za-z0-9_]*
181      (?:::[A-Za-z_][A-Za-z0-9_]*)*
182      (?:::)?
183   )$
184 /x;
185
186 sub _validate_pkg {
187  my ($pkg, $cur) = @_;
188
189  return $cur unless defined $pkg;
190
191  if (ref $pkg or $pkg !~ $pkg_rx) {
192   require Carp;
193   Carp::croak('Invalid package name');
194  }
195
196  $pkg =~ s/::$//;
197  $pkg = $cur . $pkg if $pkg eq '' or $pkg =~ /^::/;
198  $pkg;
199 }
200
201 sub import {
202  shift;
203  if (@_ % 2) {
204   require Carp;
205   Carp::croak('Optional arguments must be passed as keys/values pairs');
206  }
207  my %args = @_;
208
209  my $cur = caller;
210  my $in  = _validate_pkg $args{in}, $cur;
211  ++$pkgs{$in};
212  {
213   no strict 'refs';
214   cast %{$in . '::'}, $wiz, $in;
215  }
216
217  $^H{+(__PACKAGE__)} = 1;
218  $^H |= 0x020000;
219
220  return;
221 }
222
223 sub unimport {
224  $^H{+(__PACKAGE__)} = 0;
225 }
226
227 {
228  no warnings 'void';
229  CHECK {
230   no strict 'refs';
231   dispell %{$_ . '::'}, $wiz for keys %pkgs;
232  }
233 }
234
235 =head1 EXPORT
236
237 None.
238
239 =head1 CAVEATS
240
241 C<*{'::foo'}{CODE}> will appear as defined in a scope where the pragma is enabled, C<foo> is used as a bareword, but is never actually defined afterwards.
242 This may or may not be considered as Doing The Right Thing.
243 However, C<*{'::foo'}{CODE}> will always return the right value if you fetch it outside the pragma's scope.
244 Actually, you can make it return the right value even in the pragma's scope by reading C<*{'::foo'}{CODE}> outside (or by actually defining C<foo>, which is ultimately why you use this pragma, right ?).
245
246 You have to open global filehandles outside of the scope of this pragma if you want them not to be treated as function calls.
247 Or just use lexical filehandles and default ones as you should be.
248
249 This pragma doesn't propagate into C<eval STRING>.
250
251 =head1 DEPENDENCIES
252
253 L<perl> 5.10.0.
254
255 L<Variable::Magic> with C<uvar> magic enabled (this should be assured by the required perl version).
256
257 L<B::Keywords>.
258
259 L<Carp> (standard since perl 5), L<XSLoader> (since 5.006).
260
261 =head1 AUTHOR
262
263 Vincent Pit, C<< <perl at profvince.com> >>, L<http://www.profvince.com>.
264
265 You can contact me by mail or on C<irc.perl.org> (vincent).
266
267 =head1 BUGS
268
269 Please report any bugs or feature requests to C<bug-subs-auto at rt.cpan.org>, or through the web interface at L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=subs-auto>.
270 I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.
271
272 =head1 SUPPORT
273
274 You can find documentation for this module with the perldoc command.
275
276     perldoc subs::auto
277
278 Tests code coverage report is available at L<http://www.profvince.com/perl/cover/subs-auto>.
279
280 =head1 ACKNOWLEDGEMENTS
281
282 Thanks to Sebastien Aperghis-Tramoni for helping to name this pragma.
283
284 =head1 COPYRIGHT & LICENSE
285
286 Copyright 2008,2009,2010,2011 Vincent Pit, all rights reserved.
287
288 This program is free software; you can redistribute it and/or modify it
289 under the same terms as Perl itself.
290
291 =cut
292
293 1; # End of subs::auto