Introduce NVef, NVff, and NVgf, use the middle one.
[perl.git] / lib / Fatal.pm
1 package Fatal;
2
3 use 5.005_64;
4 use Carp;
5 use strict;
6 our($AUTOLOAD, $Debug, $VERSION);
7
8 $VERSION = 1.02;
9
10 $Debug = 0 unless defined $Debug;
11
12 sub import {
13     my $self = shift(@_);
14     my($sym, $pkg);
15     my $void = 0;
16     $pkg = (caller)[0];
17     foreach $sym (@_) {
18         if ($sym eq ":void") {
19             $void = 1;
20         }
21         else {
22             &_make_fatal($sym, $pkg, $void);
23         }
24     }
25 };
26
27 sub AUTOLOAD {
28     my $cmd = $AUTOLOAD;
29     $cmd =~ s/.*:://;
30     &_make_fatal($cmd, (caller)[0]);
31     goto &$AUTOLOAD;
32 }
33
34 sub fill_protos {
35   my $proto = shift;
36   my ($n, $isref, @out, @out1, $seen_semi) = -1;
37   while ($proto =~ /\S/) {
38     $n++;
39     push(@out1,[$n,@out]) if $seen_semi;
40     push(@out, $1 . "{\$_[$n]}"), next if $proto =~ s/^\s*\\([\@%\$\&])//;
41     push(@out, "\$_[$n]"), next if $proto =~ s/^\s*([*\$&])//;
42     push(@out, "\@_[$n..\$#_]"), last if $proto =~ s/^\s*(;\s*)?\@//;
43     $seen_semi = 1, $n--, next if $proto =~ s/^\s*;//; # XXXX ????
44     die "Unknown prototype letters: \"$proto\"";
45   }
46   push(@out1,[$n+1,@out]);
47   @out1;
48 }
49
50 sub write_invocation {
51   my ($core, $call, $name, $void, @argvs) = @_;
52   if (@argvs == 1) {            # No optional arguments
53     my @argv = @{$argvs[0]};
54     shift @argv;
55     return "\t" . one_invocation($core, $call, $name, $void, @argv) . ";\n";
56   } else {
57     my $else = "\t";
58     my (@out, @argv, $n);
59     while (@argvs) {
60       @argv = @{shift @argvs};
61       $n = shift @argv;
62       push @out, "$ {else}if (\@_ == $n) {\n";
63       $else = "\t} els";
64       push @out, 
65           "\t\treturn " . one_invocation($core, $call, $name, $void, @argv) . ";\n";
66     }
67     push @out, <<EOC;
68         }
69         die "$name(\@_): Do not expect to get ", scalar \@_, " arguments";
70 EOC
71     return join '', @out;
72   }
73 }
74
75 sub one_invocation {
76   my ($core, $call, $name, $void, @argv) = @_;
77   local $" = ', ';
78   if ($void) { 
79     return qq/(defined wantarray)?$call(@argv):
80               $call(@argv) || croak "Can't $name(\@_)/ . 
81            ($core ? ': $!' : ', \$! is \"$!\"') . '"'
82   } else {
83     return qq{$call(@argv) || croak "Can't $name(\@_)} . 
84            ($core ? ': $!' : ', \$! is \"$!\"') . '"';
85   }
86 }
87
88 sub _make_fatal {
89     my($sub, $pkg, $void) = @_;
90     my($name, $code, $sref, $real_proto, $proto, $core, $call);
91     my $ini = $sub;
92
93     $sub = "${pkg}::$sub" unless $sub =~ /::/;
94     $name = $sub;
95     $name =~ s/.*::// or $name =~ s/^&//;
96     print "# _make_fatal: sub=$sub pkg=$pkg name=$name void=$void\n" if $Debug;
97     croak "Bad subroutine name for Fatal: $name" unless $name =~ /^\w+$/;
98     if (defined(&$sub)) {       # user subroutine
99         $sref = \&$sub;
100         $proto = prototype $sref;
101         $call = '&$sref';
102     } elsif ($sub eq $ini) {    # Stray user subroutine
103         die "$sub is not a Perl subroutine" 
104     } else {                    # CORE subroutine
105         $proto = eval { prototype "CORE::$name" };
106         die "$name is neither a builtin, nor a Perl subroutine" 
107           if $@;
108         die "Cannot make a non-overridable builtin fatal"
109           if not defined $proto;
110         $core = 1;
111         $call = "CORE::$name";
112     }
113     if (defined $proto) {
114       $real_proto = " ($proto)";
115     } else {
116       $real_proto = '';
117       $proto = '@';
118     }
119     $code = <<EOS;
120 sub$real_proto {
121         local(\$", \$!) = (', ', 0);
122 EOS
123     my @protos = fill_protos($proto);
124     $code .= write_invocation($core, $call, $name, $void, @protos);
125     $code .= "}\n";
126     print $code if $Debug;
127     {
128       no strict 'refs'; # to avoid: Can't use string (...) as a symbol ref ...
129       $code = eval("package $pkg; use Carp; $code");
130       die if $@;
131       no warnings;   # to avoid: Subroutine foo redefined ...
132       *{$sub} = $code;
133     }
134 }
135
136 1;
137
138 __END__
139
140 =head1 NAME
141
142 Fatal - replace functions with equivalents which succeed or die
143
144 =head1 SYNOPSIS
145
146     use Fatal qw(open close);
147
148     sub juggle { . . . }
149     import Fatal 'juggle';
150
151 =head1 DESCRIPTION
152
153 C<Fatal> provides a way to conveniently replace functions which normally
154 return a false value when they fail with equivalents which raise exceptions
155 if they are not successful.  This lets you use these functions without
156 having to test their return values explicitly on each call.  Exceptions
157 can be caught using C<eval{}>.  See L<perlfunc> and L<perlvar> for details.
158
159 The do-or-die equivalents are set up simply by calling Fatal's
160 C<import> routine, passing it the names of the functions to be
161 replaced.  You may wrap both user-defined functions and overridable
162 CORE operators (except C<exec>, C<system> which cannot be expressed
163 via prototypes) in this way.
164
165 If the symbol C<:void> appears in the import list, then functions
166 named later in that import list raise an exception only when
167 these are called in void context--that is, when their return
168 values are ignored.  For example
169
170         use Fatal qw/:void open close/;
171
172         # properly checked, so no exception raised on error
173         if(open(FH, "< /bogotic") {
174                 warn "bogo file, dude: $!";
175         }
176
177         # not checked, so error raises an exception
178         close FH;
179
180 =head1 AUTHOR
181
182 Lionel.Cons@cern.ch
183
184 prototype updates by Ilya Zakharevich ilya@math.ohio-state.edu
185
186 =cut