mention portability caveat about C<use Errno 'EFOO'>

[perl5.git] / ext / Errno / Errno_pm.PL

diff --git a/ext/Errno/Errno_pm.PL b/ext/Errno/Errno_pm.PL
index 1cb55e1..e81afb2 100644 (file)
--- a/ext/Errno/Errno_pm.PL
+++ b/ext/Errno/Errno_pm.PL
@@ -1,11 +1,10 @@
-#!perl
 use ExtUtils::MakeMaker;
 use Config;
 use strict;
 
 use vars qw($VERSION);
 
-$VERSION = "1.09";
+$VERSION = "1.111";
 
 my %err = ();
 
@@ -22,7 +21,7 @@ unlink "errno.c" if -f "errno.c";
 sub process_file {
     my($file) = @_;
 
-    return unless defined $file;
+    return unless defined $file and -f $file;
 
     local *FH;
     if (($^O eq 'VMS') && ($Config{vms_cc_type} ne 'gnuc')) {
@@ -32,7 +31,9 @@ sub process_file {
        }     
     } else {
        unless(open(FH,"< $file")) {
-            warn "Cannot open '$file'";
+           # This file could be a temporary file created by cppstdin
+           # so only warn under -w, and return
+            warn "Cannot open '$file'" if $^W;
             return;
        }
     }
@@ -43,6 +44,24 @@ sub process_file {
    close(FH);
 }
 
+my $cppstdin;
+
+sub default_cpp {
+    unless (defined $cppstdin) {
+       use File::Spec;
+       $cppstdin = $Config{cppstdin};
+       my $upup_cppstdin = File::Spec->catfile(File::Spec->updir,
+                                               File::Spec->updir,
+                                               "cppstdin");
+       my $cppstdin_is_wrapper =
+           ($cppstdin eq 'cppstdin'
+               and -f $upup_cppstdin
+                   and -x $upup_cppstdin);
+       $cppstdin = $upup_cppstdin if $cppstdin_is_wrapper;
+    }
+    return "$cppstdin $Config{cppflags} $Config{cppminus}";
+}
+
 sub get_files {
     my %file = ();
     # VMS keeps its include files in system libraries (well, except for Gcc)
@@ -54,6 +73,12 @@ sub get_files {
        } elsif ($Config{vms_cc_type} eq 'gcc') {
            $file{'gnu_cc_include:[000000]errno.h'} = 1;
        }
+    } elsif ($^O eq 'os390') {
+       # OS/390 C compiler doesn't generate #file or #line directives
+       $file{'/usr/include/errno.h'} = 1;
+    } elsif ($^O eq 'vmesa') {
+       # OS/390 C compiler doesn't generate #file or #line directives
+       $file{'../../vmesa/errno.h'} = 1;
     } else {
        open(CPPI,"> errno.c") or
            die "Cannot open errno.c";
@@ -63,9 +88,14 @@ sub get_files {
        close(CPPI);
 
        # invoke CPP and read the output
-
-       open(CPPO,"$Config{cpprun} $Config{cppflags} errno.c |") or
-           die "Cannot exec $Config{cpprun}";
+       if ($^O eq 'MSWin32') {
+           open(CPPO,"$Config{cpprun} $Config{cppflags} errno.c |") or
+               die "Cannot run '$Config{cpprun} $Config{cppflags} errno.c'";
+       } else {
+           my $cpp = default_cpp();
+           open(CPPO,"$cpp < errno.c |") or
+               die "Cannot exec $cpp";
+       }
 
        my $pat;
        if ($^O eq 'MSWin32' and $Config{cc} =~ /^bcc/i) {
@@ -75,7 +105,16 @@ sub get_files {
            $pat = '^#(?:line)?\s*\d+\s+"([^"]+)"';
        }
        while(<CPPO>) {
-           $file{$1} = 1 if /$pat/o;
+           if ($^O eq 'os2' or $^O eq 'MSWin32') {
+               if (/$pat/o) {
+                  my $f = $1;
+                  $f =~ s,\\\\,/,g;
+                  $file{$f} = 1;
+               }
+           }
+           else {
+               $file{$1} = 1 if /$pat/o;
+           }
        }
        close(CPPO);
     }
@@ -85,6 +124,10 @@ sub get_files {
 sub write_errno_pm {
     my $err;
 
+    # quick sanity check
+
+    die "No error definitions found" unless keys %err;
+
     # create the CPP input
 
     open(CPPI,"> errno.c") or
@@ -105,14 +148,13 @@ sub write_errno_pm {
        $cpp =~ s/sys\$input//i;
        open(CPPO,"$cpp  errno.c |") or
           die "Cannot exec $Config{cppstdin}";
-    } elsif($^O eq 'next') {
-       # NeXT will do syntax checking unless it is reading from stdin
-       my $cpp = "$Config{cppstdin} $Config{cppflags} $Config{cppminus}";
+    } elsif ($^O eq 'MSWin32') {
+       open(CPPO,"$Config{cpprun} $Config{cppflags} errno.c |") or
+           die "Cannot run '$Config{cpprun} $Config{cppflags} errno.c'";
+    } else {
+       my $cpp = default_cpp();
        open(CPPO,"$cpp < errno.c |")
            or die "Cannot exec $cpp";
-    } else {
-       open(CPPO,"$Config{cpprun} $Config{cppflags} errno.c |") or
-           die "Cannot exec $Config{cpprun}";
     }
 
     %err = ();
@@ -138,8 +180,9 @@ use Exporter ();
 use Config;
 use strict;
 
-\$Config{'myarchname'} eq "$Config{'myarchname'}" or
-       die "Errno architecture ($Config{'myarchname'}) does not match executable architecture (\$Config{'myarchname'})";
+"\$Config{'archname'}-\$Config{'osvers'}" eq
+"$Config{'archname'}-$Config{'osvers'}" or
+       die "Errno architecture ($Config{'archname'}-$Config{'osvers'}) does not match executable architecture (\$Config{'archname'}-\$Config{'osvers'})";
 
 \$VERSION = "$VERSION";
 \@ISA = qw(Exporter);
@@ -188,13 +231,14 @@ sub TIEHASH { bless [] }
 sub FETCH {
     my ($self, $errname) = @_;
     my $proto = prototype("Errno::$errname");
+    my $errno = "";
     if (defined($proto) && $proto eq "") {
        no strict 'refs';
-        return $! == &$errname;
+       $errno = &$errname;
+        $errno = 0 unless $! == $errno;
     }
-    require Carp;
-    Carp::confess("No errno $errname");
-} 
+    return $errno;
+}
 
 sub STORE {
     require Carp;
@@ -209,13 +253,12 @@ sub NEXTKEY {
     while(($k,$v) = each %Errno::) {
        my $proto = prototype("Errno::$k");
        last if (defined($proto) && $proto eq "");
-       
     }
     $k
 }
 
 sub FIRSTKEY {
-    my $s = scalar keys %Errno::;
+    my $s = scalar keys %Errno::;      # initialize iterator
     goto &NEXTKEY;
 }
 
@@ -244,8 +287,8 @@ C<Errno> defines and conditionally exports all the error constants
 defined in your system C<errno.h> include file. It has a single export
 tag, C<:POSIX>, which will export all POSIX defined error numbers.
 
-C<Errno> also makes C<%!> magic such that each element of C<%!> has a non-zero
-value only if C<$!> is set to that value, eg
+C<Errno> also makes C<%!> magic such that each element of C<%!> has a
+non-zero value only if C<$!> is set to that value. For example:
 
     use Errno;
     
@@ -257,6 +300,20 @@ value only if C<$!> is set to that value, eg
         } 
     } 
 
+If a specified constant C<EFOO> does not exist on the system, C<$!{EFOO}>
+returns C<"">.  You may use C<exists $!{EFOO}> to check whether the
+constant is available on the system.
+
+=head1 CAVEATS
+
+Importing a particular constant may not be very portable, because the
+import will fail on platforms that do not have that constant.  A more
+portable way to set C<$!> to a valid value is to use:
+
+    if (exists &Errno::EFOO) {
+        $! = &Errno::EFOO;
+    }
+
 =head1 AUTHOR
 
 Graham Barr <gbarr@pobox.com>