This patch describes the changes made in ActivePerl build 816 over the official Perl v5.8.8 sources from CPAN. The ActivePerl Release Notes contain an informal summary of these changes. These can be viewed at: http://aspn.ActiveState.com/ASPN/docs/ActivePerl/5.8/CHANGES-58.html The included patch may be applied to Perl v5.8.8 sources using the GNU patch utility. e.g: % cd perl-5.8.8 % patch -lNp1 < this_file --------------------------------------------------------------------------- diff -ruN perl-5.8.8/activeperl.c AP816_source/activeperl.c --- perl-5.8.8/activeperl.c 1969-12-31 16:00:00.000000000 -0800 +++ AP816_source/activeperl.c 2006-03-09 21:52:22.000000000 -0800 @@ -0,0 +1,67 @@ +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" + +static +XS(ActivePerl_PRODUCT) +{ + dXSARGS; + if (items != 0) + Perl_croak(aTHX_ "Usage: ActivePerl::PRODUCT()"); + XSRETURN_PV(ACTIVEPERL_PRODUCT); +} + +static +XS(ActivePerl_BUILD) +{ + dXSARGS; + if (items != 0) + Perl_croak(aTHX_ "Usage: ActivePerl::BUILD()"); + XSRETURN_PV(PRODUCT_BUILD_NUMBER); +} + +#ifdef CONFIG_HEAVY +static +XS(ActivePerl_CONFIG_HEAVY) +{ + dXSARGS; + if (items != 0) + Perl_croak(aTHX_ "Usage: ActivePerl::_CONFIG_HEAVY()"); + XSRETURN_PV(STRINGIFY(CONFIG_HEAVY)); +} +#endif + +void +Perl_boot_core_ActivePerl(pTHX) +{ + char *file = __FILE__; + SV *version_sv = get_sv("ActivePerl::VERSION", TRUE); +#if ACTIVEPERL_SUBVERSION > 0 + Perl_sv_setpvf(aTHX_ version_sv, "%d.%02d", ACTIVEPERL_VERSION, ACTIVEPERL_SUBVERSION); +#else + sv_setiv(version_sv, ACTIVEPERL_VERSION); +#endif + newXS("ActivePerl::PRODUCT", ActivePerl_PRODUCT, file); + newXS("ActivePerl::BUILD", ActivePerl_BUILD, file); +#ifdef CONFIG_HEAVY + newXS("ActivePerl::_CONFIG_HEAVY", ActivePerl_CONFIG_HEAVY, file); +#endif +} + + +/* compatibility wrappers */ + +/* XXX Perl_new_vstring */ +/* XXX Perl_pad_allocmy */ + +EXTERN_C runops_proc_t* Perl_Grunops_dbg_ptr(pTHX) { return &PL_runops_dbg; } +EXTERN_C runops_proc_t* Perl_Grunops_std_ptr(pTHX) { return &PL_runops_std; } +EXTERN_C thrhook_proc_t* Perl_Gthreadhook_ptr(pTHX) { return &PL_threadhook; } +EXTERN_C share_proc_t* Perl_Gsharehook_ptr(pTHX) { return &PL_sharehook; } +EXTERN_C share_proc_t* Perl_Glockhook_ptr(pTHX) { return &PL_lockhook; } +EXTERN_C share_proc_t* Perl_Gunlockhook_ptr(pTHX) { return &PL_unlockhook; } + +EXTERN_C AV** Perl_Icomppad_ptr(pTHX) { return &PL_comppad; } +EXTERN_C const char** Perl_Ish_path_ptr(pTHX) { return &PL_sh_path; } +/* XXX Is this really the right thing to do? */ +EXTERN_C bool* Perl_Iwantutf8_ptr(pTHX) { return &PL_utf8locale; } diff -ruN perl-5.8.8/BuildInfo.h AP816_source/BuildInfo.h --- perl-5.8.8/BuildInfo.h 1969-12-31 16:00:00.000000000 -0800 +++ AP816_source/BuildInfo.h 2006-03-09 21:52:21.000000000 -0800 @@ -0,0 +1,38 @@ +/* BuildInfo.h + * + * Copyright (C) 1998-2006 ActiveState Corp. All rights reserved. + * + */ + +#ifndef ___BuildInfo__h___ +#define ___BuildInfo__h___ + +#define ACTIVEPERL_PRODUCT "ActivePerl" +#define ACTIVEPERL_VERSION 816 +#define ACTIVEPERL_SUBVERSION 0 +#define ACTIVEPERL_CHANGELIST "" + +#define PERL_VENDORLIB_NAME "ActiveState" + +#ifndef STRINGIFY +# include "config.h" +#endif + +/* Derived values and legacy */ +#if ACTIVEPERL_SUBVERSION > 0 +# define PRODUCT_BUILD_NUMBER STRINGIFY(ACTIVEPERL_VERSION) "." STRINGIFY(ACTIVEPERL_SUBVERSION) +#else +# define PRODUCT_BUILD_NUMBER STRINGIFY(ACTIVEPERL_VERSION) +#endif +#define PERLFILEVERSION "5,8,8," STRINGIFY(ACTIVEPERL_VERSION) "\0" +#define PERLRC_VERSION 5,8,8,ACTIVEPERL_VERSION +#define PERLPRODUCTVERSION "Build " PRODUCT_BUILD_NUMBER ACTIVEPERL_CHANGELIST "\0" +#define PERLPRODUCTNAME ACTIVEPERL_PRODUCT "\0" +#define ACTIVEPERL_LOCAL_PATCHES_ENTRY ACTIVEPERL_PRODUCT " Build " PRODUCT_BUILD_NUMBER ACTIVEPERL_CHANGELIST +#ifdef BUILT_BY_ACTIVESTATE +#define BINARY_BUILD_NOTICE PerlIO_printf(PerlIO_stdout(), "\n\ +Binary build " PRODUCT_BUILD_NUMBER ACTIVEPERL_CHANGELIST " provided by ActiveState http://www.ActiveState.com\n\ +Built " __DATE__ " " __TIME__ "\n"); +#endif + +#endif /* ___BuildInfo__h___ */ diff -ruN perl-5.8.8/cflags.SH AP816_source/cflags.SH --- perl-5.8.8/cflags.SH 2005-05-26 08:59:31.000000000 -0700 +++ AP816_source/cflags.SH 2006-03-09 21:52:22.000000000 -0800 @@ -86,6 +86,9 @@ ODBM_File) ;; POSIX) ;; SDBM_File) ;; + activeperl) + ccflags="$ccflags -DCONFIG_HEAVY=$config_heavy" + ;; av) ;; byterun) ;; deb) ;; diff -ruN perl-5.8.8/Changes AP816_source/Changes --- perl-5.8.8/Changes 2006-01-31 07:50:45.000000000 -0800 +++ AP816_source/Changes 2006-03-09 21:52:21.000000000 -0800 @@ -24,6 +24,165 @@ to the perl5-porters mailing list. You can retrieve the messages for example from http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/ +-------------------- +ActivePerl build 816 Additional core patches in ActivePerl build 816 +-------------------- +____________________________________________________________________________ +[ 27359] By: rgs on 2006/03/01 22:39:24 + Log: Don't put strings with embedded NULs in the environment. + This makes things like -d:Foo=bar work again. + Branch: perl + ! perl.c +____________________________________________________________________________ +[ 27210] By: gisle on 2006/02/17 20:54:46 + Log: Fix quote typo. + + Subject: [PATCH] 5.8.8: Debian patches + From: "Brendan O'Dea" + Date: Sat, 11 Feb 2006 00:37:15 +1100 + Message-ID: <20060210133715.GA6826@londo.c47.org> + Branch: perl + ! utils/c2ph.PL +____________________________________________________________________________ +[ 27203] By: rgs on 2006/02/16 14:15:53 + Log: Subject: Problem compiling swigged c++ code with 5.8.8 + From: Merijn Broeren + Date: Wed, 15 Feb 2006 13:51:49 +0100 + Message-ID: <20060215125148.GA12535@brugman.iloquent.nl> + Branch: perl + ! XSUB.h perl.h +____________________________________________________________________________ +[ 27200] By: rgs on 2006/02/16 11:46:51 + Log: Subject: [PATCH] stat() on Windows doesn't handle trailing slashes/backslashes correctly + From: "Jan Dubois" + Date: Wed, 15 Feb 2006 17:19:29 -0800 + Message-ID: <017901c63297$08e1e3f0$2217a8c0@candy> + Branch: perl + ! win32/win32.c +____________________________________________________________________________ +[ 27194] By: gisle on 2006/02/15 15:25:36 + Log: Get perl_fini() running on HP-UX again. + It was effectively disabled by change 24667 since + __ux_version is only available under DCE threads + which isn't used when perl is built on HP-UX 11 + and later. + Branch: perl + ! perl.c +____________________________________________________________________________ +[ 27133] By: nicholas on 2006/02/08 20:57:24 + Log: lastparen in the regexp structure is never initialised, and so will + still be uninitialised after a failed match, yet various points in + mg.c read it come what may. Should fix bug 38461. + Branch: perl + ! regcomp.c +____________________________________________________________________________ +[ 27034] By: rgs on 2006/02/01 15:51:35 + Log: Avoid "Prototype mismatch" warnings with autouse. + Branch: perl + ! lib/autouse.pm +____________________________________________________________________________ +[ 26970] By: gisle on 2006/01/27 19:48:28 + Log: Subject: Re: Make Passive mode the default for Net::FTP + From: Gisle Aas + Date: 27 Jan 2006 07:21:16 -0800 + Message-ID: + Branch: perl + ! lib/Net/Config.pm lib/Net/FTP.pm +____________________________________________________________________________ +[ 26921] By: gisle on 2006/01/23 09:57:10 + Log: Subject: Avoid most getprotobyname/number calls in IO::Socket::INET + From: Gisle Aas + Date: 18 Jan 2006 09:28:24 -0800 + Message-ID: + Branch: perl + ! ext/IO/lib/IO/Socket/INET.pm +____________________________________________________________________________ +[ 26903] By: gisle on 2006/01/18 14:43:14 + Log: Allow IPPROTO_ICMP and IPPROTO_UDP to be exported. + These were introduced in change 26897. + Branch: perl + ! ext/Socket/Socket.pm +____________________________________________________________________________ +[ 26902] By: gisle on 2006/01/18 14:41:17 + Log: Use the IPPROTO_TCP constant instead of 6. + Branch: perl + ! ext/Socket/t/Socket.t +____________________________________________________________________________ +[ 26897] By: gisle on 2006/01/18 11:57:07 + Log: Make sure the most common IPPROTO_* constants are always available. + These are well known numbers so it should not be a problem to + hardcode values when no constant is provided by the C library. + Ref . + + On some old glibc systems (eg Redhat 6) IPPROTO_TCP is an enum only + and this change workaround that problem as well. + Branch: perl + ! ext/Socket/Makefile.PL +____________________________________________________________________________ +[ 26893] By: gisle on 2006/01/18 10:12:14 + Log: Suppress "statement not reached" warning from the Sun C compiler. + Branch: perl + ! doio.c +____________________________________________________________________________ +[ 26673] By: gisle on 2006/01/06 14:00:14 + Log: Remove code duplicated a few lines above by change 19695. + Branch: perl + ! toke.c +____________________________________________________________________________ +[ 26670] By: gisle on 2006/01/06 10:54:18 + Log: Make '-s' on the shebang line able to parse -foo=bar switches again. + This feature was broken by change 19695 some years ago + and integrated into perl-5.8.1. perl-5.8.0 was fine. + Ref http://bugs.activestate.com/show_bug.cgi?id=43483 + Branch: perl + ! perl.c t/run/switches.t +____________________________________________________________________________ +[ 26379] By: rgs on 2005/12/16 21:13:37 + Log: Subject: [PATCH] RE: PeekMessage() call in win32\win32.c win32_async_check + From: Jan Dubois + Date: Dec 16, 2005 7:12 AM + Message-ID: <015901c60207$abd64210$d563a8c0@candy> + + (Without the proposed alarm.t test) + Branch: perl + ! t/op/fork.t win32/perlhost.h win32/win32.c win32/win32.h +____________________________________________________________________________ +[ 26087] By: stevep on 2005/11/11 16:17:03 + Log: Subject: [PATCH] Storable 0.1 compatibility + From: Gisle Aas + Date: 11 Nov 2005 05:42:29 -0800 + Message-ID: + Branch: perl + ! MANIFEST ext/Storable/MANIFEST ext/Storable/Storable.xs + + ext/Storable/t/compat01.t#1 add +____________________________________________________________________________ +[ 25861] By: stevep on 2005/10/27 11:13:50 + Log: Subject: Re: IO::File performace issue + From: gisle@ActiveState.com (Gisle Aas) + Date: 27 Oct 2005 01:00:39 -0700 + Message-ID: + + Also includes a version bump for IO::File. + Branch: perl + ! ext/IO/lib/IO/File.pm +____________________________________________________________________________ +[ 25084] By: davem on 2005/07/05 18:17:34 + Log: a long /etc/groups entry could cause memory exhaustion. + Too small a buffer would cause ERANGE and a retry with double the + buffer size. later at EOF, the apparent error got 'stuck' as + ERANGE rather than ENOENT, so the buffer size doubled recursively + Branch: perl + ! reentr.h reentr.pl +____________________________________________________________________________ +[ 24699] By: rgs on 2005/06/03 21:07:03 + Log: Subject: Re: [PATCH] Improved ICMP_UNREACHABLE handling in Net::Ping + From: Gisle Aas + Date: 03 Jun 2005 09:17:44 -0700 + Message-ID: + Branch: perl + ! lib/Net/Ping.pm +____________________________________________________________________________ + -------------- Version v5.8.8 Maintenance release working toward v5.8.8 -------------- diff -ruN perl-5.8.8/config_h.SH AP816_source/config_h.SH --- perl-5.8.8/config_h.SH 2005-10-31 10:13:05.000000000 -0800 +++ AP816_source/config_h.SH 2006-03-09 21:52:22.000000000 -0800 @@ -2319,7 +2319,9 @@ * This symbol, if defined, indicates that sitecustomize should * be used. */ +#ifndef USE_SITECUSTOMIZE #$usesitecustomize USE_SITECUSTOMIZE /**/ +#endif /* HAS_SOCKET: * This symbol, if defined, indicates that the BSD socket interface is @@ -3499,6 +3501,14 @@ #define SITELIB_EXP "$sitelibexp" /**/ #define SITELIB_STEM "$sitelib_stem" /**/ +/* USE_SITECUSTOMIZE: + * This symbol, if defined, indicates that sitecustomize should + * be used. + */ +#ifndef USE_SITECUSTOMIZE +#$usesitecustomize USE_SITECUSTOMIZE /**/ +#endif + /* Size_t_size: * This symbol holds the size of a Size_t in bytes. */ diff -ruN perl-5.8.8/configpm AP816_source/configpm --- perl-5.8.8/configpm 2005-09-14 01:34:34.000000000 -0700 +++ AP816_source/configpm 2006-03-09 21:52:22.000000000 -0800 @@ -7,9 +7,9 @@ # commonly used names to precache (and hence lookup fastest) my %Common; -while ($how_many_common--) { - $_ = ; - chomp; +while () { + next if /^\s*#/; + last unless $how_many_common--; /^(\S+):\s*(\d+)$/ or die "Malformed line '$_'"; $Common{$1} = $1; } @@ -80,6 +80,14 @@ use strict; # use warnings; Pulls in Carp # use vars pulls in Carp +BEGIN { + unless ($ENV{ACTIVEPERL_CONFIG_DISABLE}) { + eval { + require ActivePerl::Config; + }; + die $@ if $@ && $@ !~ /^Can't locate ActivePerl\/Config\.pm/; + } +} ENDOFBEG my $myver = sprintf "v%vd", $^V; @@ -201,6 +209,16 @@ # Search for it in the big string sub fetch_string { my($self, $key) = @_; + # Let ActivePerl::Config override if it wants + my $value; + $value = _fetch_string(@_) + unless defined(&ActivePerl::Config::override) && + ActivePerl::Config::override($key, $value); + return $self->{$key} = $value; # cache it +} + +sub _fetch_string { + my($self, $key) = @_; EOT @@ -259,7 +277,7 @@ $fetch_string .= <<'EOT'; # So we can say "if $Config{'foo'}". $value = undef if $value eq 'undef'; - $self->{$key} = $value; # cache it + return $value; } EOT @@ -525,16 +543,26 @@ # Sanity check needed to stop an infite loop if Config_heavy.pl fails to define # &launcher for some reason (eg it got truncated) -print CONFIG sprintf <<'ENDOFTIE', $fast_config; +$Config_heavy =~ s,.*[/\\],,; # basename +print CONFIG sprintf <<'ENDOFTIE', $Config_heavy, $Config_heavy, $fast_config; sub DESTROY { } sub AUTOLOAD { - require 'Config_heavy.pl'; + my $config_heavy = '%s'; + if (defined &ActivePerl::_CONFIG_HEAVY) { + $config_heavy = ActivePerl::_CONFIG_HEAVY(); + } + require $config_heavy; goto \&launcher unless $Config::AUTOLOAD =~ /launcher$/; die "&Config::AUTOLOAD failed on $Config::AUTOLOAD"; } +sub __unused { + # XXX Keep PerlApp happy + require '%s'; +} + # tie returns the object, so the value returned to require will be true. tie %%Config, 'Config', { %s}; @@ -803,7 +831,7 @@ sitelibexp: 4305 privlibexp: 4163 ldlibpthname: 4041 -libpth: 2134 +#libpth: 2134 archname: 1591 exe_ext: 1256 scriptdir: 1155 @@ -816,15 +844,15 @@ intsize: 759 usevendorprefix: 642 dlsrc: 624 -cc: 541 +#cc: 541 lib_ext: 520 so: 512 -ld: 501 -ccdlflags: 500 -ldflags: 495 +#ld: 501 +#ccdlflags: 500 +#ldflags: 495 obj_ext: 495 -cccdlflags: 493 -lddlflags: 493 +#cccdlflags: 493 +#lddlflags: 493 ar: 492 dlext: 492 libc: 492 @@ -859,11 +887,11 @@ siteprefixexp: 336 installbin: 335 usedl: 332 -ccflags: 285 +#ccflags: 285 startperl: 232 optimize: 231 usemymalloc: 229 -cpprun: 228 +#cpprun: 228 sharpbang: 228 perllibs: 225 usesfio: 224 @@ -872,7 +900,7 @@ extensions: 217 usesocks: 208 shellflags: 198 -make: 191 +#make: 191 d_pwage: 189 d_pwchange: 189 d_pwclass: 189 @@ -881,10 +909,10 @@ d_pwgecos: 189 d_pwpasswd: 189 d_pwquota: 189 -gccversion: 189 +#gccversion: 189 libs: 186 useshrplib: 186 -cppflags: 185 +#cppflags: 185 ptrsize: 185 shrpenv: 185 static_ext: 185 @@ -892,6 +920,6 @@ uselargefiles: 185 alignbytes: 184 byteorder: 184 -ccversion: 184 +#ccversion: 184 config_args: 184 -cppminus: 184 +#cppminus: 184 diff -ruN perl-5.8.8/Configure AP816_source/Configure --- perl-5.8.8/Configure 2006-01-08 06:51:03.000000000 -0800 +++ AP816_source/Configure 2006-03-09 21:52:22.000000000 -0800 @@ -195,6 +195,7 @@ to='' usecrosscompile='' mistrustnm='' +config_heavy='' perllibs='' dynamic_ext='' extensions='' @@ -3512,6 +3513,11 @@ esac EOSC +: default Config_heavy.pl +case "$config_heavy" in +'') config_heavy=Config_heavy.pl;; +esac + : function used to set $1 to $val setvar='var=$1; eval "was=\$$1"; td=$define; tu=$undef; case "$val$was" in @@ -7969,7 +7975,7 @@ $spackage has manual pages available in source form. EOM -case "$nroff" in +case "DISABLED $nroff" in # heuristic disabled for ActivePerl (always want manpages) nroff) echo "However, you don't have nroff, so they're probably useless to you." case "$man1dir" in @@ -8078,7 +8084,7 @@ $spackage has manual pages for many of the library modules. EOM -case "$nroff" in +case "DISABLED $nroff" in # heuristic disabled for ActivePerl (always want manpages) nroff) $cat <<'EOM' However, you don't have nroff, so they're probably useless to you. @@ -19198,12 +19204,12 @@ if [ "X$ranlib" = "X" ]; then ranlib=":" fi -elif $ar ts bar$_a >/dev/null 2>&1 && +elif $ar s bar$_a >/dev/null 2>&1 && $cc -o foobar $ccflags $ldflags foo$_o bar$_a $libs > /dev/null 2>&1 && $run ./foobar >/dev/null 2>&1; then - echo "a table of contents needs to be added with '$ar ts'." + echo "a table of contents needs to be added with '$ar s'." orderlib=false - ranlib="$ar ts" + ranlib="$ar s" else case "$ranlib" in :) ranlib='';; @@ -21017,6 +21023,7 @@ clocktype='$clocktype' comm='$comm' compress='$compress' +config_heavy='$config_heavy' contains='$contains' cp='$cp' cpio='$cpio' @@ -21756,7 +21763,7 @@ passcat='$passcat' patchlevel='$patchlevel' path_sep='$path_sep' -perl5='$perl5' +perl5='$installprefix/bin/perl' perl='$perl' perl_patchlevel='$perl_patchlevel' perladmin='$perladmin' diff -ruN perl-5.8.8/doio.c AP816_source/doio.c --- perl-5.8.8/doio.c 2006-01-11 08:55:50.000000000 -0800 +++ AP816_source/doio.c 2006-03-09 21:52:22.000000000 -0800 @@ -1989,9 +1989,10 @@ Safefree(gary); return rc; } -#endif +#else return FALSE; #endif +#endif } #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) diff -ruN perl-5.8.8/embed.fnc AP816_source/embed.fnc --- perl-5.8.8/embed.fnc 2006-01-31 06:40:27.000000000 -0800 +++ AP816_source/embed.fnc 2006-03-09 21:52:22.000000000 -0800 @@ -125,6 +125,7 @@ ApR |I32 |block_gimme pR |int |block_start |int full p |void |boot_core_UNIVERSAL +p |void |boot_core_ActivePerl p |void |boot_core_PerlIO Ap |void |call_list |I32 oldscope|NN AV* av_list pR |bool |cando |Mode_t mode|Uid_t effective|NN Stat_t* statbufp diff -ruN perl-5.8.8/embed.h AP816_source/embed.h --- perl-5.8.8/embed.h 2006-01-31 07:50:34.000000000 -0800 +++ AP816_source/embed.h 2006-03-09 21:52:22.000000000 -0800 @@ -86,6 +86,7 @@ #ifdef PERL_CORE #define block_start Perl_block_start #define boot_core_UNIVERSAL Perl_boot_core_UNIVERSAL +#define boot_core_ActivePerl Perl_boot_core_ActivePerl #define boot_core_PerlIO Perl_boot_core_PerlIO #endif #define call_list Perl_call_list @@ -2160,6 +2161,7 @@ #ifdef PERL_CORE #define block_start(a) Perl_block_start(aTHX_ a) #define boot_core_UNIVERSAL() Perl_boot_core_UNIVERSAL(aTHX) +#define boot_core_ActivePerl() Perl_boot_core_ActivePerl(aTHX) #define boot_core_PerlIO() Perl_boot_core_PerlIO(aTHX) #endif #define call_list(a,b) Perl_call_list(aTHX_ a,b) diff -ruN perl-5.8.8/ext/B/t/stash.t AP816_source/ext/B/t/stash.t --- perl-5.8.8/ext/B/t/stash.t 2005-04-08 11:25:25.000000000 -0700 +++ AP816_source/ext/B/t/stash.t 2006-03-09 21:52:22.000000000 -0800 @@ -58,6 +58,7 @@ print "# (after perlio censorings)\n"; print "# got = @got\n"; +@got = grep { ! /^ActivePerl$/ } @got if defined &ActivePerl::BUILD; @got = grep { ! /^Win32$/ } @got if $^O eq 'MSWin32'; @got = grep { ! /^NetWare$/ } @got if $^O eq 'NetWare'; @got = grep { ! /^(Cwd|File|File::Copy|OS2)$/ } @got if $^O eq 'os2'; diff -ruN perl-5.8.8/ext/IO/lib/IO/File.pm AP816_source/ext/IO/lib/IO/File.pm --- perl-5.8.8/ext/IO/lib/IO/File.pm 2005-09-06 02:11:32.000000000 -0700 +++ AP816_source/ext/IO/lib/IO/File.pm 2006-03-09 21:52:24.000000000 -0800 @@ -137,7 +137,7 @@ @ISA = qw(IO::Handle IO::Seekable Exporter); -$VERSION = "1.13"; +$VERSION = "1.13_01"; @EXPORT = @IO::Seekable::EXPORT; @@ -181,13 +181,9 @@ } elsif ($mode =~ /:/) { return open($fh, $mode, $file) if @_ == 3; croak 'usage: $fh->open(FILENAME, IOLAYERS)'; - } - if (defined($file) && length($file) - && ! File::Spec->file_name_is_absolute($file)) - { - $file = File::Spec->rel2abs($file); - } - $file = IO::Handle::_open_mode_string($mode) . " $file\0"; + } else { + return open($fh, IO::Handle::_open_mode_string($mode), $file); + } } open($fh, $file); } diff -ruN perl-5.8.8/ext/IO/lib/IO/Socket/INET.pm AP816_source/ext/IO/lib/IO/Socket/INET.pm --- perl-5.8.8/ext/IO/lib/IO/Socket/INET.pm 2005-09-06 02:11:32.000000000 -0700 +++ AP816_source/ext/IO/lib/IO/Socket/INET.pm 2006-03-09 21:52:24.000000000 -0800 @@ -25,6 +25,11 @@ udp => SOCK_DGRAM, icmp => SOCK_RAW ); +my %proto_number; +$proto_number{tcp} = Socket::IPPROTO_TCP() if defined &Socket::IPPROTO_TCP; +$proto_number{upd} = Socket::IPPROTO_UDP() if defined &Socket::IPPROTO_UDP; +$proto_number{icmp} = Socket::IPPROTO_ICMP() if defined &Socket::IPPROTO_ICMP; +my %proto_name = reverse %proto_number; sub new { my $class = shift; @@ -32,30 +37,60 @@ return $class->SUPER::new(@_); } +sub _cache_proto { + my @proto = @_; + for (map lc($_), $proto[0], split(' ', $proto[1])) { + $proto_number{$_} = $proto[2]; + } + $proto_name{$proto[2]} = $proto[0]; +} + +sub _get_proto_number { + my $name = lc(shift); + return undef unless defined $name; + return $proto_number{$name} if exists $proto_number{$name}; + + my @proto = getprotobyname($name); + return undef unless @proto; + _cache_proto(@proto); + + return $proto[2]; +} + +sub _get_proto_name { + my $num = shift; + return undef unless defined $num; + return $proto_name{$num} if exists $proto_name{$num}; + + my @proto = getprotobynumber($num); + return undef unless @proto; + _cache_proto(@proto); + + return $proto[0]; +} + sub _sock_info { my($addr,$port,$proto) = @_; my $origport = $port; - my @proto = (); my @serv = (); $port = $1 if(defined $addr && $addr =~ s,:([\w\(\)/]+)$,,); if(defined $proto && $proto =~ /\D/) { - if(@proto = getprotobyname($proto)) { - $proto = $proto[2] || undef; - } - else { + my $num = _get_proto_number($proto); + unless (defined $num) { $@ = "Bad protocol '$proto'"; return; } + $proto = $num; } if(defined $port) { my $defport = ($port =~ s,\((\d+)\)$,,) ? $1 : undef; my $pnum = ($port =~ m,^(\d+)$,)[0]; - @serv = getservbyname($port, $proto[0] || "") + @serv = getservbyname($port, _get_proto_name($proto) || "") if ($port =~ m,\D,); $port = $serv[2] || $defport || $pnum; @@ -64,8 +99,7 @@ return; } - $proto = (getprotobyname($serv[3]))[2] || undef - if @serv && !$proto; + $proto = _get_proto_number($serv[3]) if @serv && !$proto; } return ($addr || undef, @@ -129,10 +163,9 @@ or return _error($sock, $!, $@); } - $proto ||= (getprotobyname('tcp'))[2]; + $proto ||= _get_proto_number('tcp'); - my $pname = (getprotobynumber($proto))[0]; - $type = $arg->{Type} || $socket_type{lc $pname}; + $type = $arg->{Type} || $socket_type{lc _get_proto_name($proto)}; my @raddr = (); diff -ruN perl-5.8.8/ext/Socket/Makefile.PL AP816_source/ext/Socket/Makefile.PL --- perl-5.8.8/ext/Socket/Makefile.PL 2002-03-19 14:12:09.000000000 -0800 +++ AP816_source/ext/Socket/Makefile.PL 2006-03-09 21:52:24.000000000 -0800 @@ -15,7 +15,7 @@ AF_LAST AF_LAT AF_LINK AF_MAX AF_NBS AF_NIT AF_NS AF_OSI AF_OSINET AF_PUP AF_ROUTE AF_SNA AF_UNIX AF_UNSPEC AF_USER AF_WAN AF_X25 - IOV_MAX IPPROTO_TCP + IOV_MAX MSG_BCAST MSG_BTAG MSG_CTLFLAGS MSG_CTLIGNORE MSG_DONTWAIT MSG_EOF MSG_EOR MSG_ERRQUEUE MSG_ETAG MSG_FIN MSG_MAXIOVLEN MSG_MCAST MSG_NOSIGNAL MSG_RST MSG_SYN @@ -45,6 +45,9 @@ TCP_KEEPALIVE TCP_MAXRT TCP_MAXSEG TCP_NODELAY TCP_STDURG UIO_MAXIOV ), + {name=>"IPPROTO_ICMP", type=>"IV", default=>["IV", 1]}, + {name=>"IPPROTO_TCP", type=>"IV", default=>["IV", 6]}, + {name=>"IPPROTO_UDP", type=>"IV", default=>["IV", 17]}, {name=>"SHUT_RD", type=>"IV", default=>["IV", "0"]}, {name=>"SHUT_WR", type=>"IV", default=>["IV", "1"]}, {name=>"SHUT_RDWR", type=>"IV", default=>["IV", "2"]}, diff -ruN perl-5.8.8/ext/Socket/Socket.pm AP816_source/ext/Socket/Socket.pm --- perl-5.8.8/ext/Socket/Socket.pm 2006-01-12 10:52:17.000000000 -0800 +++ AP816_source/ext/Socket/Socket.pm 2006-03-09 21:52:24.000000000 -0800 @@ -337,7 +337,10 @@ @EXPORT_OK = qw(CR LF CRLF $CR $LF $CRLF + IPPROTO_ICMP IPPROTO_TCP + IPPROTO_UDP + TCP_KEEPALIVE TCP_MAXRT TCP_MAXSEG diff -ruN perl-5.8.8/ext/Socket/t/Socket.t AP816_source/ext/Socket/t/Socket.t --- perl-5.8.8/ext/Socket/t/Socket.t 2003-10-15 00:52:51.000000000 -0700 +++ AP816_source/ext/Socket/t/Socket.t 2006-03-09 21:52:24.000000000 -0800 @@ -12,7 +12,7 @@ $has_alarm = $Config{d_alarm}; } -use Socket; +use Socket qw(:all); print "1..17\n"; @@ -22,7 +22,7 @@ sub alarmed { $alarmed = 1 } $SIG{ALRM} = 'alarmed' if $has_alarm; -if (socket(T,PF_INET,SOCK_STREAM,6)) { +if (socket(T, PF_INET, SOCK_STREAM, IPPROTO_TCP)) { print "ok 1\n"; arm(5); @@ -70,7 +70,7 @@ print "not ok 1\n"; } -if( socket(S,PF_INET,SOCK_STREAM,6) ){ +if( socket(S, PF_INET,SOCK_STREAM, IPPROTO_TCP) ){ print "ok 4\n"; arm(5); diff -ruN perl-5.8.8/ext/Storable/MANIFEST AP816_source/ext/Storable/MANIFEST --- perl-5.8.8/ext/Storable/MANIFEST 2005-05-20 07:46:24.000000000 -0700 +++ AP816_source/ext/Storable/MANIFEST 2006-03-09 21:52:24.000000000 -0800 @@ -15,6 +15,7 @@ t/canonical.t See if Storable works t/circular_hook.t Test thaw hook called depth-first for circular refs t/code.t Test (de)serialization of code references +t/compat01.t See if Storable is compatible with v0.1 and v0.4 dumps t/compat06.t See if Storable works t/croak.t See if Storable works t/dclone.t See if Storable works diff -ruN perl-5.8.8/ext/Storable/Storable.xs AP816_source/ext/Storable/Storable.xs --- perl-5.8.8/ext/Storable/Storable.xs 2005-09-19 03:41:33.000000000 -0700 +++ AP816_source/ext/Storable/Storable.xs 2006-03-09 21:52:24.000000000 -0800 @@ -4767,6 +4767,11 @@ sv = NEWSV(10002, len); SEEN(sv, cname, 0); /* Associate this new scalar with tag "tagnum" */ + if (len == 0) { + sv_setpvn(sv, "", 0); + return sv; + } + /* * WARNING: duplicates parts of sv_setpv and breaks SV data encapsulation. * @@ -5641,6 +5646,7 @@ int length; int use_network_order; int use_NV_size; + int old_magic = 0; int version_major; int version_minor = 0; @@ -5674,6 +5680,7 @@ if (memNE(buf, old_magicstr, old_len)) CROAK(("File is not a perl storable")); + old_magic++; current = buf + old_len; } use_network_order = *current; @@ -5685,9 +5692,14 @@ * indicate the version number of the binary, and therefore governs the * setting of sv_retrieve_vtbl. See magic_write(). */ - - version_major = use_network_order >> 1; - cxt->retrieve_vtbl = (SV*(**)(pTHX_ stcxt_t *cxt, char *cname)) (version_major ? sv_retrieve : sv_old_retrieve); + if (old_magic && use_network_order > 1) { + /* 0.1 dump - use_network_order is really byte order length */ + version_major = -1; + } + else { + version_major = use_network_order >> 1; + } + cxt->retrieve_vtbl = (SV*(**)(pTHX_ stcxt_t *cxt, char *cname)) (version_major > 0 ? sv_retrieve : sv_old_retrieve); TRACEME(("magic_check: netorder = 0x%x", use_network_order)); @@ -5750,7 +5762,12 @@ /* In C truth is 1, falsehood is 0. Very convienient. */ use_NV_size = version_major >= 2 && version_minor >= 2; - GETMARK(c); + if (version_major >= 0) { + GETMARK(c); + } + else { + c = use_network_order; + } length = c + 3 + use_NV_size; READ(buf, length); /* Not null-terminated */ diff -ruN perl-5.8.8/ext/Storable/t/compat01.t AP816_source/ext/Storable/t/compat01.t --- perl-5.8.8/ext/Storable/t/compat01.t 1969-12-31 16:00:00.000000000 -0800 +++ AP816_source/ext/Storable/t/compat01.t 2006-03-09 21:52:24.000000000 -0800 @@ -0,0 +1,56 @@ +#!perl -w + +BEGIN { + if ($ENV{PERL_CORE}){ + chdir('t') if -d 't'; + @INC = ('.', '../lib', '../ext/Storable/t'); + } else { + unshift @INC, 't'; + } + require Config; import Config; + if ($ENV{PERL_CORE} and $Config{'extensions'} !~ /\bStorable\b/) { + print "1..0 # Skip: Storable was not built\n"; + exit 0; + } + + use Config; + if ($Config{byteorder} ne "1234") { + print "1..0 # Skip: Test only works for 32 bit little-ending machines\n"; + exit 0; + } +} + +use strict; +use Storable qw(retrieve); + +my $file = "xx-$$.pst"; +my @dumps = ( + # some sample dumps of the hash { one => 1 } + "perl-store\x041234\4\4\4\x94y\22\b\3\1\0\0\0vxz\22\b\1\1\0\0\x001Xk\3\0\0\0oneX", # 0.1 + "perl-store\0\x041234\4\4\4\x94y\22\b\3\1\0\0\0vxz\22\b\b\x81Xk\3\0\0\0oneX", # 0.4@7 +); + +print "1.." . @dumps . "\n"; + +my $testno; +for my $dump (@dumps) { + $testno++; + + open(FH, ">$file") || die "Can't create $file: $!"; + binmode(FH); + print FH $dump; + close(FH) || die "Can't write $file: $!"; + + eval { + my $data = retrieve($file); + if (ref($data) eq "HASH" && $data->{one} eq "1") { + print "ok $testno\n"; + } + else { + print "not ok $testno\n"; + } + }; + warn $@ if $@; + + unlink($file); +} diff -ruN perl-5.8.8/ext/Storable/t/malice.t AP816_source/ext/Storable/t/malice.t --- perl-5.8.8/ext/Storable/t/malice.t 2004-07-10 14:47:51.000000000 -0700 +++ AP816_source/ext/Storable/t/malice.t 2006-03-09 21:52:24.000000000 -0800 @@ -51,7 +51,7 @@ # present in files, but not in things store()ed to memory $fancy = ($] > 5.007 ? 2 : 0); -plan tests => 368 + length ($byteorder) * 4 + $fancy * 8 + 1; +plan tests => 372 + length ($byteorder) * 4 + $fancy * 8; use Storable qw (store retrieve freeze thaw nstore nfreeze); require 'testlib.pl'; @@ -306,3 +306,9 @@ # us, which will probably alert the user that something went wrong. ok(1); } + +# Unusual in that the empty string is stored with a SX_LSCALAR marker +my $hash = store_and_retrieve("pst0\5\6\3\0\0\0\1\1\0\0\0\0\0\0\0\5empty"); +ok(!$@, "no exception"); +is(ref($hash), "HASH", "got a hash"); +is($hash->{empty}, "", "got empty element"); diff -ruN perl-5.8.8/ext/util/make_ext AP816_source/ext/util/make_ext --- perl-5.8.8/ext/util/make_ext 2002-05-02 16:32:21.000000000 -0700 +++ AP816_source/ext/util/make_ext 2006-03-09 21:52:24.000000000 -0800 @@ -92,7 +92,12 @@ dynamic) makeargs="LINKTYPE=dynamic"; target=all ;; -static) makeargs="LINKTYPE=static CCCDLFLAGS=" +static) case "$mname" in + # For Apache, DynaLoader needs the CCCDLFLAGS variable + # (+z/+Z/-fpic/-fPIC) to stick around + *DynaLoader*) makeargs="LINKTYPE=static" ;; + *) makeargs="LINKTYPE=static CCCDLFLAGS=" ;; + esac target=all ;; static_pic) makeargs="LINKTYPE=static" diff -ruN perl-5.8.8/globvar.sym AP816_source/globvar.sym --- perl-5.8.8/globvar.sym 2005-12-14 08:05:51.000000000 -0800 +++ AP816_source/globvar.sym 2006-03-09 21:52:24.000000000 -0800 @@ -9,7 +9,6 @@ fold fold_locale freq -memory_wrap no_aelem no_dir_func no_func diff -ruN perl-5.8.8/gv.c AP816_source/gv.c --- perl-5.8.8/gv.c 2006-01-08 12:55:41.000000000 -0800 +++ AP816_source/gv.c 2006-03-09 21:52:24.000000000 -0800 @@ -34,8 +34,8 @@ #define PERL_IN_GV_C #include "perl.h" -const char S_autoload[] = "AUTOLOAD"; -const STRLEN S_autolen = sizeof(S_autoload)-1; +STATIC const char S_autoload[] = "AUTOLOAD"; +STATIC const STRLEN S_autolen = sizeof(S_autoload)-1; #ifdef PERL_DONT_CREATE_GVSV diff -ruN perl-5.8.8/hints/aix.sh AP816_source/hints/aix.sh --- perl-5.8.8/hints/aix.sh 2005-07-26 06:46:55.000000000 -0700 +++ AP816_source/hints/aix.sh 2006-03-09 21:52:24.000000000 -0800 @@ -152,6 +152,28 @@ # the required -bE:$installarchlib/CORE/perl.exp is added by # libperl.U (Configure) later. +case "$cc" in +*gcc*) ;; +cc*|xlc*) # cc should've been set by line 116 or so if empty. + if test ! -x /usr/bin/$cc -a -x /usr/vac/bin/$cc; then + case ":$PATH:" in + *:/usr/vac/bin:*) ;; + *) cat <&1`" in + *"3.3 20030304"*) + d_attribute_format='undef' + d_attribute_malloc='undef' + d_attribute_nonnull='undef' + d_attribute_noreturn='undef' + d_attribute_pure='undef' + d_attribute_unused='undef' + d_attribute_warn_unused_result='undef' + ;; +esac # This was previously used in all but causes three cases # (no -Ddprefix=, -Dprefix=/usr, -Dprefix=/some/thing/else) # but that caused too much grief. diff -ruN perl-5.8.8/hints/hpux.sh AP816_source/hints/hpux.sh --- perl-5.8.8/hints/hpux.sh 2006-01-10 07:07:47.000000000 -0800 +++ AP816_source/hints/hpux.sh 2006-03-09 21:52:24.000000000 -0800 @@ -7,6 +7,8 @@ xxOsRevMajor=`uname -r | sed -e 's/^[^0-9]*//' | cut -d. -f1`; xxOsRevMinor=`uname -r | sed -e 's/^[^0-9]*//' | cut -d. -f2`; xxOsRev=`expr 100 \* $xxOsRevMajor + $xxOsRevMinor` +if [ "X$archname" = "X" ]; then + if [ "$xxOsRevMajor" -ge 10 ]; then # This system is running >= 10.x @@ -33,6 +35,7 @@ sed -e 's/HP-//' -e 1q`; selecttype='int *' fi +fi # For some strange reason, the u32align test from Configure hangs in # HP-UX 10.20 since the December 2001 patches. So hint it to avoid @@ -179,7 +182,11 @@ esac # When HP-UX runs a script with "#!", it sets argv[0] to the script name. +case "$toke_cflags" in +'') toke_cflags='ccflags="$ccflags -DARG_ZERO_IS_SCRIPT"' + ;; +esac ### 64 BITNESS @@ -286,7 +293,11 @@ ;; *) ccflags="$ccflags +DD64" - ldflags="$ldflags +DD64" + case "$archname" in + PA-RISC*) + ldflags="$ldflags +DD64" + ;; + esac ;; esac @@ -294,7 +305,7 @@ # are the right type # (NOTE: on IA64, this doesn't work with .a files.) libscheck='case "`/usr/bin/file $xxx`" in - *ELF-64*|*LP64*|*PA-RISC2.0*) ;; + *ELF-64*|*LP64*|*PA-RISC2.0*|*pa20_64*) ;; *) xxx=/no/64-bit$xxx ;; esac' @@ -307,7 +318,10 @@ libc='/lib/libc.sl' ;; IA64*) loclibpth="$loclibpth /usr/lib/hpux32" - libc='/usr/lib/hpux32/libc.so' ;; + libc='/usr/lib/hpux32/libc.so' + # no odbm libs + i_dbm=$undef + ;; esac ;; esac @@ -367,14 +381,17 @@ $define|true|[Yy]) case "$optimize" in - "") optimize="-g -O" ;; + "") optimize="-O" ;; *O[3456789]*) optimize=`echo "$optimize" | sed -e 's/O[3-9]/O2/'` ;; esac - #ld="$cc" - ld=/usr/bin/ld + ld="$cc" + #ld=/usr/bin/ld cccdlflags='-fPIC' - #lddlflags='-shared' - lddlflags='-b' + lddlflags='-shared -static-libgcc -fPIC' + case "$ccflags" in + *-mlp64*) lddlflags="$lddlflags -mlp64" ;; + esac + #lddlflags='-b' case "$optimize" in *-g*-O*|*-O*-g*) # gcc without gas will not accept -g @@ -434,6 +451,35 @@ ;; esac +# -lc should be at the end, if present (cc wrappers always add it). +# If $ld is the same as $cc, we remove libc from $libswanted, as cc +# will normally add it to the end of the libs list. If that isn't +# the case, we need to move libc to the end of $libswanted. +case "$ld" in +"$cc") + set `echo " $libswanted " | sed -e 's@ c @ @'` + libswanted="$*" + ;; +*) + case " $libswanted " in + *" c "*) + set `echo " $libswanted " | sed -e 's@ c @ @'` + libswanted="$* c " + ;; + esac + ;; +esac + +# Link with libcres.a, a performance library, on PA-RISC when using HP C +case "$archname" in + PA-RISC*) + case "$ccisgcc" in + '') + libswanted="cres $libswanted" + ;; + esac + esac + ## LARGEFILES if [ $xxOsRev -lt 1020 ]; then uselargefiles="$undef" @@ -636,9 +682,17 @@ else # 12 may want upping the _POSIX_C_SOURCE datestamp... ccflags=" -D_POSIX_C_SOURCE=199506L -D_REENTRANT $ccflags" - set `echo X "$libswanted "| sed -e 's/ c / pthread c /'` - shift - libswanted="$*" + case "$libswanted " in + *" pthread "*) ;; + *" c "*) + set `echo X "$libswanted "| sed -e 's/ c / pthread c /'` + shift + libswanted="$*" + ;; + *) + libswanted="$libswanted pthread " + ;; + esac fi ;; @@ -648,7 +702,7 @@ # The mysterious io_xs memory corruption in 11.00 32bit seems to get # fixed by not using Perl's malloc. Flip side is performance loss. # So we want mymalloc for all situations possible -usemymalloc='y' +usemymalloc='n' case "$usethreads" in $define|true|[yY]*) usemymalloc='n' ;; *) case "$ccisgcc" in @@ -668,7 +722,7 @@ usemymalloc='n' case "$useperlio" in - $undef|false|[nN]*) usemymalloc='y' ;; + $undef|false|[nN]*) usemymalloc='n' ;; esac # malloc wrap works diff -ruN perl-5.8.8/hints/solaris_2.sh AP816_source/hints/solaris_2.sh --- perl-5.8.8/hints/solaris_2.sh 2005-10-11 08:41:18.000000000 -0700 +++ AP816_source/hints/solaris_2.sh 2006-03-09 21:52:24.000000000 -0800 @@ -64,6 +64,14 @@ fi ;; esac +case "$archname" in +"i86pc-${osname}") + # x86 looks so much better and is how this platform + # is usually denoted + archname="x86-${osname}" + ;; +esac + # # This extracts the library directories that will be searched by the Sun @@ -359,7 +367,9 @@ # after it has prompted the user for whether to use threads. case "$usethreads" in $define|true|[yY]*) - ccflags="-D_REENTRANT $ccflags" + # -D_POSIX_C_SOURCE=199506L doesn't compile with gcc 2.95.2 :-( + #ccflags="-D_POSIX_C_SOURCE=199506L -D_REENTRANT $ccflags" + ccflags="-D_POSIX_PTHREAD_SEMANTICS -D_REENTRANT $ccflags" # -lpthread overrides some lib C functions, so put it before c. set `echo X "$libswanted "| sed -e "s/ c / pthread c /"` diff -ruN perl-5.8.8/installperl AP816_source/installperl --- perl-5.8.8/installperl 2006-01-28 07:35:28.000000000 -0800 +++ AP816_source/installperl 2006-03-09 21:52:24.000000000 -0800 @@ -842,7 +842,7 @@ if ($dir =~ /^auto/ || ($name =~ /^(.*)\.(?:pm|pod)$/ && $archpms{$1}) || ($name =~ /^(.*)\.(?:h|lib)$/i && ($Is_W32 || $Is_NetWare)) || - $name eq 'Config_heavy.pl' + $name eq $Config{config_heavy} ) { $installlib = $installarchlib; return unless $do_installarchlib; diff -ruN perl-5.8.8/intrpvar.h AP816_source/intrpvar.h --- perl-5.8.8/intrpvar.h 2006-01-01 03:35:36.000000000 -0800 +++ AP816_source/intrpvar.h 2006-03-09 21:52:24.000000000 -0800 @@ -527,11 +527,19 @@ PERLVAR(Isort_RealCmp, SVCOMPARE_t) +#ifndef PERL_DARWIN +/* Iin_load_module moved here because it was already in build 806 */ +PERLVARI(Iin_load_module, int, 0) /* to prevent recursions in PerlIO_find_layer */ +#endif + PERLVARI(Icheckav_save, AV*, Nullav) /* save CHECK{}s when compiling */ PERLVARI(Iclocktick, long, 0) /* this many times() ticks in a second */ +#ifdef PERL_DARWIN +/* for OS X build 813 is the first release, so keep original layout */ PERLVARI(Iin_load_module, int, 0) /* to prevent recursions in PerlIO_find_layer */ +#endif PERLVAR(Iunicode, U32) /* Unicode features: $ENV{PERL_UNICODE} or -C */ diff -ruN perl-5.8.8/lib/ActivePerl.pm AP816_source/lib/ActivePerl.pm --- perl-5.8.8/lib/ActivePerl.pm 1969-12-31 16:00:00.000000000 -0800 +++ AP816_source/lib/ActivePerl.pm 2006-03-09 21:52:24.000000000 -0800 @@ -0,0 +1,121 @@ +package ActivePerl; + +sub perl_version { + return sprintf("%vd.%s", $^V, BUILD()); +} + +1; + +__END__ + +=head1 NAME + +ActivePerl - ActiveState's quality-assured binary build of Perl + +=head1 SYNOPSIS + + use ActivePerl; + print "$ActivePerl::VERSION\n"; + +=head1 DESCRIPTION + +ActivePerl is ActiveState's quality-assured binary build of Perl, +available for AIX, HP-UX, Linux, Mac OS X, Solaris and +Windows. ActivePerl includes: + +=over + +=item * + +The binary core distribution of perl. See L for details. + +=item * + +A set of useful additional CPAN modules "out of +the box". + +=item * + +The Perl Package Manager, for quick and easy install of additional +Perl extension modules. See L for details. + +=item * + +Complete documentation in HTML format. This is found in the F +sub directory where ActivePerl was installed. + +=back + +The release notes for this version of ActivePerl is available in +L. A list of changes beween builds of ActivePerl +is found in L. + +=head2 The ActivePerl:: module + +The C module provide version information about ActivePerl. +The module is built in so most of its variables and functions are +available without having to C the module. The module was +introduced in ActivePerl 813.1. + +The following functions are available: + +=over + +=item ActivePerl->VERSION + +=item ActivePerl->VERSION( $VERSION ) + +This method returns the current version of ActivePerl. It is a number +like C<813.01> or C<815>. With argument croak if the current version +is less than the given number. + +This method is inherited from Perl's C class, and will +usually be invoked indirectly by C, for instance: + + use ActivePerl 815; + +This statement ensures that the scripts runs under ActivePerl 815 or +better. If this perl is not ActivePerl or is older than 815 then this +statement would croak. + +The version number returned is picked up from the $ActivePerl::VERSION +variable. For conditional code it is usually better to test against +this variable directly: + + if (($ActivePerl::VERSION || 0) >= 815) { + ... + } + +The C<|| 0> ensures that this code does not produce a warning if +running on ActivePerl 813 or older, or running on standard perl. + +=item ActivePerl::PRODUCT + +This constant function returns "ActivePerl" for the free version and +"ActivePerlEE" for the Enterprise Edition product. + +=item ActivePerl::BUILD + +The value returned is the same as found in $ActivePerl::VERSION, but +the subversion number will not be padded with 0. It means that this +value is suitable for printing, but unsafe for numeric comparisons. + +This returns the same value as Win32::BuildNumber(), but this function +is only avalable on the Windows builds of ActivePerl. + +=item ActivePerl::perl_version + +Returns a full version number that also include the version of perl +this ActivePerl release is based on. It returns a string like +"5.8.7.815" or "5.8.7.813.1". + +This function is not directly built in and will only be avalable after +'require ActivePerl' has executed. + +=back + +=head1 SEE ALSO + +L, L, L + +=cut diff -ruN perl-5.8.8/lib/autouse.pm AP816_source/lib/autouse.pm --- perl-5.8.8/lib/autouse.pm 2005-09-22 05:57:33.000000000 -0700 +++ AP816_source/lib/autouse.pm 2006-03-09 21:52:25.000000000 -0800 @@ -3,7 +3,7 @@ #use strict; # debugging only use 5.003_90; # ->can, for my $var -$autouse::VERSION = '1.05'; +$autouse::VERSION = '1.06'; $autouse::DEBUG ||= 0; @@ -53,7 +53,7 @@ require $pm; vet_import $module; } - no warnings 'redefine'; + no warnings qw(redefine prototype); *$closure_import_func = \&{"${module}::$closure_func"}; print "autousing $module; " ."imported $closure_func as $closure_import_func\n" diff -ruN perl-5.8.8/lib/CGI/Carp.pm AP816_source/lib/CGI/Carp.pm --- perl-5.8.8/lib/CGI/Carp.pm 2006-01-08 08:39:12.000000000 -0800 +++ AP816_source/lib/CGI/Carp.pm 2006-03-09 21:52:24.000000000 -0800 @@ -368,12 +368,16 @@ # The mod_perl package Apache::Registry loads CGI programs by calling -# eval. These evals don't count when looking at the stack backtrace. +# eval, as does PerlEx. These evals don't count when looking at the +# stack backtrace. sub _longmess { my $message = Carp::longmess(); - $message =~ s,eval[^\n]+(ModPerl|Apache)/(?:Registry|Dispatch)\w*\.pm.*,,s - if exists $ENV{MOD_PERL}; - return $message; + my $mod_perl = exists $ENV{MOD_PERL}; + my $plex = exists($ENV{'GATEWAY_INTERFACE'}) + && $ENV{'GATEWAY_INTERFACE'} =~ /^CGI-PerlEx/; + $message =~ s,eval[^\n]+((ModPerl|Apache)/Registry\w*\.pm|\s*PerlEx::Precompiler).*,,s + if $mod_perl or $plex; + return $message; } sub ineval { @@ -441,13 +445,15 @@ For help, please send mail to $wm, giving this error message and the time and date of the error. END - ; - my $mod_perl = exists $ENV{MOD_PERL}; + ; + my $mod_perl = exists $ENV{MOD_PERL}; + my $plex = exists($ENV{'GATEWAY_INTERFACE'}) + && $ENV{'GATEWAY_INTERFACE'} =~ /^CGI-PerlEx/; if ($CUSTOM_MSG) { if (ref($CUSTOM_MSG) eq 'CODE') { print STDOUT "Content-type: text/html\n\n" - unless $mod_perl; + unless $mod_perl || $plex; &$CUSTOM_MSG($msg); # nicer to perl 5.003 users return; } else { diff -ruN perl-5.8.8/lib/CPAN/Config.pm AP816_source/lib/CPAN/Config.pm --- perl-5.8.8/lib/CPAN/Config.pm 1969-12-31 16:00:00.000000000 -0800 +++ AP816_source/lib/CPAN/Config.pm 2006-03-09 21:52:24.000000000 -0800 @@ -0,0 +1,49 @@ +# This is CPAN.pm's systemwide configuration file provided for +# ActivePerl. This file provides defaults for users, and the values +# can be changed in a per-user configuration file. The user-config +# file is being looked for as ~/.cpan/CPAN/MyConfig.pm. + +my $CPAN_HOME = "$ENV{HOME}/.cpan"; +$CPAN_HOME = do {require Config; "$Config::Config{prefix}/cpan"} + if $^O eq "MSWin32"; + +my $SHELL = $ENV{SHELL}; +$SHELL ||= $ENV{COMSPEC} if $^O eq "MSWin32"; + +my $PAGER = $ENV{PAGER} || "more"; + +$CPAN::Config = { + 'build_cache' => "10", + 'build_dir' => "$CPAN_HOME/build", + 'cache_metadata' => 1, + 'cpan_home' => $CPAN_HOME, + 'ftp' => '', + 'ftp_proxy' => '', + 'getcwd' => '', + 'gpg' => '', + 'gzip' => '', + 'histfile' => "$CPAN_HOME/histfile", + 'histsize' => 100, + 'http_proxy' => '', + 'inactivity_timeout' => 0, + 'index_expire' => 1, + 'inhibit_startup_message' => 0, + 'keep_source_where' => "$CPAN_HOME/sources", + 'lynx' => '', + 'make' => '', + 'make_arg' => '', + 'make_install_arg' => '', + 'makepl_arg' => '', + 'no_proxy' => '', + 'pager' => $PAGER, + 'prerequisites_policy' => 'ask', + 'scan_cache' => 'atstart', + 'shell' => $SHELL, + 'tar' => '', + 'term_is_latin' => 1, + 'unzip' => '', + 'urllist' => ['http://ppm.activestate.com/CPAN', 'http://cpan.perl.org'], + 'wget' => '', +}; + +1; diff -ruN perl-5.8.8/lib/CPAN/FirstTime.pm AP816_source/lib/CPAN/FirstTime.pm --- perl-5.8.8/lib/CPAN/FirstTime.pm 2006-01-30 13:08:57.000000000 -0800 +++ AP816_source/lib/CPAN/FirstTime.pm 2006-03-09 21:52:24.000000000 -0800 @@ -297,6 +297,10 @@ $CPAN::Config->{$progname} = 'not_here'; next; } + if ($^O eq 'MSWin32' && $progname eq 'make') { + $CPAN::Config->{$progname} = ''; + next; + } my $progcall = $progname; # we don't need ncftp if we have ncftpget next if $progname eq "ncftp" && $CPAN::Config->{ncftpget} gt " "; @@ -335,6 +339,7 @@ $path = ""; } $path ||= $ENV{SHELL}; + $path ||= $ENV{COMSPEC} if $^O eq "MSWin32"; if ($^O eq 'MacOS') { $CPAN::Config->{'shell'} = 'not_here'; } else { diff -ruN perl-5.8.8/lib/CPAN.pm AP816_source/lib/CPAN.pm --- perl-5.8.8/lib/CPAN.pm 2006-01-31 06:11:22.000000000 -0800 +++ AP816_source/lib/CPAN.pm 2006-03-09 21:52:24.000000000 -0800 @@ -4561,7 +4561,7 @@ if (my @prereq = $self->unsat_prereq){ return 1 if $self->follow_prereqs(@prereq); # signal success to the queuerunner } - $system = join " ", $CPAN::Config->{'make'}, $CPAN::Config->{make_arg}; + $system = join " ", _make_command(), $CPAN::Config->{make_arg}; if (system($system) == 0) { $CPAN::Frontend->myprint(" $system -- OK\n"); $self->{'make'} = "YES"; @@ -4572,6 +4572,10 @@ } } +sub _make_command { + return $CPAN::Config->{'make'} || $Config::Config{make} || 'make'; +} + sub follow_prereqs { my($self) = shift; my(@prereq) = @_; @@ -4740,7 +4744,7 @@ local $ENV{PERL5LIB} = $ENV{PERL5LIB} || ""; $CPAN::META->set_perl5lib; - my $system = join " ", $CPAN::Config->{'make'}, "test"; + my $system = join " ", _make_command(), "test"; if (system($system) == 0) { $CPAN::Frontend->myprint(" $system -- OK\n"); $CPAN::META->is_tested($self->{'build_dir'}); @@ -4772,7 +4776,7 @@ return; } - my $system = join " ", $CPAN::Config->{'make'}, "clean"; + my $system = join " ", _make_command(), "clean"; if (system($system) == 0) { $CPAN::Frontend->myprint(" $system -- OK\n"); @@ -4847,7 +4851,7 @@ return; } - my $system = join(" ", $CPAN::Config->{'make'}, + my $system = join(" ", _make_command(), "install", $CPAN::Config->{make_install_arg}); my($stderr) = $^O =~ /Win/i ? "" : " 2>&1 "; my($pipe) = FileHandle->new("$system $stderr |"); diff -ruN perl-5.8.8/lib/ExtUtils/Embed.pm AP816_source/lib/ExtUtils/Embed.pm --- perl-5.8.8/lib/ExtUtils/Embed.pm 2004-08-03 03:41:49.000000000 -0700 +++ AP816_source/lib/ExtUtils/Embed.pm 2006-03-09 21:52:25.000000000 -0800 @@ -221,21 +221,27 @@ } #print STDERR "\@potential_libs = @potential_libs\n"; + my $lpath = File::Spec->catdir($Config{archlibexp}, 'CORE'); my $libperl; if ($^O eq 'MSWin32') { $libperl = $Config{libperl}; + $lpath = qq["$lpath"]; } else { $libperl = (grep(/^-l\w*perl\w*$/, @link_args))[0] || ($Config{libperl} =~ /^lib(\w+)(\Q$lib_ext\E|\.\Q$Config{dlext}\E)$/ ? "-l$1" : '') || "-lperl"; + if ($libperl eq "-lperl" && $Config{libperl} eq "libperl.a" && + -f File::Spec->catfile($lpath, "libperl.so")) + { + $libperl = File::Spec->catfile($lpath, $Config{libperl}); + $lpath = undef; + } } - my $lpath = File::Spec->catdir($Config{archlibexp}, 'CORE'); - $lpath = qq["$lpath"] if $^O eq 'MSWin32'; my($extralibs, $bsloadlibs, $ldloadlibs, $ld_run_path) = - MM->ext(join ' ', "-L$lpath", $libperl, @potential_libs); + MM->ext(join ' ', ($lpath ? "-L$lpath" : ()), $libperl, @potential_libs); my $ld_or_bs = $bsloadlibs || $ldloadlibs; print STDERR "bs: $bsloadlibs ** ld: $ldloadlibs" if $Verbose; diff -ruN perl-5.8.8/lib/ExtUtils/Install.pm AP816_source/lib/ExtUtils/Install.pm --- perl-5.8.8/lib/ExtUtils/Install.pm 2005-10-21 05:00:01.000000000 -0700 +++ AP816_source/lib/ExtUtils/Install.pm 2006-03-09 21:52:25.000000000 -0800 @@ -205,7 +205,7 @@ if ($pack{'write'}) { $dir = install_rooted_dir(dirname($pack{'write'})); mkpath($dir,0,0755) unless $nonono; - print "Writing $pack{'write'}\n"; + print "Writing $pack{'write'}\n" if $verbose; $packlist->write(install_rooted_file($pack{'write'})) unless $nonono; } } @@ -279,6 +279,13 @@ my $INST_SCRIPT = File::Spec->catdir($Curdir,'blib','script'); my $INST_MAN1DIR = File::Spec->catdir($Curdir,'blib','man1'); my $INST_MAN3DIR = File::Spec->catdir($Curdir,'blib','man3'); + + my @INST_HTML; + if($Config{installhtmldir}) { + my $INST_HTMLDIR = File::Spec->catdir($Curdir,'blib','html'); + @INST_HTML = ($INST_HTMLDIR => $Config{installhtmldir}); + } + install({ read => "$Config{sitearchexp}/auto/$FULLEXT/.packlist", write => "$Config{installsitearch}/auto/$FULLEXT/.packlist", @@ -290,6 +297,7 @@ $INST_SCRIPT => $Config{installscript}, $INST_MAN1DIR => $Config{installman1dir}, $INST_MAN3DIR => $Config{installman3dir}, + @INST_HTML, },1,0,0); } @@ -370,7 +378,7 @@ } # if not verbose, we just say nothing } else { - print "Unlinking $targetfile (shadowing?)\n"; + print "Unlinking $targetfile (shadowing?)\n" if $verbose; forceunlink($targetfile); } } diff -ruN perl-5.8.8/lib/ExtUtils/Liblist/Kid.pm AP816_source/lib/ExtUtils/Liblist/Kid.pm --- perl-5.8.8/lib/ExtUtils/Liblist/Kid.pm 2005-10-21 04:44:36.000000000 -0700 +++ AP816_source/lib/ExtUtils/Liblist/Kid.pm 2006-03-09 21:52:25.000000000 -0800 @@ -82,6 +82,12 @@ next; } + if ($Config_libext && $thislib =~ /\Q$Config_libext\E$/) { + push @libs, $thislib unless $libs_seen{$thislib}++; + push(@ldloadlibs, $thislib); + next; + } + # Handle possible library arguments. unless ($thislib =~ s/^-l//){ warn "Unrecognized argument in LIBS ignored: '$thislib'\n"; diff -ruN perl-5.8.8/lib/ExtUtils/MakeMaker.pm AP816_source/lib/ExtUtils/MakeMaker.pm --- perl-5.8.8/lib/ExtUtils/MakeMaker.pm 2005-10-21 07:11:04.000000000 -0700 +++ AP816_source/lib/ExtUtils/MakeMaker.pm 2006-03-09 21:52:25.000000000 -0800 @@ -212,16 +212,16 @@ FULLPERL FULLPERLRUN FULLPERLRUNINST FUNCLIST H IMPORTS - INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB INST_MAN1DIR INST_MAN3DIR + INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB INST_MAN1DIR INST_MAN3DIR INST_HTMLDIR INSTALLDIRS DESTDIR PREFIX INSTALLBASE PERLPREFIX SITEPREFIX VENDORPREFIX INSTALLPRIVLIB INSTALLSITELIB INSTALLVENDORLIB INSTALLARCHLIB INSTALLSITEARCH INSTALLVENDORARCH INSTALLBIN INSTALLSITEBIN INSTALLVENDORBIN - INSTALLMAN1DIR INSTALLMAN3DIR - INSTALLSITEMAN1DIR INSTALLSITEMAN3DIR - INSTALLVENDORMAN1DIR INSTALLVENDORMAN3DIR + INSTALLMAN1DIR INSTALLMAN3DIR INSTALLHTMLDIR + INSTALLSITEMAN1DIR INSTALLSITEMAN3DIR INSTALLSITEHTMLDIR + INSTALLVENDORMAN1DIR INSTALLVENDORMAN3DIR INSTALLVENDORHTMLDIR INSTALLSCRIPT PERL_LIB PERL_ARCHLIB SITELIBEXP SITEARCHEXP @@ -268,7 +268,7 @@ special_targets c_o xs_c xs_o top_targets blibdirs linkext dlsyms dynamic dynamic_bs - dynamic_lib static static_lib manifypods processPL + dynamic_lib static static_lib manifypods htmlifypods processPL installbin subdirs clean_subdirs clean realclean_subdirs realclean metafile signature @@ -324,7 +324,7 @@ # @Prepend_parent = qw( INST_BIN INST_LIB INST_ARCHLIB INST_SCRIPT - MAP_TARGET INST_MAN1DIR INST_MAN3DIR PERL_SRC + MAP_TARGET INST_MAN1DIR INST_MAN3DIR INST_HTMLDIR PERL_SRC PERL FULLPERL ); } @@ -1066,8 +1066,8 @@ =head2 make install make alone puts all relevant files into directories that are named by -the macros INST_LIB, INST_ARCHLIB, INST_SCRIPT, INST_MAN1DIR and -INST_MAN3DIR. All these default to something below ./blib if you are +the macros INST_LIB, INST_ARCHLIB, INST_SCRIPT, INST_MAN1DIR, INST_MAN3DIR +INST_HTMLDIR. All these default to something below ./blib if you are I building below the perl source directory. If you I building below the perl source, INST_LIB and INST_ARCHLIB default to ../../lib, and INST_SCRIPT is not defined. @@ -1087,6 +1087,7 @@ INST_SCRIPT INSTALLSCRIPT INSTALLSCRIPT INSTALLSCRIPT INST_MAN1DIR INSTALLMAN1DIR INSTALLSITEMAN1DIR INSTALLVENDORMAN1DIR INST_MAN3DIR INSTALLMAN3DIR INSTALLSITEMAN3DIR INSTALLVENDORMAN3DIR + INST_HTMLDIR INSTALLHTMLDIR INSTALLSITEHTMLDIR INSTALLVENDORHTMLDIR The INSTALL... macros in turn default to their %Config ($Config{installprivlib}, $Config{installarchlib}, etc.) counterparts. @@ -1618,6 +1619,10 @@ Directory to hold the man pages at 'make' time +=item INST_HTMLDIR + +Directory to hold the html documentation at 'make' time + =item INST_SCRIPT Directory, where executable files should be installed during diff -ruN perl-5.8.8/lib/ExtUtils/MM_Any.pm AP816_source/lib/ExtUtils/MM_Any.pm --- perl-5.8.8/lib/ExtUtils/MM_Any.pm 2005-04-13 00:49:53.000000000 -0700 +++ AP816_source/lib/ExtUtils/MM_Any.pm 2006-03-09 21:52:25.000000000 -0800 @@ -342,7 +342,7 @@ my $self = shift; return <<'MAKE_EXT'; -all :: pure_all +all :: pure_all htmlifypods $(NOECHO) $(NOOP) MAKE_EXT @@ -613,6 +613,59 @@ } +=head3 htmlifypods + +Defines targets and routines to translate the pods into html and +put them into the INST_* directories. + +=cut + +sub htmlifypods { + my $self = shift; + + my $POD2HTML_macro = $self->POD2HTML_macro(); + my $htmlifypods_target = $self->htmlifypods_target(); + + return <htmlifypods_target; + +Generates the htmlifypods target. This target generates html pages from +all POD files in MAN1PODS and MAN3PODS. + +=cut + +sub htmlifypods_target { + my($self) = shift; + + my $dependencies = ''; + + # populate dependencies: + foreach my $name (keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}}) { + $dependencies .= " \\\n\t$name"; + } + + my $htmlify = <makemakerdflt_target @@ -983,6 +1036,7 @@ $self->{INST_MAN1DIR} ||= $self->catdir($Curdir,'blib','man1'); $self->{INST_MAN3DIR} ||= $self->catdir($Curdir,'blib','man3'); + $self->{INST_HTMLDIR} ||= $self->catdir($Curdir,'blib','html'); return 1; } @@ -1141,6 +1195,19 @@ d => 'man/man3', style => $manstyle, }, ); + + my %html_layouts = + ( + htmldir => { s => $iprefix, + t =>'perl', + d => 'html', }, + sitehtmldir => { s => $sprefix, + t => 'site', + d => 'html', }, + vendorhtmldir => { s => $vprefix, + t => 'vendor', + d => 'html', }, + ); my %lib_layouts = ( @@ -1192,7 +1259,7 @@ vendor => 'VENDORPREFIX' ); - my %layouts = (%bin_layouts, %man_layouts, %lib_layouts); + my %layouts = (%bin_layouts, %man_layouts, %html_layouts, %lib_layouts); while( my($var, $layout) = each(%layouts) ) { my($s, $t, $d, $style) = @{$layout}{qw(s t d style)}; my $r = '$('.$type2prefix{$t}.')'; @@ -1467,6 +1534,37 @@ } +=head3 POD2HTML_macro + + my $pod2html_macro = $self->POD2HTML_macro + +Returns a definition for the POD2HTML macro. This is a program +which emulates the pod2html utility. You can add more switches to the +command by simply appending them on the macro. + +Typical usage: + + $(POD2HTML) podfile1 html_page1 ... + +=cut + +sub POD2HTML_macro { + my $self = shift; + + my $pod2html_exe; + if (eval "require ActivePerl::DocTools; 1;") { + $pod2html_exe = '$(PERLRUN) "-MActivePerl::DocTools" -e "Pod2HTML(installdirs => "$(INSTALLDIRS)")"'; + } + else { + $pod2html_exe = '$(NOOP)'; + } + return <<"END_OF_DEF"; +POD2HTML_EXE = $pod2html_exe +POD2HTML = \$(POD2HTML_EXE) +END_OF_DEF +} + + =head3 POD2MAN_macro my $pod2man_macro = $self->POD2MAN_macro @@ -1630,6 +1728,7 @@ SCRIPT MAN1DIR SITEMAN1DIR VENDORMAN1DIR MAN3DIR SITEMAN3DIR VENDORMAN3DIR + HTMLDIR SITEHTMLDIR VENDORHTMLDIR ); } diff -ruN perl-5.8.8/lib/ExtUtils/MM_Unix.pm AP816_source/lib/ExtUtils/MM_Unix.pm --- perl-5.8.8/lib/ExtUtils/MM_Unix.pm 2005-05-21 02:42:56.000000000 -0700 +++ AP816_source/lib/ExtUtils/MM_Unix.pm 2006-03-09 21:52:25.000000000 -0800 @@ -372,7 +372,7 @@ VERSION VERSION_MACRO VERSION_SYM DEFINE_VERSION XS_VERSION XS_VERSION_MACRO XS_DEFINE_VERSION INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB - INST_MAN1DIR INST_MAN3DIR + INST_MAN1DIR INST_MAN3DIR INST_HTMLDIR MAN1EXT MAN3EXT INSTALLDIRS INSTALLBASE DESTDIR PREFIX PERLPREFIX SITEPREFIX VENDORPREFIX @@ -1486,6 +1486,14 @@ sub init_main { my($self) = @_; + unless ( $Config{installsitehtmldir} ) { + $Config_Override{installsitehtmldir} = $Config{installhtmldir}; + } + + unless ( $Config{installvendorhtmldir} ) { + $Config_Override{installvendorhtmldir} = $Config{installhtmldir}; + } + # --- Initialize Module Name and Paths # NAME = Foo::Bar::Oracle @@ -2027,9 +2035,15 @@ sub install { my($self, %attribs) = @_; my(@m); - + + my $doc_update = '$(NOOP)'; + if (eval { require ActivePerl::DocTools; 1; }) { + $doc_update = '$(NOECHO) $(PERLRUN) "-MActivePerl::DocTools" -e '. + 'ActivePerl::DocTools::WriteTOC'; + } + push @m, q{ -install :: all pure_install doc_install +install :: all pure_install doc_install doc_update $(NOECHO) $(NOOP) install_perl :: all pure_perl_install doc_perl_install @@ -2047,6 +2061,9 @@ doc_install :: doc_$(INSTALLDIRS)_install $(NOECHO) $(NOOP) +doc_update :: + }.$doc_update.q{ + pure__install : pure_site_install $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site @@ -2062,7 +2079,8 @@ $(INST_BIN) $(DESTINSTALLBIN) \ $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \ $(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \ - $(INST_MAN3DIR) $(DESTINSTALLMAN3DIR) + $(INST_MAN3DIR) $(DESTINSTALLMAN3DIR) \ + $(INST_HTMLDIR) $(DESTINSTALLHTMLDIR) $(NOECHO) $(WARN_IF_OLD_PACKLIST) \ }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{ @@ -2076,7 +2094,8 @@ $(INST_BIN) $(DESTINSTALLSITEBIN) \ $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \ $(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \ - $(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR) + $(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR) \ + $(INST_HTMLDIR) $(DESTINSTALLSITEHTMLDIR) $(NOECHO) $(WARN_IF_OLD_PACKLIST) \ }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{ @@ -2089,7 +2108,8 @@ $(INST_BIN) $(DESTINSTALLVENDORBIN) \ $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \ $(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \ - $(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR) + $(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR) \ + $(INST_HTMLDIR) $(DESTINSTALLVENDORHTMLDIR) doc_perl_install :: $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod @@ -2127,7 +2147,7 @@ }; push @m, q{ -uninstall :: uninstall_from_$(INSTALLDIRS)dirs +uninstall :: uninstall_from_$(INSTALLDIRS)dirs doc_update $(NOECHO) $(NOOP) uninstall_from_perldirs :: @@ -2935,7 +2955,13 @@ } - $ppd_xml .= sprintf <<'PPD_OUT', $Config{archname}; + my $archname = $Config{archname}; + if ($^V ge v5.8) { +# archname did not change from 5.6 to 5.8, but those versions may not be not binary compatible +# so now we append the part of the version that changes when binary compatibility may change + $archname .= "-". substr($Config{version},0,3); + } + $ppd_xml .= sprintf <<'PPD_OUT', $archname; PPD_OUT @@ -3556,7 +3582,7 @@ my $self = shift; return <<'MAKE_EXT'; -all :: pure_all manifypods +all :: pure_all htmlifypods manifypods $(NOECHO) $(NOOP) MAKE_EXT } diff -ruN perl-5.8.8/lib/ExtUtils/t/basic.t AP816_source/lib/ExtUtils/t/basic.t --- perl-5.8.8/lib/ExtUtils/t/basic.t 2005-10-21 05:00:22.000000000 -0700 +++ AP816_source/lib/ExtUtils/t/basic.t 2006-03-09 21:52:25.000000000 -0800 @@ -102,7 +102,13 @@ ' ' ); like( $ppd_html, qr{^\s*}m, ' ' ); -like( $ppd_html, qr{^\s*}m, +my $archname = $Config{archname}; +if ($^V ge v5.8) { +# archname did not change from 5.6 to 5.8, but those versions may not be not binary compatible +# so now we append the part of the version that changes when binary compatibility may change + $archname .= "-". substr($Config{version},0,3); +} +like( $ppd_html, qr{^\s*}m, ' '); like( $ppd_html, qr{^\s*}m, ' '); like( $ppd_html, qr{^\s*}m, ' '); @@ -124,7 +130,7 @@ diag $test_out; -my $install_out = run("$make install"); +my $install_out = run("$make install VERBINST=1"); is( $?, 0, 'install' ) || diag $install_out; like( $install_out, qr/^Installing /m ); like( $install_out, qr/^Writing /m ); @@ -150,7 +156,7 @@ SKIP: { skip 'VMS install targets do not preserve $(PREFIX)', 9 if $Is_VMS; - $install_out = run("$make install PREFIX=elsewhere"); + $install_out = run("$make install VERBINST=1 PREFIX=elsewhere"); is( $?, 0, 'install with PREFIX override' ) || diag $install_out; like( $install_out, qr/^Installing /m ); like( $install_out, qr/^Writing /m ); @@ -170,7 +176,7 @@ SKIP: { skip 'VMS install targets do not preserve $(DESTDIR)', 11 if $Is_VMS; - $install_out = run("$make install PREFIX= DESTDIR=other"); + $install_out = run("$make install VERBINST=1 PREFIX= DESTDIR=other"); is( $?, 0, 'install with DESTDIR' ) || diag $install_out; like( $install_out, qr/^Installing /m ); @@ -211,7 +217,7 @@ SKIP: { skip 'VMS install targets do not preserve $(PREFIX)', 10 if $Is_VMS; - $install_out = run("$make install PREFIX=elsewhere DESTDIR=other/"); + $install_out = run("$make install VERBINST=1 PREFIX=elsewhere DESTDIR=other/"); is( $?, 0, 'install with PREFIX override and DESTDIR' ) || diag $install_out; like( $install_out, qr/^Installing /m ); diff -ruN perl-5.8.8/lib/ExtUtils/t/installbase.t AP816_source/lib/ExtUtils/t/installbase.t --- perl-5.8.8/lib/ExtUtils/t/installbase.t 2005-04-07 01:32:22.000000000 -0700 +++ AP816_source/lib/ExtUtils/t/installbase.t 2006-03-09 21:52:25.000000000 -0800 @@ -51,7 +51,7 @@ my $install_out = run("$make install"); is( $?, 0, ' make install exited normally' ) || diag $install_out; like( $install_out, qr/^Installing /m ); -like( $install_out, qr/^Writing /m ); +like( $install_out, qr/^Appending /m ); ok( -r '../dummy-install', ' install dir created' ); diff -ruN perl-5.8.8/lib/ExtUtils/t/MM_Unix.t AP816_source/lib/ExtUtils/t/MM_Unix.t --- perl-5.8.8/lib/ExtUtils/t/MM_Unix.t 2005-10-21 04:44:56.000000000 -0700 +++ AP816_source/lib/ExtUtils/t/MM_Unix.t 2006-03-09 21:52:25.000000000 -0800 @@ -18,7 +18,7 @@ plan skip_all => 'Non-Unix platform'; } else { - plan tests => 110; + plan tests => 111; } } @@ -98,6 +98,7 @@ makeaperl makefile manifypods + htmlifypods needs_linking pasthru perldepend diff -ruN perl-5.8.8/lib/File/Path.pm AP816_source/lib/File/Path.pm --- perl-5.8.8/lib/File/Path.pm 2006-01-02 14:11:06.000000000 -0800 +++ AP816_source/lib/File/Path.pm 2006-03-09 21:52:25.000000000 -0800 @@ -72,33 +72,17 @@ =item * -a boolean value, which if TRUE will cause C to -skip any files to which you do not have delete access -(if running under VMS) or write access (if running -under another OS). This will change in the future when -a criterion for 'delete permission' under OSs other -than VMS is settled. (defaults to FALSE) +a boolean value, which if FALSE (the default for non-root users) will +cause C to adjust the mode of directories (if required) prior +to attempting to remove the contents. Note that on interruption or +failure of C, directories may be left with more permissive +modes for the owner. =back It returns the number of files successfully deleted. Symlinks are simply deleted and not followed. -B There are race conditions internal to the implementation of -C making it unsafe to use on directory trees which may be -altered or moved while C is running, and in particular on any -directory trees with any path components or subdirectories potentially -writable by untrusted users. - -Additionally, if the third parameter is not TRUE and C is -interrupted, it may leave files and directories with permissions altered -to allow deletion (and older versions of this module would even set -files and directories to world-read/writable!) - -Note also that the occurrence of errors in C can be determined I -by trapping diagnostic messages using C<$SIG{__WARN__}>; it is not apparent -from the return value. - =head1 DIAGNOSTICS =over 4 @@ -124,8 +108,9 @@ use Exporter (); use strict; use warnings; +use Cwd 'getcwd'; -our $VERSION = "1.08"; +our $VERSION = "1.08"; # but modified for ActivePerl our @ISA = qw( Exporter ); our @EXPORT = qw( mkpath rmtree ); @@ -172,111 +157,150 @@ @created; } -sub rmtree { - my($roots, $verbose, $safe) = @_; - my(@files); - my($count) = 0; - $verbose ||= 0; - $safe ||= 0; - - if ( defined($roots) && length($roots) ) { - $roots = [$roots] unless ref $roots; - } - else { - carp "No root path(s) specified\n"; - return 0; - } - - my($root); - foreach $root (@{$roots}) { - if ($Is_MacOS) { - $root = ":$root" if $root !~ /:/; - $root =~ s#([^:])\z#$1:#; - } else { - $root =~ s#/\z##; - } - (undef, undef, my $rp) = lstat $root or next; - $rp &= 07777; # don't forget setuid, setgid, sticky bits - if ( -d _ ) { - # notabene: 0700 is for making readable in the first place, - # it's also intended to change it to writable in case we have - # to recurse in which case we are better than rm -rf for - # subtrees with strange permissions - chmod($rp | 0700, ($Is_VMS ? VMS::Filespec::fileify($root) : $root)) - or carp "Can't make directory $root read+writeable: $!" - unless $safe; - - if (opendir my $d, $root) { - no strict 'refs'; - if (!defined ${"\cTAINT"} or ${"\cTAINT"}) { - # Blindly untaint dir names - @files = map { /^(.*)$/s ; $1 } readdir $d; - } else { - @files = readdir $d; - } - closedir $d; - } - else { - carp "Can't read $root: $!"; - @files = (); - } - - # Deleting large numbers of files from VMS Files-11 filesystems - # is faster if done in reverse ASCIIbetical order - @files = reverse @files if $Is_VMS; - ($root = VMS::Filespec::unixify($root)) =~ s#\.dir\z## if $Is_VMS; - if ($Is_MacOS) { - @files = map("$root$_", @files); - } else { - @files = map("$root/$_", grep $_!~/^\.{1,2}\z/s,@files); - } - $count += rmtree(\@files,$verbose,$safe); - if ($safe && - ($Is_VMS ? !&VMS::Filespec::candelete($root) : !-w $root)) { - print "skipped $root\n" if $verbose; - next; - } - chmod $rp | 0700, $root - or carp "Can't make directory $root writeable: $!" - if $force_writeable; - print "rmdir $root\n" if $verbose; - if (rmdir $root) { - ++$count; - } - else { - carp "Can't remove directory $root: $!"; - chmod($rp, ($Is_VMS ? VMS::Filespec::fileify($root) : $root)) - or carp("and can't restore permissions to " - . sprintf("0%o",$rp) . "\n"); +sub _rmtree +{ + my ($path, $prefix, $up, $up_dev, $up_ino, $verbose, $safe) = @_; + + my ($dev, $ino, $perm) = lstat $path or do { + return 0; + }; + $perm &= 07777; + + unless (-d _) + { + my $nperm; + if ($force_writeable) { + # make the file writable + $nperm = $perm | 0600; + unless ($safe or $nperm == $perm or chmod $nperm, $path) { + carp "Can't make file $prefix$path writeable: $!"; } } - else { - if ($safe && - ($Is_VMS ? !&VMS::Filespec::candelete($root) - : !(-l $root || -w $root))) - { - print "skipped $root\n" if $verbose; - next; - } - chmod $rp | 0600, $root - or carp "Can't make file $root writeable: $!" - if $force_writeable; - print "unlink $root\n" if $verbose; - # delete all versions under VMS - for (;;) { - unless (unlink $root) { - carp "Can't unlink file $root: $!"; - if ($force_writeable) { - chmod $rp, $root - or carp("and can't restore permissions to " - . sprintf("0%o",$rp) . "\n"); - } - last; + print "unlink $prefix$path\n" if $verbose; + unless (unlink $path) + { + carp "Can't remove file $prefix$path ($!)"; + if ($force_writeable) { + unless ($safe or $nperm == $perm or chmod $perm, $path) { + carp("and can't restore permissions to " + . sprintf("0%o",$perm) . "\n"); } - ++$count; - last unless $Is_VMS && lstat $root; } + return 0; } + return 1; + } + + CHDIR: { + last CHDIR if chdir $path; + my $err = $!; + unless ($safe || ($perm & 0100)) { + # might be able to succeed by tweaking the permission + # before we chdir + last CHDIR if chmod(0700, $path) && chdir($path); + } + carp "Can't chdir to $prefix$path ($err)"; + return 0; + } + + # avoid a race condition where a directory may be replaced by a + # symlink between the initial lstat and the chdir + my ($new_dev, $new_ino) = stat '.'; + unless ("$new_dev:$new_ino" eq "$dev:$ino") + { + croak "Directory $prefix$path changed before chdir, aborting"; + } + + my $nperm = $perm | 0700; + unless ($safe or $nperm == $perm or chmod $nperm, '.') + { + carp "Can't make directory $prefix$path read+writeable ($!)"; + $nperm = $perm; + } + + my $count = 0; + if (opendir my $dir, '.') + { + my $entry; + while (defined ($entry = readdir $dir)) + { + next if $entry =~ /^\.\.?$/; + $entry =~ /^(.*)$/s; $entry = $1; # untaint + $count += _rmtree($entry, "$prefix$path/", '..', $dev, $ino, + $verbose, $safe); + } + + closedir $dir; + } + + # restore directory permissions is required (in case the rmdir + # below fails) now, while we're still in the directory and may do + # so without a race via '.' + unless ($force_writeable or $safe or $nperm == $perm or chmod $perm, '.') + { + carp "Can't restore permissions on directory $prefix$path ($!)"; + } + + # don't leave the caller in an unexpected directory + unless (chdir $up) + { + croak "Can't return to $up from $prefix$path ($!)"; + } + + # ensure that a chdir .. didn't take us somewhere other than + # where we expected (see CVE-2002-0435) + unless (($new_dev, $new_ino) = stat '.' + and "$new_dev:$new_ino" eq "$up_dev:$up_ino") + { + croak "Previous directory $up changed since entering $prefix$path"; + } + + print "rmdir $prefix$path\n" if $verbose; + if (rmdir $path) + { + $count++; + } + else + { + carp "Can't remove directory $prefix$path ($!)"; + } + + return $count; +} + +sub rmtree +{ + my ($p, $verbose, $safe) = @_; + $p = [] unless defined $p and length $p; + $p = [ $p ] unless ref $p; + my @paths = grep defined && length, @$p; + + # default to "unsafe" for non-root (will chmod dirs) + $safe = ($> || $force_writeable) ? 0 : 1 unless defined $safe; + + unless (@paths) + { + carp "No root path(s) specified"; + return 0; + } + + my $oldpwd = getcwd or do { + carp "Can't fetch initial working directory"; + return 0; + }; + + my ($dev, $ino) = stat '.' or do { + carp "Can't stat initial working directory"; + return 0; + }; + + # untaint + for ($oldpwd) { /^(.*)$/s; $_ = $1 } + + my $count = 0; + for my $path (@paths) + { + $count += _rmtree($path, '', $oldpwd, $dev, $ino, $verbose, $safe); } $count; diff -ruN perl-5.8.8/lib/File/Path.t AP816_source/lib/File/Path.t --- perl-5.8.8/lib/File/Path.t 2003-08-22 06:31:50.000000000 -0700 +++ AP816_source/lib/File/Path.t 2006-03-09 21:52:25.000000000 -0800 @@ -12,16 +12,16 @@ my $count = 0; use warnings; -print "1..4\n"; +print "1..6\n"; # first check for stupid permissions second for full, so we clean up # behind ourselves -for my $perm (0111,0777) { +for my $perm (0111,0777,0) { my $path = catdir(curdir(), "mhx", "bar"); mkpath($path); chmod $perm, "mhx", $path; - print "not " unless -d "mhx" && -d $path; + print "not " unless -d "mhx" && (!$perm || -d $path); print "ok ", ++$count, "\n"; rmtree("mhx"); diff -ruN perl-5.8.8/lib/Net/Config.pm AP816_source/lib/Net/Config.pm --- perl-5.8.8/lib/Net/Config.pm 2002-02-28 06:04:31.000000000 -0800 +++ AP816_source/lib/Net/Config.pm 2006-03-09 21:52:25.000000000 -0800 @@ -27,8 +27,8 @@ time_hosts => [], inet_domain => undef, ftp_firewall => undef, - ftp_ext_passive => 0, - ftp_int_passive => 0, + ftp_ext_passive => 1, + ftp_int_passive => 1, test_hosts => 1, test_exist => 1, ); @@ -269,11 +269,12 @@ =item ftp_int_pasive -FTP servers normally work on a non-passive mode. That is when you want to -transfer data you have to tell the server the address and port to -connect to. +FTP servers can work in passive or active mode. Active mode is when +you want to transfer data you have to tell the server the address and +port to connect to. Passive mode is when the server provide the +address and port and you establish the connection. -With some firewalls this does not work as the server cannot +With some firewalls active mode does not work as the server cannot connect to your machine (because you are behind a firewall) and the firewall does not re-write the command. In this case you should set C to a I value. diff -ruN perl-5.8.8/lib/Net/FTP.pm AP816_source/lib/Net/FTP.pm --- perl-5.8.8/lib/Net/FTP.pm 2004-06-30 07:06:43.000000000 -0700 +++ AP816_source/lib/Net/FTP.pm 2006-03-09 21:52:25.000000000 -0800 @@ -1332,10 +1332,18 @@ B - debug level (see the debug method in L) -B - If set to a non-zero value then all data transfers will be done -using passive mode. This is not usually required except for some I -servers, and some firewall configurations. This can also be set by the -environment variable C. +B - If set to a non-zero value then all data transfers will +be done using passive mode. If set to zero then data transfers will be +done using active mode. If the machine is connected to the Internet +directly, both passive and active mode should work equally well. +Behind most firewall and NAT configurations passive mode has a better +chance of working. However, in some rare firewall configurations, +active mode actually works when passive mode doesn't. Some really old +FTP servers might not implement passive transfers. If not specified, +then the transfer mode is set by the environment variable +C or if that one is not set by the settings done by the +F utility. If none of these apply then passive mode is +used. B - If given a reference to a file handle (e.g., C<\*STDERR>), print hash marks (#) on that filehandle every 1024 bytes. This diff -ruN perl-5.8.8/lib/Net/Ping/t/110_icmp_inst.t AP816_source/lib/Net/Ping/t/110_icmp_inst.t --- perl-5.8.8/lib/Net/Ping/t/110_icmp_inst.t 2002-10-20 06:22:45.000000000 -0700 +++ AP816_source/lib/Net/Ping/t/110_icmp_inst.t 2006-03-09 21:52:25.000000000 -0800 @@ -15,9 +15,11 @@ # Everything loaded fine ok 1; +require Win32 if $^O eq "MSWin32"; + if (($> and $^O ne 'VMS' and $^O ne 'cygwin') or ($^O eq 'MSWin32' - and Win32::IsWinNT()) + and !Win32::IsAdminUser()) or ($^O eq 'VMS' and (`write sys\$output f\$privilege("SYSPRV")` =~ m/FALSE/))) { skip "icmp ping requires root privileges.", 1; diff -ruN perl-5.8.8/lib/Net/Ping/t/500_ping_icmp.t AP816_source/lib/Net/Ping/t/500_ping_icmp.t --- perl-5.8.8/lib/Net/Ping/t/500_ping_icmp.t 2003-02-08 01:19:27.000000000 -0800 +++ AP816_source/lib/Net/Ping/t/500_ping_icmp.t 2006-03-09 21:52:25.000000000 -0800 @@ -15,9 +15,11 @@ # Everything loaded fine ok 1; +require Win32 if $^O eq "MSWin32"; + if (($> and $^O ne 'VMS' and $^O ne 'cygwin') or ($^O eq 'MSWin32' - and Win32::IsWinNT()) + and !Win32::IsAdminUser()) or ($^O eq 'VMS' and (`write sys\$output f\$privilege("SYSPRV")` =~ m/FALSE/))) { skip "icmp ping requires root privileges.", 1; diff -ruN perl-5.8.8/lib/Net/Ping.pm AP816_source/lib/Net/Ping.pm --- perl-5.8.8/lib/Net/Ping.pm 2003-08-03 12:38:04.000000000 -0700 +++ AP816_source/lib/Net/Ping.pm 2006-03-09 21:52:25.000000000 -0800 @@ -396,6 +396,7 @@ } use constant ICMP_ECHOREPLY => 0; # ICMP packet types +use constant ICMP_UNREACHABLE => 3; use constant ICMP_ECHO => 8; use constant ICMP_STRUCT => "C2 n3 A"; # Structure of a minimal ICMP packet use constant SUBCODE => 0; # No ICMP subcode for ECHO and ECHOREPLY @@ -480,8 +481,11 @@ ($from_seq == $self->{"seq"})) { if ($from_type == ICMP_ECHOREPLY){ $ret = 1; + $done = 1; + } + elsif ($from_type == ICMP_UNREACHABLE) { + $done = 1; } - $done = 1; } } else { # Oops, timed out $done = 1; diff -ruN perl-5.8.8/lib/Pod/Find.pm AP816_source/lib/Pod/Find.pm --- perl-5.8.8/lib/Pod/Find.pm 2005-10-04 11:40:15.000000000 -0700 +++ AP816_source/lib/Pod/Find.pm 2006-03-09 21:52:25.000000000 -0800 @@ -196,7 +196,7 @@ my $name; if(-f $try) { if($name = _check_and_extract_name($try, $opts{-verbose})) { - _check_for_duplicates($try, $name, \%names, \%pods); + _check_for_duplicates($try, $name, \%names, \%pods, $opts{-verbose}); } next; } @@ -225,7 +225,7 @@ return; } if($name = _check_and_extract_name($item, $opts{-verbose}, $root_rx)) { - _check_for_duplicates($item, $name, \%names, \%pods); + _check_for_duplicates($item, $name, \%names, \%pods, $opts{-verbose}); } }, $try); # end of File::Find::find } @@ -234,11 +234,12 @@ } sub _check_for_duplicates { - my ($file, $name, $names_ref, $pods_ref) = @_; - if($$names_ref{$name}) { - warn "Duplicate POD found (shadowing?): $name ($file)\n"; - warn " Already seen in ", - join(' ', grep($$pods_ref{$_} eq $name, keys %$pods_ref)),"\n"; + my ($file, $name, $names_ref, $pods_ref, $verbose) = @_; + if ($$names_ref{$name}) { + warn "Duplicate POD found (shadowing?): $name ($file)\n", + " Already seen in ", + join(' ', grep($$pods_ref{$_} eq $name, keys %$pods_ref)),"\n" + if $verbose; } else { $$names_ref{$name} = 1; diff -ruN perl-5.8.8/lib/Pod/Html.pm AP816_source/lib/Pod/Html.pm --- perl-5.8.8/lib/Pod/Html.pm 2006-01-12 10:08:03.000000000 -0800 +++ AP816_source/lib/Pod/Html.pm 2006-03-09 21:52:25.000000000 -0800 @@ -682,7 +682,7 @@ usage("-") if defined $opt_help; # see if the user asked for help $opt_help = ""; # just to make -w shut-up. - @Podpath = split(":", $opt_podpath) if defined $opt_podpath; + @Podpath = map { s/\|/:/g; $_ } split(":", $opt_podpath) if defined $opt_podpath; @Libpods = split(":", $opt_libpods) if defined $opt_libpods; $Backlink = $opt_backlink if defined $opt_backlink; @@ -1301,6 +1301,34 @@ $line; #eg; + my @line = split /\n/, $rest; + my $comments = !grep !/^\s*(#.*)?$/, @line; + + # Try to colorize the block as Perl sample code + if (($comments || $rest =~ /[;{]/) && + eval {require ActiveState::Scineplex}) + { + my $prefix; + my $input = $rest; # Don't modify $rest in case the colorizer fails + if ($input =~ /^( +)/) { + $prefix = $1; + s/^$prefix// for @line; + $input = join("\n", @line, ""); + } + my $styled = eval { ActiveState::Scineplex::Annotate($input, 'perl', outputFormat => 'html') }; + if ($styled) { + # If this really looks like code, then we don't want + # to add hyperlinks to URLs embedded in strings etc. + if ($prefix) { + $$text = $prefix . join("\n$prefix", split("\n", $styled)) . "\n"; + } + else { + $$text = $styled; + } + return; + } + } + # convert some special chars to HTML escapes $rest = html_escape($rest); diff -ruN perl-5.8.8/makedef.pl AP816_source/makedef.pl --- perl-5.8.8/makedef.pl 2006-01-27 12:12:53.000000000 -0800 +++ AP816_source/makedef.pl 2006-03-09 21:52:26.000000000 -0800 @@ -163,6 +163,19 @@ if ($define{USE_ITHREADS} and $define{PERL_IMPLICIT_SYS}) { output_symbol("perl_clone_host"); } + # export symbols for compatibility wrappers + # XXX Perl_pad_allocmy + # XXX Perl_new_vstring + output_symbol($_) for qw( Perl_Grunops_dbg_ptr + Perl_Grunops_std_ptr + Perl_Gthreadhook_ptr + Perl_Gsharehook_ptr + Perl_Glockhook_ptr + Perl_Gunlockhook_ptr + + Perl_Icomppad_ptr + Perl_Ish_path_ptr + Perl_Iwantutf8_ptr ); } elsif ($PLATFORM eq 'os2') { if (open my $fh, '<', 'perl5.def') { @@ -394,6 +407,9 @@ PL_statusvalue_vms PL_sys_intern )]); + emit_symbols([qw( + boot_DynaLoader + )]); } elsif ($PLATFORM eq 'os2') { emit_symbols([qw( diff -ruN perl-5.8.8/Makefile.SH AP816_source/Makefile.SH --- perl-5.8.8/Makefile.SH 2006-01-24 04:49:44.000000000 -0800 +++ AP816_source/Makefile.SH 2006-03-09 21:52:22.000000000 -0800 @@ -286,6 +286,8 @@ INSTALLPREFIXEXP = $prefix +CONFIG_HEAVY = $config_heavy + !GROK!THIS! # not used by Makefile but by installperl; # mentioned here so that metaconfig picks these up @@ -315,7 +317,7 @@ CCCMDSRC = `sh $(shellflags) cflags "optimize='$(OPTIMIZE)'" $<` -CONFIGPM = lib/Config.pm lib/Config_heavy.pl +CONFIGPM = lib/Config.pm lib/$(CONFIG_HEAVY) private = preplibrary $(CONFIGPM) lib/Config.pod lib/ExtUtils/Miniperl.pm # Files to be built with variable substitution before miniperl @@ -355,14 +357,14 @@ c1 = $(mallocsrc) av.c scope.c op.c doop.c doio.c dump.c hv.c mg.c reentr.c c2 = perl.c perly.c pp.c pp_hot.c pp_ctl.c pp_sys.c regcomp.c regexec.c utf8.c -c3 = gv.c sv.c taint.c toke.c util.c deb.c run.c universal.c xsutils.c pad.c +c3 = gv.c sv.c taint.c toke.c util.c deb.c run.c universal.c xsutils.c activeperl.c pad.c c4 = globals.c perlio.c perlapi.c numeric.c locale.c pp_pack.c pp_sort.c c = $(c1) $(c2) $(c3) $(c4) miniperlmain.c perlmain.c opmini.c obj1 = $(mallocobj) gv$(OBJ_EXT) toke$(OBJ_EXT) perly$(OBJ_EXT) op$(OBJ_EXT) pad$(OBJ_EXT) regcomp$(OBJ_EXT) dump$(OBJ_EXT) util$(OBJ_EXT) mg$(OBJ_EXT) reentr$(OBJ_EXT) obj2 = hv$(OBJ_EXT) av$(OBJ_EXT) run$(OBJ_EXT) pp_hot$(OBJ_EXT) sv$(OBJ_EXT) pp$(OBJ_EXT) scope$(OBJ_EXT) pp_ctl$(OBJ_EXT) pp_sys$(OBJ_EXT) -obj3 = doop$(OBJ_EXT) doio$(OBJ_EXT) regexec$(OBJ_EXT) utf8$(OBJ_EXT) taint$(OBJ_EXT) deb$(OBJ_EXT) universal$(OBJ_EXT) xsutils$(OBJ_EXT) globals$(OBJ_EXT) perlio$(OBJ_EXT) perlapi$(OBJ_EXT) numeric$(OBJ_EXT) locale$(OBJ_EXT) pp_pack$(OBJ_EXT) pp_sort$(OBJ_EXT) +obj3 = doop$(OBJ_EXT) doio$(OBJ_EXT) regexec$(OBJ_EXT) utf8$(OBJ_EXT) taint$(OBJ_EXT) deb$(OBJ_EXT) universal$(OBJ_EXT) xsutils$(OBJ_EXT) activeperl$(OBJ_EXT) globals$(OBJ_EXT) perlio$(OBJ_EXT) perlapi$(OBJ_EXT) numeric$(OBJ_EXT) locale$(OBJ_EXT) pp_pack$(OBJ_EXT) pp_sort$(OBJ_EXT) obj = $(obj1) $(obj2) $(obj3) $(ARCHOBJS) @@ -776,7 +778,7 @@ $(MAKE) lib/re.pm lib/Config.pod: config.sh miniperl$(EXE_EXT) configpm Porting/Glossary - $(LDLIBPTH) ./miniperl -Ilib configpm --heavy=lib/Config_heavy.pl lib/Config.pm + $(LDLIBPTH) ./miniperl -Ilib configpm --heavy=lib/$(CONFIG_HEAVY) lib/Config.pm $(CONFIGPM): lib/Config.pod diff -ruN perl-5.8.8/MANIFEST AP816_source/MANIFEST --- perl-5.8.8/MANIFEST 2006-01-31 15:27:53.000000000 -0800 +++ AP816_source/MANIFEST 2006-03-09 21:56:26.000000000 -0800 @@ -1,3 +1,4 @@ +activeperl.c apollo/netinet/in.h Apollo DomainOS port: C header file frontend Artistic The "Artistic License" AUTHORS Contact info for contributors @@ -7,6 +8,7 @@ beos/beos.c BeOS port beos/beosish.h BeOS port beos/nm.c BeOS port +BuildInfo.h ActivePerl build number bytecode.pl Produces ext/ByteLoader/byterun.h, ext/ByteLoader/byterun.c and ext/B/Asmdata.pm cc_runtime.h Macros need by runtime of compiler-generated code cflags.SH A script that emits C compilation flags per file @@ -819,6 +821,7 @@ ext/Storable/t/canonical.t See if Storable works ext/Storable/t/circular_hook.t Test thaw hook called depth-first for circular refs ext/Storable/t/code.t See if Storable works +ext/Storable/t/compat01.t See if Storable works ext/Storable/t/compat06.t See if Storable works ext/Storable/t/croak.t See if Storable works ext/Storable/t/dclone.t See if Storable works @@ -1143,6 +1146,7 @@ keywords.h The keyword numbers keywords.pl Program to write keywords.h lib/abbrev.pl An abbreviation table builder +lib/ActivePerl.pm lib/AnyDBM_File.pm Perl module to emulate dbmopen lib/AnyDBM_File.t See if AnyDBM_File works lib/assert.pl assertion and panic with stack trace @@ -1267,6 +1271,7 @@ lib/constant.pm For "use constant" lib/constant.t See if compile-time constants work lib/CPAN/bin/cpan easily interact with CPAN from the command line +lib/CPAN/Config.pm lib/CPAN/FirstTime.pm Utility for creating CPAN config files lib/CPAN/Nox.pm Runs CPAN while avoiding compiled extensions lib/CPAN/PAUSE2003.pub CPAN public key @@ -2807,6 +2812,7 @@ t/op/re_tests Regular expressions for regexp.t t/op/reverse.t See if reverse operator works t/op/runlevel.t See if die() works from perl_call_*() +t/op/sig.t See if signals work t/op/sleep.t See if sleep works t/op/sort.t See if sort works t/op/splice.t See if splice works @@ -3038,10 +3044,12 @@ win32/makefile.mk Win32 makefile for DMAKE (BC++, VC++ builds) win32/makeico.pl script to create perlexe.ico image file win32/mdelete.bat multifile delete +win32/perldll.rc ActivePerl info resource win32/perlexe.rc associated perl binary with icon win32/perlglob.c Win32 port win32/perlhost.h Perl "host" implementation win32/perllib.c Win32 port +win32/perl.ico ActivePerl Gecko win32/pod.mak Win32 port win32/runperl.c Win32 port win32/splittree.pl Win32 port diff -ruN perl-5.8.8/mg.c AP816_source/mg.c --- perl-5.8.8/mg.c 2006-01-27 12:23:21.000000000 -0800 +++ AP816_source/mg.c 2006-03-09 21:52:26.000000000 -0800 @@ -1217,8 +1217,8 @@ return 0; } -static void -S_raise_signal(pTHX_ int sig) +void +Perl_raise_signal(pTHX_ int sig) { /* Set a flag to say this signal is pending */ PL_psig_pend[sig]++; @@ -1251,7 +1251,7 @@ * with risk we may be in malloc() etc. */ (*PL_sighandlerp)(sig); else - S_raise_signal(aTHX_ sig); + Perl_raise_signal(aTHX_ sig); } #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS) diff -ruN perl-5.8.8/patchlevel.h AP816_source/patchlevel.h --- perl-5.8.8/patchlevel.h 2006-01-31 08:12:10.000000000 -0800 +++ AP816_source/patchlevel.h 2006-03-09 21:52:26.000000000 -0800 @@ -10,6 +10,8 @@ #ifndef __PATCHLEVEL_H_INCLUDED__ +#include "BuildInfo.h" + /* do not adjust the whitespace! Configure expects the numbers to be * exactly on the third column */ @@ -120,7 +122,33 @@ #if !defined(PERL_PATCHLEVEL_H_IMPLICIT) && !defined(LOCAL_PATCH_COUNT) static const char *local_patches[] = { - NULL + NULL + ,ACTIVEPERL_LOCAL_PATCHES_ENTRY +# if !defined(PERL_DARWIN) + ,"Iin_load_module moved for compatibility with build 806" +# endif +# if defined(__hpux) + ,"Avoid signal flag SA_RESTART for older versions of HP-UX" +# endif + ,"PerlEx support in CGI::Carp" + ,"Less verbose ExtUtils::Install and Pod::Find" + ,"Patch for CAN-2005-0448 from Debian with modifications" + ,"27359 Fix -d:Foo=bar syntax" + ,"27210 Fix quote typo in c2ph" + ,"27203 Allow compiling swigged C++ code" + ,"27200 Make stat() on Windows handle trailing slashes correctly" + ,"27194 Get perl_fini() running on HP-UX again" + ,"27133 Initialise lastparen in the regexp structure" + ,"27034 Avoid \"Prototype mismatch\" warnings with autouse" + ,"26970 Make Passive mode the default for Net::FTP" + ,"26921 Avoid getprotobyname/number calls in IO::Socket::INET" + ,"26897,26903 Make common IPPROTO_* constants always available" + ,"26670 Make '-s' on the shebang line parse -foo=bar switches" + ,"26379 Fix alarm() for Windows 2003" + ,"26087 Storable 0.1 compatibility" + ,"25861 IO::File performace issue" + ,"25084 long groups entry could cause memory exhaustion" + ,"24699 ICMP_UNREACHABLE handling in Net::Ping" ,NULL }; diff -ruN perl-5.8.8/perl.c AP816_source/perl.c --- perl-5.8.8/perl.c 2006-01-31 04:34:47.000000000 -0800 +++ AP816_source/perl.c 2006-03-09 21:52:26.000000000 -0800 @@ -1403,7 +1403,7 @@ /* provide destructors to clean up the thread key when libperl is unloaded */ #ifndef WIN32 /* handled during DLL_PROCESS_DETACH in win32/perllib.c */ -#if defined(__hpux) && __ux_version > 1020 && !defined(__GNUC__) +#if defined(__hpux) && !(defined(__ux_version) && __ux_version <= 1020) && !defined(__GNUC__) #pragma fini "perl_fini" #endif @@ -2109,6 +2109,7 @@ boot_core_PerlIO(); boot_core_UNIVERSAL(); boot_core_xsutils(); + boot_core_ActivePerl(); if (xsinit) (*xsinit)(aTHX); /* in case linked C routines want magical variables */ @@ -3109,7 +3110,9 @@ sv_catpv(sv, start); else { sv_catpvn(sv, start, s-start); - Perl_sv_catpvf(aTHX_ sv, " split(/,/,q%c%s%c)", 0, ++s, 0); + /* Don't use NUL as q// delimiter here, this string goes in the + * environment. */ + Perl_sv_catpvf(aTHX_ sv, " split(/,/,q{%s});", ++s); } s += strlen(s); my_setenv("PERL5DB", (char *)SvPV_nolen_const(sv)); @@ -4566,8 +4569,9 @@ break; } if ((s = strchr(argv[0], '='))) { - *s++ = '\0'; - sv_setpv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),s); + *s = '\0'; + sv_setpv(GvSV(gv_fetchpv(argv[0] + 1, TRUE, SVt_PV)), s + 1); + *s = '='; } else sv_setiv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),1); diff -ruN perl-5.8.8/perl.h AP816_source/perl.h --- perl-5.8.8/perl.h 2006-01-13 10:17:12.000000000 -0800 +++ AP816_source/perl.h 2006-03-09 21:52:26.000000000 -0800 @@ -159,7 +159,7 @@ #endif #ifndef PERL_UNUSED_DECL -# ifdef HASATTRIBUTE_UNUSED +# if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus) # define PERL_UNUSED_DECL __attribute__unused__ # else # define PERL_UNUSED_DECL @@ -3473,8 +3473,7 @@ INIT("\"my\" variable %s can't be in a package"); EXTCONST char PL_no_localize_ref[] INIT("Can't localize through a reference"); -EXTCONST char PL_memory_wrap[] - INIT("panic: memory wrap"); +#define PL_memory_wrap "panic: memory wrap" EXTCONST char PL_uuemap[65] INIT("`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"); diff -ruN perl-5.8.8/perlio.c AP816_source/perlio.c --- perl-5.8.8/perlio.c 2006-01-06 14:42:20.000000000 -0800 +++ AP816_source/perlio.c 2006-03-09 21:52:26.000000000 -0800 @@ -63,6 +63,13 @@ int mkstemp(char*); #endif +/* mkstemp is defined to be mkstemp64 at some patchlevel on AIX5 and that's not + * binary compatible with older versions of the OS (http://bugs.activestate.com/show_bug.cgi?id=44902) + */ +#if defined(_AIX) +# undef mkstemp +#endif + /* Call the callback or PerlIOBase, and return failure. */ #define Perl_PerlIO_or_Base(f, callback, base, failure, args) \ if (PerlIOValid(f)) { \ diff -ruN perl-5.8.8/perlio.h AP816_source/perlio.h --- perl-5.8.8/perlio.h 2005-05-23 07:59:26.000000000 -0700 +++ AP816_source/perlio.h 2006-03-09 21:52:26.000000000 -0800 @@ -114,11 +114,11 @@ #define PERLIO_FUNCS_CAST(funcs) (funcs) #endif -PERL_EXPORT_C void PerlIO_define_layer(pTHX_ PerlIO_funcs *tab); +PERL_EXPORT_C void PerlIO_define_layer(pTHX_ PerlIO_funcs *); PERL_EXPORT_C PerlIO_funcs *PerlIO_find_layer(pTHX_ const char *name, STRLEN len, int load); -PERL_EXPORT_C PerlIO *PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab), +PERL_EXPORT_C PerlIO *PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*), const char *mode, SV *arg); PERL_EXPORT_C void PerlIO_pop(pTHX_ PerlIO *f); PERL_EXPORT_C AV* PerlIO_get_layers(pTHX_ PerlIO *f); diff -ruN perl-5.8.8/pod/perlapi.pod AP816_source/pod/perlapi.pod --- perl-5.8.8/pod/perlapi.pod 2006-01-07 05:30:59.000000000 -0800 +++ AP816_source/pod/perlapi.pod 2006-03-09 21:52:26.000000000 -0800 @@ -1169,7 +1169,8 @@ =item HvNAME X -Returns the package name of a stash. See C, C. +Returns the package name of a stash, or NULL if C isn't a stash. +See C, C. char* HvNAME(HV* stash) diff -ruN perl-5.8.8/pod/perl.pod AP816_source/pod/perl.pod --- perl-5.8.8/pod/perl.pod 2006-01-07 05:24:56.000000000 -0800 +++ AP816_source/pod/perl.pod 2006-03-09 21:52:26.000000000 -0800 @@ -28,6 +28,8 @@ perlintro Perl introduction for beginners perltoc Perl documentation table of contents + ActivePerl ActivePerl overview + =head2 Tutorials perlreftut Perl references short introduction @@ -155,6 +157,9 @@ perl5005delta Perl changes in version 5.005 perl5004delta Perl changes in version 5.004 + activeperl-release Release notes for ActivePerl + activeperl-changes ActivePerl revision history + perlartistic Perl Artistic License perlgpl GNU General Public License diff -ruN perl-5.8.8/Porting/curliff.pl AP816_source/Porting/curliff.pl --- perl-5.8.8/Porting/curliff.pl 2003-07-28 11:01:56.000000000 -0700 +++ AP816_source/Porting/curliff.pl 2006-03-09 21:52:22.000000000 -0800 @@ -17,6 +17,7 @@ README.win32 win32/Makefile win32/makefile.mk + wince/Makefile.ce wince/compile-all.bat wince/README.perlce wince/registry.bat diff -ruN perl-5.8.8/proto.h AP816_source/proto.h --- perl-5.8.8/proto.h 2006-01-31 07:50:34.000000000 -0800 +++ AP816_source/proto.h 2006-03-09 21:52:27.000000000 -0800 @@ -123,6 +123,7 @@ __attribute__warn_unused_result__; PERL_CALLCONV void Perl_boot_core_UNIVERSAL(pTHX); +PERL_CALLCONV void Perl_boot_core_ActivePerl(pTHX); PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX); PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV* av_list); PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, Uid_t effective, Stat_t* statbufp) diff -ruN perl-5.8.8/reentr.inc AP816_source/reentr.inc --- perl-5.8.8/reentr.inc 2005-09-18 08:58:21.000000000 -0700 +++ AP816_source/reentr.inc 2006-03-09 21:52:27.000000000 -0800 @@ -146,34 +146,34 @@ # undef getgrent # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBWR # ifdef PERL_CORE -# define getgrent() (((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0))) +# define getgrent() (((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0));}) +# define getgrent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0));}) # else # define getgrent() Perl_reentr_getgrent() static struct group* Perl_reentr_getgrent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0)); + return ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0)); } # endif # endif # endif # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBIR # ifdef PERL_CORE -# define getgrent() (((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0))) +# define getgrent() (((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0));}) +# define getgrent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0));}) # else # define getgrent() Perl_reentr_getgrent() static struct group* Perl_reentr_getgrent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0)); + return ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0)); } # endif # endif @@ -186,34 +186,34 @@ # endif # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBI # ifdef PERL_CORE -# define getgrent() (((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0))) +# define getgrent() (((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0));}) +# define getgrent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0));}) # else # define getgrent() Perl_reentr_getgrent() static struct group* Perl_reentr_getgrent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0)); + return ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0)); } # endif # endif # endif # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBIH # ifdef PERL_CORE -# define getgrent() (((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_fptr)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0))) +# define getgrent() (((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_fptr)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_fptr)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0));}) +# define getgrent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_fptr)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0));}) # else # define getgrent() Perl_reentr_getgrent() static struct group* Perl_reentr_getgrent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_fptr)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrent") : 0)); + return ((PL_REENTRANT_RETINT = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_fptr)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrent") : 0)); } # endif # endif @@ -224,51 +224,51 @@ # undef getgrgid # if !defined(getgrgid) && GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBWR # ifdef PERL_CORE -# define getgrgid(a) (((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0))) +# define getgrgid(a) (((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrgid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0));}) +# define getgrgid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0));}) # else # define getgrgid(a) Perl_reentr_getgrgid(a) static struct group* Perl_reentr_getgrgid(gid_t a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0)); + return ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0)); } # endif # endif # endif # if !defined(getgrgid) && GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBIR # ifdef PERL_CORE -# define getgrgid(a) (((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0))) +# define getgrgid(a) (((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrgid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0));}) +# define getgrgid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0));}) # else # define getgrgid(a) Perl_reentr_getgrgid(a) static struct group* Perl_reentr_getgrgid(gid_t a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0)); + return ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0)); } # endif # endif # endif # if !defined(getgrgid) && GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBI # ifdef PERL_CORE -# define getgrgid(a) (((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0))) +# define getgrgid(a) (((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrgid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0));}) +# define getgrgid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0));}) # else # define getgrgid(a) Perl_reentr_getgrgid(a) static struct group* Perl_reentr_getgrgid(gid_t a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0)); + return ((PL_REENTRANT_RETINT = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrgid", a) : 0)); } # endif # endif @@ -282,34 +282,34 @@ # undef getgrnam # if !defined(getgrnam) && GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR # ifdef PERL_CORE -# define getgrnam(a) (((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0))) +# define getgrnam(a) (((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0));}) +# define getgrnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0));}) # else # define getgrnam(a) Perl_reentr_getgrnam(a) static struct group* Perl_reentr_getgrnam(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0)); + return ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0)); } # endif # endif # endif # if !defined(getgrnam) && GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBIR # ifdef PERL_CORE -# define getgrnam(a) (((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0))) +# define getgrnam(a) (((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0));}) +# define getgrnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0));}) # else # define getgrnam(a) Perl_reentr_getgrnam(a) static struct group* Perl_reentr_getgrnam(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0)); + return ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0)); } # endif # endif @@ -319,17 +319,17 @@ # endif # if !defined(getgrnam) && GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBI # ifdef PERL_CORE -# define getgrnam(a) (((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0))) +# define getgrnam(a) (((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getgrnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0));}) +# define getgrnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0));}) # else # define getgrnam(a) Perl_reentr_getgrnam(a) static struct group* Perl_reentr_getgrnam(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0)); + return ((PL_REENTRANT_RETINT = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct group*)Perl_reentrant_retry("getgrnam", a) : 0)); } # endif # endif @@ -343,17 +343,17 @@ # undef gethostbyaddr # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CWISBWRE # ifdef PERL_CORE -# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) +# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) +# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) # else # define gethostbyaddr(a, b, c) Perl_reentr_gethostbyaddr(a, b, c) static struct hostent* Perl_reentr_gethostbyaddr(const char* a, size_t b, int c) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); + return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); } # endif # endif @@ -378,68 +378,68 @@ # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CWISD # ifdef PERL_CORE -# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) +# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) +# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) # else # define gethostbyaddr(a, b, c) Perl_reentr_gethostbyaddr(a, b, c) static struct hostent* Perl_reentr_gethostbyaddr(const char* a, size_t b, int c) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); + return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); } # endif # endif # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CIISD # ifdef PERL_CORE -# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) +# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) +# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) # else # define gethostbyaddr(a, b, c) Perl_reentr_gethostbyaddr(a, b, c) static struct hostent* Perl_reentr_gethostbyaddr(const char* a, int b, int c) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); + return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); } # endif # endif # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CII # ifdef PERL_CORE -# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c)) == 0 ? 1 : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) +# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c)) == 0 ? 1 : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c)) == 0 ? 1 : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) +# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c)) == 0 ? 1 : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) # else # define gethostbyaddr(a, b, c) Perl_reentr_gethostbyaddr(a, b, c) static struct hostent* Perl_reentr_gethostbyaddr(const char* a, int b, int c) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c)) == 0 ? 1 : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); + return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c)) == 0 ? 1 : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); } # endif # endif # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_TsISBWRE # ifdef PERL_CORE -# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) +# define gethostbyaddr(a, b, c) (((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) +# define gethostbyaddr(a, b, c) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0));}) # else # define gethostbyaddr(a, b, c) Perl_reentr_gethostbyaddr(a, b, c) static struct hostent* Perl_reentr_gethostbyaddr(const void* a, socklen_t b, int c) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); + return ((PL_REENTRANT_RETINT = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)); } # endif # endif @@ -450,17 +450,17 @@ # undef gethostbyname # if !defined(gethostbyname) && GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE # ifdef PERL_CORE -# define gethostbyname(a) (((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0))) +# define gethostbyname(a) (((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0));}) +# define gethostbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0));}) # else # define gethostbyname(a) Perl_reentr_gethostbyname(a) static struct hostent* Perl_reentr_gethostbyname(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0)); + return ((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0)); } # endif # endif @@ -470,17 +470,17 @@ # endif # if !defined(gethostbyname) && GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD # ifdef PERL_CORE -# define gethostbyname(a) (((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0))) +# define gethostbyname(a) (((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0));}) +# define gethostbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0));}) # else # define gethostbyname(a) Perl_reentr_gethostbyname(a) static struct hostent* Perl_reentr_gethostbyname(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0)); + return ((PL_REENTRANT_RETINT = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostbyname", a) : 0)); } # endif # endif @@ -491,34 +491,34 @@ # undef gethostent # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBWRE # ifdef PERL_CORE -# define gethostent() (((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0))) +# define gethostent() (((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0));}) +# define gethostent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0));}) # else # define gethostent() Perl_reentr_gethostent() static struct hostent* Perl_reentr_gethostent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0)); + return ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0)); } # endif # endif # endif # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBIE # ifdef PERL_CORE -# define gethostent() (((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0))) +# define gethostent() (((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0));}) +# define gethostent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0));}) # else # define gethostent() Perl_reentr_gethostent() static struct hostent* Perl_reentr_gethostent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0)); + return ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0)); } # endif # endif @@ -531,34 +531,34 @@ # endif # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBI # ifdef PERL_CORE -# define gethostent() (((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0))) +# define gethostent() (((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0));}) +# define gethostent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0));}) # else # define gethostent() Perl_reentr_gethostent() static struct hostent* Perl_reentr_gethostent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0)); + return ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0)); } # endif # endif # endif # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SD # ifdef PERL_CORE -# define gethostent() (((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0))) +# define gethostent() (((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define gethostent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0));}) +# define gethostent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0));}) # else # define gethostent() Perl_reentr_gethostent() static struct hostent* Perl_reentr_gethostent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0)); + return ((PL_REENTRANT_RETINT = gethostent_r(&PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct hostent*)Perl_reentrant_retry("gethostent") : 0)); } # endif # endif @@ -569,34 +569,34 @@ # undef getlogin # if !defined(getlogin) && GETLOGIN_R_PROTO == REENTRANT_PROTO_I_BW # ifdef PERL_CORE -# define getlogin() (((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (char*)Perl_reentrant_retry("getlogin") : 0))) +# define getlogin() (((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : ((PL_REENTRANT_RETINT == ERANGE) ? (char*)Perl_reentrant_retry("getlogin") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getlogin() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (char*)Perl_reentrant_retry("getlogin") : 0));}) +# define getlogin() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : ((PL_REENTRANT_RETINT == ERANGE) ? (char*)Perl_reentrant_retry("getlogin") : 0));}) # else # define getlogin() Perl_reentr_getlogin() static char* Perl_reentr_getlogin() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (char*)Perl_reentrant_retry("getlogin") : 0)); + return ((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : ((PL_REENTRANT_RETINT == ERANGE) ? (char*)Perl_reentrant_retry("getlogin") : 0)); } # endif # endif # endif # if !defined(getlogin) && GETLOGIN_R_PROTO == REENTRANT_PROTO_I_BI # ifdef PERL_CORE -# define getlogin() (((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (char*)Perl_reentrant_retry("getlogin") : 0))) +# define getlogin() (((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : ((PL_REENTRANT_RETINT == ERANGE) ? (char*)Perl_reentrant_retry("getlogin") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getlogin() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (char*)Perl_reentrant_retry("getlogin") : 0));}) +# define getlogin() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : ((PL_REENTRANT_RETINT == ERANGE) ? (char*)Perl_reentrant_retry("getlogin") : 0));}) # else # define getlogin() Perl_reentr_getlogin() static char* Perl_reentr_getlogin() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (char*)Perl_reentrant_retry("getlogin") : 0)); + return ((PL_REENTRANT_RETINT = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : ((PL_REENTRANT_RETINT == ERANGE) ? (char*)Perl_reentrant_retry("getlogin") : 0)); } # endif # endif @@ -613,34 +613,34 @@ # undef getnetbyaddr # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_UISBWRE # ifdef PERL_CORE -# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) +# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) +# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) # else # define getnetbyaddr(a, b) Perl_reentr_getnetbyaddr(a, b) static struct netent* Perl_reentr_getnetbyaddr(unsigned long a, int b) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); } # endif # endif # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_LISBI # ifdef PERL_CORE -# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) +# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) +# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) # else # define getnetbyaddr(a, b) Perl_reentr_getnetbyaddr(a, b) static struct netent* Perl_reentr_getnetbyaddr(long a, int b) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); } # endif # endif @@ -653,68 +653,68 @@ # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_TISD # ifdef PERL_CORE -# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) +# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) +# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) # else # define getnetbyaddr(a, b) Perl_reentr_getnetbyaddr(a, b) static struct netent* Perl_reentr_getnetbyaddr(in_addr_t a, int b) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); } # endif # endif # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_LISD # ifdef PERL_CORE -# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) +# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) +# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) # else # define getnetbyaddr(a, b) Perl_reentr_getnetbyaddr(a, b) static struct netent* Perl_reentr_getnetbyaddr(long a, int b) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); } # endif # endif # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_IISD # ifdef PERL_CORE -# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) +# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) +# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) # else # define getnetbyaddr(a, b) Perl_reentr_getnetbyaddr(a, b) static struct netent* Perl_reentr_getnetbyaddr(int a, int b) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); } # endif # endif # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_uISBWRE # ifdef PERL_CORE -# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) +# define getnetbyaddr(a, b) (((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) +# define getnetbyaddr(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0));}) # else # define getnetbyaddr(a, b) Perl_reentr_getnetbyaddr(a, b) static struct netent* Perl_reentr_getnetbyaddr(uint32_t a, int b) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyaddr", a, b) : 0)); } # endif # endif @@ -725,34 +725,34 @@ # undef getnetbyname # if !defined(getnetbyname) && GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE # ifdef PERL_CORE -# define getnetbyname(a) (((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0))) +# define getnetbyname(a) (((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0));}) +# define getnetbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0));}) # else # define getnetbyname(a) Perl_reentr_getnetbyname(a) static struct netent* Perl_reentr_getnetbyname(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0)); + return ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0)); } # endif # endif # endif # if !defined(getnetbyname) && GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBI # ifdef PERL_CORE -# define getnetbyname(a) (((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0))) +# define getnetbyname(a) (((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0));}) +# define getnetbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0));}) # else # define getnetbyname(a) Perl_reentr_getnetbyname(a) static struct netent* Perl_reentr_getnetbyname(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0)); + return ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0)); } # endif # endif @@ -762,17 +762,17 @@ # endif # if !defined(getnetbyname) && GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD # ifdef PERL_CORE -# define getnetbyname(a) (((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0))) +# define getnetbyname(a) (((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0));}) +# define getnetbyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0));}) # else # define getnetbyname(a) Perl_reentr_getnetbyname(a) static struct netent* Perl_reentr_getnetbyname(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0)); + return ((PL_REENTRANT_RETINT = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetbyname", a) : 0)); } # endif # endif @@ -783,34 +783,34 @@ # undef getnetent # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBWRE # ifdef PERL_CORE -# define getnetent() (((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0))) +# define getnetent() (((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0));}) +# define getnetent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0));}) # else # define getnetent() Perl_reentr_getnetent() static struct netent* Perl_reentr_getnetent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0)); + return ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0)); } # endif # endif # endif # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBIE # ifdef PERL_CORE -# define getnetent() (((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_errno)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0))) +# define getnetent() (((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_errno)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_errno)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0));}) +# define getnetent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_errno)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0));}) # else # define getnetent() Perl_reentr_getnetent() static struct netent* Perl_reentr_getnetent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_errno)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0)); + return ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_errno)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0)); } # endif # endif @@ -823,34 +823,34 @@ # endif # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBI # ifdef PERL_CORE -# define getnetent() (((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0))) +# define getnetent() (((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0));}) +# define getnetent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0));}) # else # define getnetent() Perl_reentr_getnetent() static struct netent* Perl_reentr_getnetent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0)); + return ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0)); } # endif # endif # endif # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_I_SD # ifdef PERL_CORE -# define getnetent() (((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0))) +# define getnetent() (((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getnetent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0));}) +# define getnetent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0));}) # else # define getnetent() Perl_reentr_getnetent() static struct netent* Perl_reentr_getnetent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0)); + return ((PL_REENTRANT_RETINT = getnetent_r(&PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct netent*)Perl_reentrant_retry("getnetent") : 0)); } # endif # endif @@ -861,17 +861,17 @@ # undef getprotobyname # if !defined(getprotobyname) && GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWR # ifdef PERL_CORE -# define getprotobyname(a) (((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0))) +# define getprotobyname(a) (((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getprotobyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0));}) +# define getprotobyname(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0));}) # else # define getprotobyname(a) Perl_reentr_getprotobyname(a) static struct protoent* Perl_reentr_getprotobyname(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0)); + return ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0)); } # endif # endif @@ -881,17 +881,17 @@ # endif # if !defined(getprotobyname) && GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD # ifdef PERL_CORE -# define getprotobyname(a) (REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)), ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0))) +# define getprotobyname(a) (REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)), ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getprotobyname(a) ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)); ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0));}) +# define getprotobyname(a) ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)); ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0));}) # else # define getprotobyname(a) Perl_reentr_getprotobyname(a) static struct protoent* Perl_reentr_getprotobyname(const char* a) { dTHX; int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)); - return ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0)); + return ((PL_REENTRANT_RETINT = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobyname", a) : 0)); } # endif # endif @@ -902,17 +902,17 @@ # undef getprotobynumber # if !defined(getprotobynumber) && GETPROTOBYNUMBER_R_PROTO == REENTRANT_PROTO_I_ISBWR # ifdef PERL_CORE -# define getprotobynumber(a) (((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0))) +# define getprotobynumber(a) (((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getprotobynumber(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0));}) +# define getprotobynumber(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0));}) # else # define getprotobynumber(a) Perl_reentr_getprotobynumber(a) static struct protoent* Perl_reentr_getprotobynumber(int a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0)); + return ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0)); } # endif # endif @@ -922,17 +922,17 @@ # endif # if !defined(getprotobynumber) && GETPROTOBYNUMBER_R_PROTO == REENTRANT_PROTO_I_ISD # ifdef PERL_CORE -# define getprotobynumber(a) (REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)), ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0))) +# define getprotobynumber(a) (REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)), ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getprotobynumber(a) ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)); ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0));}) +# define getprotobynumber(a) ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)); ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0));}) # else # define getprotobynumber(a) Perl_reentr_getprotobynumber(a) static struct protoent* Perl_reentr_getprotobynumber(int a) { dTHX; int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)); - return ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0)); + return ((PL_REENTRANT_RETINT = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotobynumber", a) : 0)); } # endif # endif @@ -943,34 +943,34 @@ # undef getprotoent # if !defined(getprotoent) && GETPROTOENT_R_PROTO == REENTRANT_PROTO_I_SBWR # ifdef PERL_CORE -# define getprotoent() (((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0))) +# define getprotoent() (((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getprotoent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0));}) +# define getprotoent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0));}) # else # define getprotoent() Perl_reentr_getprotoent() static struct protoent* Perl_reentr_getprotoent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0)); + return ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0)); } # endif # endif # endif # if !defined(getprotoent) && GETPROTOENT_R_PROTO == REENTRANT_PROTO_I_SBI # ifdef PERL_CORE -# define getprotoent() (((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0))) +# define getprotoent() (((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getprotoent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0));}) +# define getprotoent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0));}) # else # define getprotoent() Perl_reentr_getprotoent() static struct protoent* Perl_reentr_getprotoent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0)); + return ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0)); } # endif # endif @@ -980,17 +980,17 @@ # endif # if !defined(getprotoent) && GETPROTOENT_R_PROTO == REENTRANT_PROTO_I_SD # ifdef PERL_CORE -# define getprotoent() (REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)), ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0))) +# define getprotoent() (REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)), ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getprotoent() ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)); ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0));}) +# define getprotoent() ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)); ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0));}) # else # define getprotoent() Perl_reentr_getprotoent() static struct protoent* Perl_reentr_getprotoent() { dTHX; int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)); - return ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0)); + return ((PL_REENTRANT_RETINT = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct protoent*)Perl_reentrant_retry("getprotoent") : 0)); } # endif # endif @@ -1001,34 +1001,34 @@ # undef getpwent # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBWR # ifdef PERL_CORE -# define getpwent() (((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0))) +# define getpwent() (((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0));}) +# define getpwent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0));}) # else # define getpwent() Perl_reentr_getpwent() static struct passwd* Perl_reentr_getpwent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0)); + return ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0)); } # endif # endif # endif # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBIR # ifdef PERL_CORE -# define getpwent() (((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0))) +# define getpwent() (((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0));}) +# define getpwent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0));}) # else # define getpwent() Perl_reentr_getpwent() static struct passwd* Perl_reentr_getpwent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0)); + return ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0)); } # endif # endif @@ -1041,34 +1041,34 @@ # endif # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBI # ifdef PERL_CORE -# define getpwent() (((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0))) +# define getpwent() (((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0));}) +# define getpwent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0));}) # else # define getpwent() Perl_reentr_getpwent() static struct passwd* Perl_reentr_getpwent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0)); + return ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0)); } # endif # endif # endif # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBIH # ifdef PERL_CORE -# define getpwent() (((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_fptr)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0))) +# define getpwent() (((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_fptr)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_fptr)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0));}) +# define getpwent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_fptr)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0));}) # else # define getpwent() Perl_reentr_getpwent() static struct passwd* Perl_reentr_getpwent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_fptr)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0)); + return ((PL_REENTRANT_RETINT = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_fptr)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwent") : 0)); } # endif # endif @@ -1079,34 +1079,34 @@ # undef getpwnam # if !defined(getpwnam) && GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR # ifdef PERL_CORE -# define getpwnam(a) (((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0))) +# define getpwnam(a) (((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0));}) +# define getpwnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0));}) # else # define getpwnam(a) Perl_reentr_getpwnam(a) static struct passwd* Perl_reentr_getpwnam(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0)); + return ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0)); } # endif # endif # endif # if !defined(getpwnam) && GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBIR # ifdef PERL_CORE -# define getpwnam(a) (((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0))) +# define getpwnam(a) (((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0));}) +# define getpwnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0));}) # else # define getpwnam(a) Perl_reentr_getpwnam(a) static struct passwd* Perl_reentr_getpwnam(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0)); + return ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0)); } # endif # endif @@ -1116,17 +1116,17 @@ # endif # if !defined(getpwnam) && GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBI # ifdef PERL_CORE -# define getpwnam(a) (((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0))) +# define getpwnam(a) (((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0));}) +# define getpwnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0));}) # else # define getpwnam(a) Perl_reentr_getpwnam(a) static struct passwd* Perl_reentr_getpwnam(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0)); + return ((PL_REENTRANT_RETINT = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwnam", a) : 0)); } # endif # endif @@ -1137,51 +1137,51 @@ # undef getpwuid # if !defined(getpwuid) && GETPWUID_R_PROTO == REENTRANT_PROTO_I_TSBWR # ifdef PERL_CORE -# define getpwuid(a) (((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0))) +# define getpwuid(a) (((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwuid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0));}) +# define getpwuid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0));}) # else # define getpwuid(a) Perl_reentr_getpwuid(a) static struct passwd* Perl_reentr_getpwuid(uid_t a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0)); + return ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0)); } # endif # endif # endif # if !defined(getpwuid) && GETPWUID_R_PROTO == REENTRANT_PROTO_I_TSBIR # ifdef PERL_CORE -# define getpwuid(a) (((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0))) +# define getpwuid(a) (((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwuid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0));}) +# define getpwuid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0));}) # else # define getpwuid(a) Perl_reentr_getpwuid(a) static struct passwd* Perl_reentr_getpwuid(uid_t a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0)); + return ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0)); } # endif # endif # endif # if !defined(getpwuid) && GETPWUID_R_PROTO == REENTRANT_PROTO_I_TSBI # ifdef PERL_CORE -# define getpwuid(a) (((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0))) +# define getpwuid(a) (((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getpwuid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0));}) +# define getpwuid(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0));}) # else # define getpwuid(a) Perl_reentr_getpwuid(a) static struct passwd* Perl_reentr_getpwuid(uid_t a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0)); + return ((PL_REENTRANT_RETINT = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct passwd*)Perl_reentrant_retry("getpwuid", a) : 0)); } # endif # endif @@ -1195,17 +1195,17 @@ # undef getservbyname # if !defined(getservbyname) && GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSBWR # ifdef PERL_CORE -# define getservbyname(a, b) (((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0))) +# define getservbyname(a, b) (((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getservbyname(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0));}) +# define getservbyname(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0));}) # else # define getservbyname(a, b) Perl_reentr_getservbyname(a, b) static struct servent* Perl_reentr_getservbyname(const char* a, const char* b) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0)); } # endif # endif @@ -1215,17 +1215,17 @@ # endif # if !defined(getservbyname) && GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSD # ifdef PERL_CORE -# define getservbyname(a, b) (REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)), ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0))) +# define getservbyname(a, b) (REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)), ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getservbyname(a, b) ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)); ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0));}) +# define getservbyname(a, b) ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)); ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0));}) # else # define getservbyname(a, b) Perl_reentr_getservbyname(a, b) static struct servent* Perl_reentr_getservbyname(const char* a, const char* b) { dTHX; int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)); - return ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyname", a, b) : 0)); } # endif # endif @@ -1236,17 +1236,17 @@ # undef getservbyport # if !defined(getservbyport) && GETSERVBYPORT_R_PROTO == REENTRANT_PROTO_I_ICSBWR # ifdef PERL_CORE -# define getservbyport(a, b) (((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0))) +# define getservbyport(a, b) (((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getservbyport(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0));}) +# define getservbyport(a, b) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0));}) # else # define getservbyport(a, b) Perl_reentr_getservbyport(a, b) static struct servent* Perl_reentr_getservbyport(int a, const char* b) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0)); } # endif # endif @@ -1256,17 +1256,17 @@ # endif # if !defined(getservbyport) && GETSERVBYPORT_R_PROTO == REENTRANT_PROTO_I_ICSD # ifdef PERL_CORE -# define getservbyport(a, b) (REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)), ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0))) +# define getservbyport(a, b) (REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)), ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getservbyport(a, b) ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)); ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0));}) +# define getservbyport(a, b) ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)); ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0));}) # else # define getservbyport(a, b) Perl_reentr_getservbyport(a, b) static struct servent* Perl_reentr_getservbyport(int a, const char* b) { dTHX; int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)); - return ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0)); + return ((PL_REENTRANT_RETINT = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservbyport", a, b) : 0)); } # endif # endif @@ -1277,34 +1277,34 @@ # undef getservent # if !defined(getservent) && GETSERVENT_R_PROTO == REENTRANT_PROTO_I_SBWR # ifdef PERL_CORE -# define getservent() (((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservent") : 0))) +# define getservent() (((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getservent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservent") : 0));}) +# define getservent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservent") : 0));}) # else # define getservent() Perl_reentr_getservent() static struct servent* Perl_reentr_getservent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservent") : 0)); + return ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservent") : 0)); } # endif # endif # endif # if !defined(getservent) && GETSERVENT_R_PROTO == REENTRANT_PROTO_I_SBI # ifdef PERL_CORE -# define getservent() (((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservent") : 0))) +# define getservent() (((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getservent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservent") : 0));}) +# define getservent() ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservent") : 0));}) # else # define getservent() Perl_reentr_getservent() static struct servent* Perl_reentr_getservent() { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservent") : 0)); + return ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservent") : 0)); } # endif # endif @@ -1314,17 +1314,17 @@ # endif # if !defined(getservent) && GETSERVENT_R_PROTO == REENTRANT_PROTO_I_SD # ifdef PERL_CORE -# define getservent() (REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)), ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservent") : 0))) +# define getservent() (REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)), ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservent") : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getservent() ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)); ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservent") : 0));}) +# define getservent() ({int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)); ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservent") : 0));}) # else # define getservent() Perl_reentr_getservent() static struct servent* Perl_reentr_getservent() { dTHX; int PL_REENTRANT_RETINT; REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)); - return ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct servent*)Perl_reentrant_retry("getservent") : 0)); + return ((PL_REENTRANT_RETINT = getservent_r(&PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_REENTRANT_RETINT == ERANGE) ? (struct servent*)Perl_reentrant_retry("getservent") : 0)); } # endif # endif @@ -1335,17 +1335,17 @@ # undef getspnam # if !defined(getspnam) && GETSPNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR # ifdef PERL_CORE -# define getspnam(a) (((PL_REENTRANT_RETINT = getspnam_r(a, &PL_reentrant_buffer->_spent_struct, PL_reentrant_buffer->_spent_buffer, PL_reentrant_buffer->_spent_size, &PL_reentrant_buffer->_spent_ptr)) == 0 ? PL_reentrant_buffer->_spent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct spwd*)Perl_reentrant_retry("getspnam", a) : 0))) +# define getspnam(a) (((PL_REENTRANT_RETINT = getspnam_r(a, &PL_reentrant_buffer->_spent_struct, PL_reentrant_buffer->_spent_buffer, PL_reentrant_buffer->_spent_size, &PL_reentrant_buffer->_spent_ptr)) == 0 ? PL_reentrant_buffer->_spent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct spwd*)Perl_reentrant_retry("getspnam", a) : 0))) # else # if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) -# define getspnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getspnam_r(a, &PL_reentrant_buffer->_spent_struct, PL_reentrant_buffer->_spent_buffer, PL_reentrant_buffer->_spent_size, &PL_reentrant_buffer->_spent_ptr)) == 0 ? PL_reentrant_buffer->_spent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct spwd*)Perl_reentrant_retry("getspnam", a) : 0));}) +# define getspnam(a) ({int PL_REENTRANT_RETINT; ; ((PL_REENTRANT_RETINT = getspnam_r(a, &PL_reentrant_buffer->_spent_struct, PL_reentrant_buffer->_spent_buffer, PL_reentrant_buffer->_spent_size, &PL_reentrant_buffer->_spent_ptr)) == 0 ? PL_reentrant_buffer->_spent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct spwd*)Perl_reentrant_retry("getspnam", a) : 0));}) # else # define getspnam(a) Perl_reentr_getspnam(a) static struct spwd* Perl_reentr_getspnam(const char* a) { dTHX; int PL_REENTRANT_RETINT; ; - return ((PL_REENTRANT_RETINT = getspnam_r(a, &PL_reentrant_buffer->_spent_struct, PL_reentrant_buffer->_spent_buffer, PL_reentrant_buffer->_spent_size, &PL_reentrant_buffer->_spent_ptr)) == 0 ? PL_reentrant_buffer->_spent_ptr : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? (struct spwd*)Perl_reentrant_retry("getspnam", a) : 0)); + return ((PL_REENTRANT_RETINT = getspnam_r(a, &PL_reentrant_buffer->_spent_struct, PL_reentrant_buffer->_spent_buffer, PL_reentrant_buffer->_spent_size, &PL_reentrant_buffer->_spent_ptr)) == 0 ? PL_reentrant_buffer->_spent_ptr : ((PL_REENTRANT_RETINT == ERANGE) ? (struct spwd*)Perl_reentrant_retry("getspnam", a) : 0)); } # endif # endif diff -ruN perl-5.8.8/reentr.pl AP816_source/reentr.pl --- perl-5.8.8/reentr.pl 2006-01-02 06:43:56.000000000 -0800 +++ AP816_source/reentr.pl 2006-03-09 21:52:27.000000000 -0800 @@ -711,7 +711,7 @@ if ($func =~ /^get/) { my $rv = $v ? ", $v" : ""; if ($r eq 'I') { - $call = qq[((PL_REENTRANT_RETINT = $call)$test ? $true : (((PL_REENTRANT_RETINT == ERANGE) || (errno == ERANGE)) ? ($seenm{$func}{$seenr{$func}})Perl_reentrant_retry("$func"$rv) : 0))]; + $call = qq[((PL_REENTRANT_RETINT = $call)$test ? $true : ((PL_REENTRANT_RETINT == ERANGE) ? ($seenm{$func}{$seenr{$func}})Perl_reentrant_retry("$func"$rv) : 0))]; my $arg = join(", ", map { $seenm{$func}{substr($a,$_,1)}." ".$v[$_] } 0..$seenu{$func}-1); my $ret = $seenr{$func} eq 'V' ? "" : "return "; my $memzero_ = $memzero ? "$memzero, " : ""; diff -ruN perl-5.8.8/regcomp.c AP816_source/regcomp.c --- perl-5.8.8/regcomp.c 2006-01-08 12:59:27.000000000 -0800 +++ AP816_source/regcomp.c 2006-03-09 21:52:27.000000000 -0800 @@ -1810,6 +1810,7 @@ r->subbeg = NULL; r->reganch = pm->op_pmflags & PMf_COMPILETIME; r->nparens = RExC_npar - 1; /* set early to validate backrefs */ + r->lastparen = 0; /* mg.c reads this. */ r->substrs = 0; /* Useful during FAIL. */ r->startp = 0; /* Useful during FAIL. */ diff -ruN perl-5.8.8/t/op/fork.t AP816_source/t/op/fork.t --- perl-5.8.8/t/op/fork.t 2003-10-02 11:35:14.000000000 -0700 +++ AP816_source/t/op/fork.t 2006-03-09 21:52:27.000000000 -0800 @@ -97,6 +97,24 @@ ok 2 ######## $| = 1; +if ($cid = fork) { + sleep 1; + print "not " unless kill 'INT', $cid; + print "ok 2\n"; +} +else { + # XXX On Windows the default signal handler kills the + # XXX whole process, not just the thread (pseudo-process) + $SIG{INT} = sub { exit }; + print "ok 1\n"; + sleep 5; + die; +} +EXPECT +ok 1 +ok 2 +######## +$| = 1; sub forkit { print "iteration $i start\n"; my $x = fork; diff -ruN perl-5.8.8/t/op/sig.t AP816_source/t/op/sig.t --- perl-5.8.8/t/op/sig.t 1969-12-31 16:00:00.000000000 -0800 +++ AP816_source/t/op/sig.t 2006-03-09 21:52:27.000000000 -0800 @@ -0,0 +1,56 @@ +#!perl -w + +BEGIN { + chdir 't' if -d 't'; + @INC = '../lib'; + eval { + require POSIX; + POSIX::->import(qw(WNOHANG SIGINT SIGTERM)); + }; + if ($@ or !$Config{d_fork}) { + print "# $@\n"; + print "1..0 # skipped, not posix compatible\n"; + exit 0; + } +} + +use strict; + +my $done = 0; +sub reaper { + print "# got sig\n"; + $done = 1; +} + +sub start_child { + my $pid = fork(); + + defined $pid or die "fork() failed: $!"; + unless ($pid) { + # child + $SIG{INT} = $SIG{TERM} = \&reaper; + while () { + last if $done; + sleep(30); + } + exit; + } + sleep 1; + return $pid; +} + +my $test = 1; +my @signals = (SIGINT, SIGTERM); +print "1.." . (@signals * 3) . "\n"; + +# SIGINT/SIGTERM should not restart sleep() +for my $sig (@signals) { + my $pid = start_child(); + print "not " unless kill(SIGINT, $pid) == 1; + print "ok $test\n"; ++$test; + sleep 1; + print "not " unless waitpid($pid, WNOHANG) == $pid; + print "ok $test\n"; ++$test; + print "# [$?]\nnot " unless 0 == ($? >> 8); + print "ok $test\n"; ++$test; +} diff -ruN perl-5.8.8/t/run/switches.t AP816_source/t/run/switches.t --- perl-5.8.8/t/run/switches.t 2003-09-14 01:07:36.000000000 -0700 +++ AP816_source/t/run/switches.t 2006-03-09 21:52:27.000000000 -0800 @@ -11,7 +11,7 @@ require "./test.pl"; -plan(tests => 26); +plan(tests => 27); use Config; @@ -125,11 +125,27 @@ ); is( $r, '21-', '-s switch parsing' ); -# Bug ID 20011106.084 $filename = 'swstest.tmp'; SKIP: { open my $f, ">$filename" or skip( "Can't write temp file $filename: $!" ); print $f <<'SWTEST'; +#!perl -s +BEGIN { print $x,$y; exit } +SWTEST + close $f or die "Could not close: $!"; + $r = runperl( + progfile => $filename, + args => [ '-x=foo -y' ], + ); + is( $r, 'foo1', '-s on the shebang line' ); + push @tmpfiles, $filename; +} + +# Bug ID 20011106.084 +$filename = 'swsntest.tmp'; +SKIP: { + open my $f, ">$filename" or skip( "Can't write temp file $filename: $!" ); + print $f <<'SWTEST'; #!perl -sn BEGIN { print $x; exit } SWTEST @@ -138,7 +154,7 @@ progfile => $filename, args => [ '-x=foo' ], ); - is( $r, 'foo', '-s on the shebang line' ); + is( $r, 'foo', '-sn on the shebang line' ); push @tmpfiles, $filename; } diff -ruN perl-5.8.8/toke.c AP816_source/toke.c --- perl-5.8.8/toke.c 2006-01-08 12:59:55.000000000 -0800 +++ AP816_source/toke.c 2006-03-09 21:52:27.000000000 -0800 @@ -2973,14 +2973,6 @@ (void)gv_fetchfile(PL_origfilename); goto retry; } - if (PL_doswitches && !switches_done) { - int argc = PL_origargc; - char **argv = PL_origargv; - do { - argc--,argv++; - } while (argc && argv[0][0] == '-' && argv[0][1]); - init_argv_symbols(argc,argv); - } } } } diff -ruN perl-5.8.8/util.c AP816_source/util.c --- perl-5.8.8/util.c 2006-01-08 12:59:59.000000000 -0800 +++ AP816_source/util.c 2006-03-09 21:52:28.000000000 -0800 @@ -2442,6 +2442,9 @@ act.sa_flags = 0; #ifdef SA_RESTART if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) +# if defined(__hpux) && !(defined(__ux_version) && __ux_version <= 1020) + if (signo != SIGTERM && signo != SIGINT) +# endif act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */ #endif #if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */ diff -ruN perl-5.8.8/utils/c2ph.PL AP816_source/utils/c2ph.PL --- perl-5.8.8/utils/c2ph.PL 2004-10-19 12:45:42.000000000 -0700 +++ AP816_source/utils/c2ph.PL 2006-03-09 21:52:28.000000000 -0800 @@ -1320,7 +1320,7 @@ $intrinsics{$_[1]} = $template{$_[0]}; } close(PIPE) || die "couldn't read intrinsics!"; - unlink($TMP, '$SAFEDIR/a.out'); + unlink($TMP, "$SAFEDIR/a.out"); print STDERR "done\n" if $trace; } diff -ruN perl-5.8.8/utils/perlbug.PL AP816_source/utils/perlbug.PL --- perl-5.8.8/utils/perlbug.PL 2006-01-03 11:07:41.000000000 -0800 +++ AP816_source/utils/perlbug.PL 2006-03-09 21:52:28.000000000 -0800 @@ -42,6 +42,7 @@ my @patches; while () { last if /^\s*}/; + next if /^\s*#/; # preprocessor stuff chomp; s/^\s+,?\s*"?//; s/"\s+STRINGIFY\(PERL_PATCHNUM\)/$patchnum"/; diff -ruN perl-5.8.8/win32/config_H.vc AP816_source/win32/config_H.vc --- perl-5.8.8/win32/config_H.vc 2006-01-18 11:43:23.000000000 -0800 +++ AP816_source/win32/config_H.vc 2006-03-09 21:52:28.000000000 -0800 @@ -1128,7 +1128,9 @@ * This symbol is defined if the C compiler can cast negative * or large floating point numbers to 32-bit ints. */ -/*#define CASTI32 /**/ +#ifdef __GNUC__ +# define CASTI32 /**/ +#endif /* CASTNEGFLOAT: * This symbol is defined if the C compiler can cast negative @@ -3044,7 +3046,11 @@ /* Off_t_size: * This symbol holds the number of bytes used by the Off_t. */ -#define Off_t __int64 /* type */ +#ifndef __GNUC__ +# define Off_t __int64 /* type */ +#else +# define Off_t long long /* type */ +#endif #define LSEEKSIZE 8 /* size */ #define Off_t_size 8 /* size */ @@ -3152,8 +3158,13 @@ */ /*#define HAS_QUAD /**/ #ifdef HAS_QUAD -# define Quad_t __int64 /**/ -# define Uquad_t unsigned __int64 /**/ +# ifndef __GNUC__ +# define Quad_t __int64 /**/ +# define Uquad_t unsigned __int64 /**/ +# else +# define Quad_t long long /**/ +# define Uquad_t unsigned long long /**/ +# endif # define QUADKIND 5 /**/ # define QUAD_IS_INT 1 # define QUAD_IS_LONG 2 @@ -3248,8 +3259,13 @@ #define I32TYPE long /**/ #define U32TYPE unsigned long /**/ #ifdef HAS_QUAD -#define I64TYPE __int64 /**/ -#define U64TYPE unsigned __int64 /**/ +# ifndef __GNUC__ +# define I64TYPE __int64 /**/ +# define U64TYPE unsigned __int64 /**/ +# else +# define I64TYPE long long /**/ +# define U64TYPE unsigned long long /**/ +# endif #endif #define NVTYPE double /**/ #define IVSIZE 4 /**/ @@ -3855,7 +3871,9 @@ * This symbol, if defined, indicates that the "fast stdio" * is available to manipulate the stdio buffers directly. */ -#define HAS_FAST_STDIO /**/ +#ifndef __GNUC__ +# define HAS_FAST_STDIO /**/ +#endif /* HAS_FLOCK_PROTO: * This symbol, if defined, indicates that the system provides diff -ruN perl-5.8.8/win32/Makefile AP816_source/win32/Makefile --- perl-5.8.8/win32/Makefile 2006-01-31 15:40:14.000000000 -0800 +++ AP816_source/win32/Makefile 2006-03-09 21:56:55.000000000 -0800 @@ -51,7 +51,7 @@ # before anything else. This script can then be set up, for example, # to add additional entries to @INC. # -#USE_SITECUST = define +USE_SITECUST = define # # uncomment to enable multiple interpreters. This is need for fork() @@ -193,7 +193,7 @@ # The latter is required to maintain binary compatibility with Perl 5.8.0. # #BUILDOPT = $(BUILDOPT) -DPERL_HASH_SEED_EXPLICIT -#BUILDOPT = $(BUILDOPT) -DNO_HASH_SEED +BUILDOPT = $(BUILDOPT) -DNO_HASH_SEED # # @@ -228,7 +228,7 @@ # set this to your email address (perl will guess a value from # from your loginname and your hostname, which may not be right) # -#EMAIL = +EMAIL = support@ActiveState.com ## ## Build configuration ends. @@ -335,6 +335,13 @@ !ENDIF !ENDIF +!IF "$(PROCESSOR_ARCHITECTURE)" == "AMD64" +PROCESSOR_ARCHITECTURE = x86_64 +!ENDIF +!IF "$(PROCESSOR_ARCHITECTURE)" == "IA64" +PROCESSOR_ARCHITECTURE = ia64 +!ENDIF + !IF "$(USE_5005THREADS)" == "define" ARCHNAME = MSWin32-$(PROCESSOR_ARCHITECTURE)-thread !ELSE @@ -437,15 +444,7 @@ !IF "$(WIN64)" == "define" DEFINES = $(DEFINES) -DWIN64 -DCONSERVATIVE -OPTIMIZE = $(OPTIMIZE) -Wp64 -Op -!ENDIF - -# the string-pooling option -Gf is deprecated in VC++ 7.x and will be removed -# in later versions, so use read-only string-pooling (-GF) instead -!IF "$(CCTYPE)" == "MSVC70FREE" || "$(CCTYPE)" == "MSVC70" -STRPOOL = -GF -!ELSE -STRPOOL = -Gf +OPTIMIZE = $(OPTIMIZE) -Wp64 -fp:precise !ENDIF !IF "$(USE_PERLCRT)" != "define" @@ -456,17 +455,20 @@ oldnames.lib kernel32.lib user32.lib gdi32.lib winspool.lib \ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib \ netapi32.lib uuid.lib ws2_32.lib mpr.lib winmm.lib \ - version.lib + version.lib odbc32.lib odbccp32.lib -# win64 doesn't have some libs -!IF "$(WIN64)" != "define" -LIBBASEFILES = $(LIBBASEFILES) odbc32.lib odbccp32.lib +# The 64 bit Platform SDK compilers contain a runtime library that doesn't +# include the buffer overrun verification code used by the /GS switch. +# Since the code links against libraries that are compiled with /GS, this +# "security cookie verification" must be included via bufferoverlow.lib. +!IF "$(WIN64)" == "define" +LIBBASEFILES = $(LIBBASEFILES) bufferoverflowU.lib !ENDIF # we add LIBC here, since we may be using PerlCRT.dll LIBFILES = $(LIBBASEFILES) $(LIBC) -EXTRACFLAGS = -nologo $(STRPOOL) -W3 +EXTRACFLAGS = -nologo -GF -W3 CFLAGS = $(EXTRACFLAGS) $(INCLUDES) $(DEFINES) $(LOCDEFS) \ $(PCHFLAGS) $(OPTIMIZE) LINK_FLAGS = -nologo -nodefaultlib $(LINK_DBG) \ @@ -530,7 +532,7 @@ PERLEXE_ICO = .\perlexe.ico PERLEXE_RES = .\perlexe.res -PERLDLL_RES = +PERLDLL_RES = .\perldll.res # Nominate a target which causes extensions to be re-built # This used to be $(PERLEXE), but at worst it is the .dll that they depend @@ -602,6 +604,7 @@ -C++ -prototypes MICROCORE_SRC = \ + ..\activeperl.c \ ..\av.c \ ..\deb.c \ ..\doio.c \ @@ -995,10 +998,10 @@ << $(XCOPY) $(PERLIMPLIB) $(COREDIR) -$(PERLEXE_ICO): $(MINIPERL) makeico.pl - $(MINIPERL) makeico.pl > $@ - -$(PERLEXE_RES): perlexe.rc $(PERLEXE_ICO) +#$(PERLEXE_ICO): $(MINIPERL) makeico.pl +# $(MINIPERL) makeico.pl > $@ +# +#$(PERLEXE_RES): perlexe.rc $(PERLEXE_ICO) $(MINIMOD) : $(MINIPERL) ..\minimod.pl cd .. @@ -1214,7 +1217,8 @@ -del /f $(CONFIGPM) -del /f bin\*.bat -del /f perllibst.h - -del /f $(PERLEXE_ICO) perl.base +# -del /f $(PERLEXE_ICO) + -del /f perl.base -cd .. && del /s *.lib *.map *.pdb *.ilk *.bs *$(o) .exists pm_to_blib -cd $(EXTDIR) && del /s *.def Makefile Makefile.old -if exist $(AUTODIR) rmdir /s /q $(AUTODIR) diff -ruN perl-5.8.8/win32/makefile.mk AP816_source/win32/makefile.mk --- perl-5.8.8/win32/makefile.mk 2006-01-31 15:40:14.000000000 -0800 +++ AP816_source/win32/makefile.mk 2006-03-09 21:56:55.000000000 -0800 @@ -53,7 +53,7 @@ # before anything else. This script can then be set up, for example, # to add additional entries to @INC. # -#USE_SITECUST *= define +USE_SITECUST *= define # # uncomment to enable multiple interpreters. This is need for fork() @@ -216,7 +216,7 @@ # The latter is required to maintain binary compatibility with Perl 5.8.0. # #BUILDOPT += -DPERL_HASH_SEED_EXPLICIT -#BUILDOPT += -DNO_HASH_SEED +BUILDOPT += -DNO_HASH_SEED # # This should normally be disabled. Adding -DPERL_POLLUTE enables support @@ -256,7 +256,7 @@ # set this to your email address (perl will guess a value from # from your loginname and your hostname, which may not be right) # -#EMAIL *= +EMAIL *= support@ActiveState.com ## ## Build configuration ends. @@ -653,7 +653,7 @@ .rc.res: .IF "$(CCTYPE)" == "GCC" - $(RSC) --use-temp-file -i $< -o $@ + $(RSC) --use-temp-file -I . -I .. -i $< -o $@ .ELSE $(RSC) -i.. $< .ENDIF @@ -681,7 +681,7 @@ PERLEXE_ICO = .\perlexe.ico PERLEXE_RES = .\perlexe.res -PERLDLL_RES = +PERLDLL_RES = .\perldll.res # Nominate a target which causes extensions to be re-built # This used to be $(PERLEXE), but at worst it is the .dll that they depend @@ -768,6 +768,7 @@ -C++ -prototypes MICROCORE_SRC = \ + ..\activeperl.c \ ..\av.c \ ..\deb.c \ ..\doio.c \ @@ -1161,11 +1162,10 @@ .ENDIF $(XCOPY) $(PERLIMPLIB) $(COREDIR) - -$(PERLEXE_ICO): $(MINIPERL) makeico.pl - $(MINIPERL) makeico.pl > $@ - -$(PERLEXE_RES): perlexe.rc $(PERLEXE_ICO) +#$(PERLEXE_ICO): $(MINIPERL) makeico.pl +# $(MINIPERL) makeico.pl > $@ +# +#$(PERLEXE_RES): perlexe.rc $(PERLEXE_ICO) $(MINIMOD) : $(MINIPERL) ..\minimod.pl cd .. && miniperl minimod.pl > lib\ExtUtils\Miniperl.pm @@ -1387,8 +1387,8 @@ -del /f ..\config.sh ..\splittree.pl perlmain.c dlutils.c config.h.new -del /f $(CONFIGPM) -del /f bin\*.bat - -del /f perllibst.h - -del /f $(PERLEXE_ICO) perl.base +# -del /f $(PERLEXE_ICO) + -del /f perl.base -cd .. && del /s *$(a) *.map *.pdb *.ilk *.tds *.bs *$(o) .exists pm_to_blib -cd $(EXTDIR) && del /s *.def Makefile Makefile.old -if exist $(AUTODIR) rmdir /s /q $(AUTODIR) diff -ruN perl-5.8.8/win32/perldll.rc AP816_source/win32/perldll.rc --- perl-5.8.8/win32/perldll.rc 1969-12-31 16:00:00.000000000 -0800 +++ AP816_source/win32/perldll.rc 2006-03-09 21:52:28.000000000 -0800 @@ -0,0 +1,52 @@ +// PerlDll.rc + +// (c) 1995-1998 Microsoft Corporation. All rights reserved. +// Developed by ActiveState Tool Corp., http://www.ActiveState.com + +// You may distribute under the terms of either the GNU General Public +// License or the Artistic License, as specified in the README file. + +#include +#include "BuildInfo.h" + +PERLDLL ICON perl.ico + +#ifndef _DEBUG +#define VER_DEBUG 0 +#else +#define VER_DEBUG VS_FF_DEBUG +#endif + +VS_VERSION_INFO VERSIONINFO + FILEVERSION PERLRC_VERSION + PRODUCTVERSION PERLRC_VERSION + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK + FILEFLAGS VER_DEBUG + FILEOS VOS_NT_WINDOWS32 + FILETYPE VFT_DLL + FILESUBTYPE VFT2_UNKNOWN + +BEGIN +BLOCK "StringFileInfo" + BEGIN + BLOCK "040904E4" + BEGIN + VALUE "CompanyName", "ActiveState\0" + VALUE "FileDescription", "Perl Interpreter\0" + VALUE "FileVersion", PERLFILEVERSION + VALUE "InternalName", "perl58.dll\0" + VALUE "LegalCopyright", "Copyright 1987-2006, Larry Wall, Binary build by ActiveState, http://www.ActiveState.com\0" + VALUE "LegalTrademarks", "\0" + VALUE "OriginalFilename", "perl58.dll\0" + VALUE "ProductName", PERLPRODUCTNAME + VALUE "ProductVersion", PERLPRODUCTVERSION + END + END + + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 0x04E4 + // English language (0x409) and the Windows ANSI codepage (0x04E4) + END +END + diff -ruN perl-5.8.8/win32/perlexe.rc AP816_source/win32/perlexe.rc --- perl-5.8.8/win32/perlexe.rc 2004-01-22 12:56:05.000000000 -0800 +++ AP816_source/win32/perlexe.rc 2006-03-09 21:52:28.000000000 -0800 @@ -1 +1,52 @@ -PERLEXE ICON perlexe.ico +// PerlExe.rc + +// (c) 1995-1999 Microsoft Corporation. All rights reserved. +// Developed by ActiveState Tool Corp., http://www.ActiveState.com + +// You may distribute under the terms of either the GNU General Public +// License or the Artistic License, as specified in the README file. + +#include +#include "BuildInfo.h" + +PERLEXE ICON perl.ico + +#ifndef _DEBUG +#define VER_DEBUG 0 +#else +#define VER_DEBUG VS_FF_DEBUG +#endif + +VS_VERSION_INFO VERSIONINFO + FILEVERSION PERLRC_VERSION + PRODUCTVERSION PERLRC_VERSION + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK + FILEFLAGS VER_DEBUG + FILEOS VOS_NT_WINDOWS32 + FILETYPE VFT_APP + FILESUBTYPE VFT2_UNKNOWN + +BEGIN +BLOCK "StringFileInfo" + BEGIN + BLOCK "040904E4" + BEGIN + VALUE "CompanyName", "ActiveState\0" + VALUE "FileDescription", "Perl Command Line Interpreter\0" + VALUE "FileVersion", PERLFILEVERSION + VALUE "InternalName", "perl.exe\0" + VALUE "LegalCopyright", "Copyright 1987-2006, Larry Wall, Binary build by ActiveState, http://www.ActiveState.com\0" + VALUE "LegalTrademarks", "\0" + VALUE "OriginalFilename", "perl.exe\0" + VALUE "ProductName", PERLPRODUCTNAME + VALUE "ProductVersion", PERLPRODUCTVERSION + END + END + + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 0x04E4 + // English language (0x409) and the Windows ANSI codepage (0x04E4) + END +END + diff -ruN perl-5.8.8/win32/perlhost.h AP816_source/win32/perlhost.h --- perl-5.8.8/win32/perlhost.h 2005-09-22 06:54:48.000000000 -0700 +++ AP816_source/win32/perlhost.h 2006-03-09 21:52:28.000000000 -0800 @@ -1693,6 +1693,7 @@ PerlInterpreter *my_perl = (PerlInterpreter*)arg; GV *tmpgv; int status; + HWND parent_message_hwnd; #ifdef PERL_SYNC_FORK static long sync_fork_id = 0; long id = ++sync_fork_id; @@ -1721,6 +1722,12 @@ } hv_clear(PL_pidstatus); + /* create message window and tell parent about it */ + parent_message_hwnd = w32_message_hwnd; + w32_message_hwnd = win32_create_message_window(); + if (parent_message_hwnd != NULL) + PostMessage(parent_message_hwnd, WM_USER_MESSAGE, w32_pseudo_id, (LONG)w32_message_hwnd); + /* push a zero on the stack (we are the child) */ { dSP; @@ -1824,6 +1831,11 @@ id = win32_start_child((LPVOID)new_perl); PERL_SET_THX(aTHX); # else + if (w32_message_hwnd == INVALID_HANDLE_VALUE) + w32_message_hwnd = win32_create_message_window(); + new_perl->Isys_intern.message_hwnd = w32_message_hwnd; + w32_pseudo_child_message_hwnds[w32_num_pseudo_children] = + (w32_message_hwnd == NULL) ? NULL : INVALID_HANDLE_VALUE; # ifdef USE_RTL_THREAD_API handle = (HANDLE)_beginthreadex((void*)NULL, 0, win32_start_child, (void*)new_perl, 0, (unsigned*)&id); Binary files perl-5.8.8/win32/perl.ico and AP816_source/win32/perl.ico differ diff -ruN perl-5.8.8/win32/win32.c AP816_source/win32/win32.c --- perl-5.8.8/win32/win32.c 2006-01-06 14:28:33.000000000 -0800 +++ AP816_source/win32/win32.c 2006-03-09 21:52:28.000000000 -0800 @@ -15,6 +15,9 @@ #define Win32_Winsock #endif #include +#ifndef HWND_MESSAGE +# define HWND_MESSAGE ((HWND)-3) +#endif /* GCC-2.95.2/Mingw32-1.1 forgot the WINAPI on CommandLineToArgvW() */ #if defined(__MINGW32__) && (__MINGW32_MAJOR_VERSION==1) # include @@ -113,7 +116,7 @@ char w32_module_name[MAX_PATH+1]; END_EXTERN_C -static DWORD w32_platform = (DWORD)-1; +static OSVERSIONINFO g_osver = {0, 0, 0, 0, 0, ""}; #define ONE_K_BUFSIZE 1024 @@ -130,13 +133,13 @@ int IsWin95(void) { - return (win32_os_id() == VER_PLATFORM_WIN32_WINDOWS); + return (g_osver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS); } int IsWinNT(void) { - return (win32_os_id() == VER_PLATFORM_WIN32_NT); + return (g_osver.dwPlatformId == VER_PLATFORM_WIN32_NT); } EXTERN_C void @@ -426,15 +429,7 @@ DllExport unsigned long win32_os_id(void) { - static OSVERSIONINFO osver; - - if (osver.dwPlatformId != w32_platform) { - memset(&osver, 0, sizeof(OSVERSIONINFO)); - osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); - GetVersionEx(&osver); - w32_platform = osver.dwPlatformId; - } - return (unsigned long)w32_platform; + return (unsigned long)g_osver.dwPlatformId; } DllExport int @@ -1071,6 +1066,8 @@ (w32_num_pseudo_children-child-1), HANDLE); Move(&w32_pseudo_child_pids[child+1], &w32_pseudo_child_pids[child], (w32_num_pseudo_children-child-1), DWORD); + Move(&w32_pseudo_child_message_hwnds[child+1], &w32_pseudo_child_message_hwnds[child], + (w32_num_pseudo_children-child-1), HWND); w32_num_pseudo_children--; } } @@ -1088,11 +1085,13 @@ /* it is a pseudo-forked child */ child = find_pseudo_pid(-pid); if (child >= 0) { + HWND hwnd = w32_pseudo_child_message_hwnds[child]; hProcess = w32_pseudo_child_handles[child]; switch (sig) { case 0: /* "Does process exist?" use of kill */ return 0; + case 9: /* kill -9 style un-graceful exit */ if (TerminateThread(hProcess, sig)) { @@ -1100,16 +1099,30 @@ return 0; } break; - default: - /* We fake signals to pseudo-processes using Win32 - * message queue. In Win9X the pids are negative already. */ - if (PostThreadMessage(IsWin95() ? pid : -pid,WM_USER,sig,0)) { - /* It might be us ... */ - PERL_ASYNC_CHECK(); - return 0; - } + + default: { + int count = 0; + /* pseudo-process has not yet properly initialized if hwnd isn't set */ + while (hwnd == INVALID_HANDLE_VALUE && count < 5) { + /* Yield and wait for the other thread to send us its message_hwnd */ + Sleep(0); + win32_async_check(aTHX); + ++count; + } + if (hwnd != INVALID_HANDLE_VALUE) { + /* We fake signals to pseudo-processes using Win32 + * message queue. In Win9X the pids are negative already. */ + if ((hwnd != NULL && PostMessage(hwnd, WM_USER_KILL, sig, 0)) || + PostThreadMessage(IsWin95() ? pid : -pid, WM_USER_KILL, sig, 0)) + { + /* It might be us ... */ + PERL_ASYNC_CHECK(); + return 0; + } + } break; } + } /* switch */ } else if (IsWin95()) { pid = -pid; @@ -1191,21 +1204,31 @@ WCHAR* pwbuffer; HANDLE handle; int nlink = 1; + BOOL expect_dir = FALSE; if (l > 1) { switch(path[l - 1]) { /* FindFirstFile() and stat() are buggy with a trailing - * backslash, so change it to a forward slash :-( */ + * slashes, except for the root directory of a drive */ case '\\': - if (l >= sizeof(buffer)) { + case '/': + if (l > sizeof(buffer)) { errno = ENAMETOOLONG; return -1; } - strncpy(buffer, path, l-1); - buffer[l - 1] = '/'; - buffer[l] = '\0'; - path = buffer; + --l; + strncpy(buffer, path, l); + /* remove additional trailing slashes */ + while (l > 1 && (buffer[l-1] == '/' || buffer[l-1] == '\\')) + --l; + /* add back slash if we otherwise end up with just a drive letter */ + if (l == 2 && isALPHA(buffer[0]) && buffer[1] == ':') + buffer[l++] = '\\'; + buffer[l] = '\0'; + path = buffer; + expect_dir = TRUE; break; + /* FindFirstFile() is buggy with "x:", so add a dot :-( */ case ':': if (l == 2 && isALPHA(path[0])) { @@ -1291,6 +1314,10 @@ return -1; } } + if (expect_dir && !S_ISDIR(sbuf->st_mode)) { + errno = ENOTDIR; + return -1; + } #ifdef __BORLANDC__ if (S_ISDIR(sbuf->st_mode)) sbuf->st_mode |= S_IWRITE | S_IEXEC; @@ -1716,44 +1743,34 @@ { struct hostent *hep; STRLEN nodemax = sizeof(name->nodename)-1; - OSVERSIONINFO osver; - - memset(&osver, 0, sizeof(OSVERSIONINFO)); - osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); - if (GetVersionEx(&osver)) { - /* sysname */ - switch (osver.dwPlatformId) { - case VER_PLATFORM_WIN32_WINDOWS: - strcpy(name->sysname, "Windows"); - break; - case VER_PLATFORM_WIN32_NT: - strcpy(name->sysname, "Windows NT"); - break; - case VER_PLATFORM_WIN32s: - strcpy(name->sysname, "Win32s"); - break; - default: - strcpy(name->sysname, "Win32 Unknown"); - break; - } - /* release */ - sprintf(name->release, "%d.%d", - osver.dwMajorVersion, osver.dwMinorVersion); - - /* version */ - sprintf(name->version, "Build %d", - osver.dwPlatformId == VER_PLATFORM_WIN32_NT - ? osver.dwBuildNumber : (osver.dwBuildNumber & 0xffff)); - if (osver.szCSDVersion[0]) { - char *buf = name->version + strlen(name->version); - sprintf(buf, " (%s)", osver.szCSDVersion); - } + /* sysname */ + switch (g_osver.dwPlatformId) { + case VER_PLATFORM_WIN32_WINDOWS: + strcpy(name->sysname, "Windows"); + break; + case VER_PLATFORM_WIN32_NT: + strcpy(name->sysname, "Windows NT"); + break; + case VER_PLATFORM_WIN32s: + strcpy(name->sysname, "Win32s"); + break; + default: + strcpy(name->sysname, "Win32 Unknown"); + break; } - else { - *name->sysname = '\0'; - *name->version = '\0'; - *name->release = '\0'; + + /* release */ + sprintf(name->release, "%d.%d", + g_osver.dwMajorVersion, g_osver.dwMinorVersion); + + /* version */ + sprintf(name->version, "Build %d", + g_osver.dwPlatformId == VER_PLATFORM_WIN32_NT + ? g_osver.dwBuildNumber : (g_osver.dwBuildNumber & 0xffff)); + if (g_osver.szCSDVersion[0]) { + char *buf = name->version + strlen(name->version); + sprintf(buf, " (%s)", g_osver.szCSDVersion); } /* nodename */ @@ -1888,65 +1905,60 @@ win32_async_check(pTHX) { MSG msg; - int ours = 1; + HWND hwnd = w32_message_hwnd; + + w32_poll_count = 0; + + if (hwnd == INVALID_HANDLE_VALUE) + return 1; + /* Passing PeekMessage -1 as HWND (2nd arg) only get PostThreadMessage() messages * and ignores window messages - should co-exist better with windows apps e.g. Tk */ - while (PeekMessage(&msg, (HWND)-1, 0, 0, PM_REMOVE|PM_NOYIELD)) { - int sig; - switch(msg.message) { + if (hwnd == NULL) + hwnd = (HWND)-1; -#if 0 - /* Perhaps some other messages could map to signals ? ... */ - case WM_CLOSE: - case WM_QUIT: - /* Treat WM_QUIT like SIGHUP? */ - sig = SIGHUP; - goto Raise; - break; + while (PeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE|PM_NOYIELD) || + PeekMessage(&msg, hwnd, WM_USER_MIN, WM_USER_MAX, PM_REMOVE|PM_NOYIELD)) + { + switch (msg.message) { +#ifdef USE_ITHREADS + case WM_USER_MESSAGE: { + int child = find_pseudo_pid(msg.wParam); + if (child >= 0) + w32_pseudo_child_message_hwnds[child] = (HWND)msg.lParam; + break; + } #endif - /* We use WM_USER to fake kill() with other signals */ - case WM_USER: { - sig = msg.wParam; - Raise: - if (do_raise(aTHX_ sig)) { - sig_terminate(aTHX_ sig); - } + case WM_USER_KILL: { + /* We use WM_USER to fake kill() with other signals */ + int sig = msg.wParam; + if (do_raise(aTHX_ sig)) + sig_terminate(aTHX_ sig); break; } case WM_TIMER: { /* alarm() is a one-shot but SetTimer() repeats so kill it */ if (w32_timerid && w32_timerid==msg.wParam) { - KillTimer(NULL,w32_timerid); + KillTimer(w32_message_hwnd, w32_timerid); w32_timerid=0; - } - else - goto FallThrough; - /* Now fake a call to signal handler */ - if (do_raise(aTHX_ 14)) { - sig_terminate(aTHX_ 14); - } - break; - } - /* Otherwise do normal Win32 thing - in case it is useful */ - default: - FallThrough: - TranslateMessage(&msg); - DispatchMessage(&msg); - ours = 0; + /* Now fake a call to signal handler */ + if (do_raise(aTHX_ 14)) + sig_terminate(aTHX_ 14); + } break; } + } /* switch */ } - w32_poll_count = 0; /* Above or other stuff may have set a signal flag */ if (PL_sig_pending) { despatch_signals(); } - return ours; + return 1; } /* This function will not return until the timeout has elapsed, or until @@ -2159,13 +2171,22 @@ * one of the supported codes in */ dTHX; + + if (w32_message_hwnd == INVALID_HANDLE_VALUE) + w32_message_hwnd = win32_create_message_window(); + if (sec) { - w32_timerid = SetTimer(NULL,w32_timerid,sec*1000,NULL); + if (w32_message_hwnd == NULL) + w32_timerid = SetTimer(NULL, w32_timerid, sec*1000, NULL); + else { + w32_timerid = 1; + SetTimer(w32_message_hwnd, w32_timerid, sec*1000, NULL); + } } else { if (w32_timerid) { - KillTimer(NULL,w32_timerid); - w32_timerid=0; + KillTimer(w32_message_hwnd, w32_timerid); + w32_timerid = 0; } } return 0; @@ -4426,6 +4447,13 @@ */ static +XS(w32_BuildNumber) +{ + dXSARGS; + XSRETURN_PV(PRODUCT_BUILD_NUMBER); +} + +static XS(w32_SetChildShowWindow) { dXSARGS; @@ -5000,6 +5028,7 @@ newXS("Win32::GetLongPathName", w32_GetLongPathName, file); newXS("Win32::CopyFile", w32_CopyFile, file); newXS("Win32::Sleep", w32_Sleep, file); + newXS("Win32::BuildNumber", w32_BuildNumber, file); newXS("Win32::SetChildShowWindow", w32_SetChildShowWindow, file); /* XXX Bloat Alert! The following Activeware preloads really @@ -5155,10 +5184,33 @@ /* Does nothing */ } +HWND +win32_create_message_window() +{ + /* "message-only" windows have been implemented in Windows 2000 and later. + * On earlier versions we'll continue to post messages to a specific + * thread and use hwnd==NULL. This is brittle when either an embedding + * application or an XS module is also posting messages to hwnd=NULL + * because once removed from the queue they cannot be delivered to the + * "right" place with DispatchMessage() anymore, as there is no WindowProc + * if there is no window handle. + */ + if (g_osver.dwMajorVersion < 5) + return NULL; + + return CreateWindow("Static", "", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, 0, NULL); +} + void Perl_sys_intern_init(pTHX) { int i; + + if (g_osver.dwOSVersionInfoSize == 0) { + g_osver.dwOSVersionInfoSize = sizeof(g_osver); + GetVersionEx(&g_osver); + } + w32_perlshell_tokens = Nullch; w32_perlshell_vec = (char**)NULL; w32_perlshell_items = 0; @@ -5167,11 +5219,12 @@ w32_num_children = 0; # ifdef USE_ITHREADS w32_pseudo_id = 0; - Newx(w32_pseudo_children, 1, child_tab); + Newx(w32_pseudo_children, 1, pseudo_child_tab); w32_num_pseudo_children = 0; # endif w32_init_socktype = 0; w32_timerid = 0; + w32_message_hwnd = INVALID_HANDLE_VALUE; w32_poll_count = 0; for (i=0; i < SIG_SIZE; i++) { w32_sighandler[i] = SIG_DFL; @@ -5197,9 +5250,11 @@ /* NOTE: w32_fdpid is freed by sv_clean_all() */ Safefree(w32_children); if (w32_timerid) { - KillTimer(NULL,w32_timerid); - w32_timerid=0; + KillTimer(w32_message_hwnd, w32_timerid); + w32_timerid = 0; } + if (w32_message_hwnd != NULL && w32_message_hwnd != INVALID_HANDLE_VALUE) + DestroyWindow(w32_message_hwnd); # ifdef MULTIPLICITY if (my_perl == PL_curinterp) { # else @@ -5223,9 +5278,10 @@ dst->fdpid = newAV(); Newxz(dst->children, 1, child_tab); dst->pseudo_id = 0; - Newxz(dst->pseudo_children, 1, child_tab); + Newxz(dst->pseudo_children, 1, pseudo_child_tab); dst->thr_intern.Winit_socktype = 0; dst->timerid = 0; + dst->message_hwnd = INVALID_HANDLE_VALUE; dst->poll_count = 0; Copy(src->sigtable,dst->sigtable,SIG_SIZE,Sighandler_t); } diff -ruN perl-5.8.8/win32/win32.h AP816_source/win32/win32.h --- perl-5.8.8/win32/win32.h 2006-01-06 15:36:03.000000000 -0800 +++ AP816_source/win32/win32.h 2006-03-09 21:52:28.000000000 -0800 @@ -9,6 +9,8 @@ #ifndef _INC_WIN32_PERL5 #define _INC_WIN32_PERL5 +#include "BuildInfo.h" + #ifndef _WIN32_WINNT # define _WIN32_WINNT 0x0400 /* needed for TryEnterCriticalSection() etc. */ #endif @@ -315,6 +317,7 @@ } child_IO_table; DllExport void win32_get_child_IO(child_IO_table* ptr); +DllExport HWND win32_create_message_window(); #ifndef USE_SOCKETS_AS_HANDLES extern FILE * my_fdopen(int, char *); @@ -364,6 +367,16 @@ * Now Win32 specific per-thread data stuff */ +/* Leave the first couple ids after WM_USER unused because they + * might be used by an embedding application, and on Windows + * version before 2000 we might end up eating those messages + * if they were not meant for us. + */ +#define WM_USER_MIN (WM_USER+30) +#define WM_USER_MESSAGE (WM_USER_MIN) +#define WM_USER_KILL (WM_USER_MIN+1) +#define WM_USER_MAX (WM_USER_MIN+1) + struct thread_intern { /* XXX can probably use one buffer instead of several */ char Wstrerror_buffer[512]; @@ -395,6 +408,15 @@ HANDLE handles[MAXIMUM_WAIT_OBJECTS]; } child_tab; +#ifdef USE_ITHREADS +typedef struct { + long num; + DWORD pids[MAXIMUM_WAIT_OBJECTS]; + HANDLE handles[MAXIMUM_WAIT_OBJECTS]; + HWND message_hwnds[MAXIMUM_WAIT_OBJECTS]; +} pseudo_child_tab; +#endif + #ifndef Sighandler_t typedef Signal_t (*Sighandler_t) (int); #define Sighandler_t Sighandler_t @@ -408,12 +430,13 @@ child_tab * children; #ifdef USE_ITHREADS DWORD pseudo_id; - child_tab * pseudo_children; + pseudo_child_tab * pseudo_children; #endif void * internal_host; #ifndef USE_5005THREADS struct thread_intern thr_intern; #endif + HWND message_hwnd; UINT timerid; unsigned poll_count; Sighandler_t sigtable[SIG_SIZE]; @@ -437,8 +460,10 @@ #define w32_num_pseudo_children (w32_pseudo_children->num) #define w32_pseudo_child_pids (w32_pseudo_children->pids) #define w32_pseudo_child_handles (w32_pseudo_children->handles) +#define w32_pseudo_child_message_hwnds (w32_pseudo_children->message_hwnds) #define w32_internal_host (PL_sys_intern.internal_host) #define w32_timerid (PL_sys_intern.timerid) +#define w32_message_hwnd (PL_sys_intern.message_hwnd) #define w32_sighandler (PL_sys_intern.sigtable) #define w32_poll_count (PL_sys_intern.poll_count) #define w32_do_async (w32_poll_count++ > WIN32_POLL_INTERVAL) diff -ruN perl-5.8.8/XSUB.h AP816_source/XSUB.h --- perl-5.8.8/XSUB.h 2006-01-02 06:45:29.000000000 -0800 +++ AP816_source/XSUB.h 2006-03-09 21:52:22.000000000 -0800 @@ -91,7 +91,7 @@ #if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING) # define XS(name) __declspec(dllexport) void name(pTHX_ CV* cv) #else -# ifdef HASATTRIBUTE_UNUSED +# if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus) # define XS(name) void name(pTHX_ CV* cv __attribute__unused__) # else # define XS(name) void name(pTHX_ CV* cv) End of Patch.