perl5.005_03

8 files changed, 5660 insertions, 0 deletions

diff --git a/gnu/usr.bin/perl/win32/GenCAPI.pl b/gnu/usr.bin/perl/win32/GenCAPI.pl
new file mode 100644
index 00000000000..c2ff67df8aa
--- /dev/null
+++ b/gnu/usr.bin/perl/win32/GenCAPI.pl
@@ -0,0 +1,1616 @@
+
+# creates a C API file from proto.h
+# takes one argument, the path to lib/CORE directory.
+# creates 2 files: "perlCAPI.cpp" and "perlCAPI.h".
+
+#use Config;
+
+my $hdrfile = "$ARGV[0]\\perlCAPI.h";
+my $infile = '..\\proto.h';
+my $embedfile = '..\\embed.h';
+my $separateObj = 0;
+
+my %skip_list;
+my %embed;
+
+sub readembed(\%$) {
+    my ($syms, $file) = @_;
+    my ($line, @words);
+    %$syms = ();
+    local (*FILE, $_);
+    open(FILE, "< $file")
+	or die "$0: Can't open $file: $!\n";
+    while ($line = <FILE>) {
+	chop($line);
+	if ($line =~ /^#define\s+\w+/) {
+	    $line =~ s/^#define\s+//;
+	    @words = split ' ', $line;
+#	    print "$words[0]\t$words[1]\n";
+	    $$syms{$words[0]} = $words[1];
+	}
+    }
+    close(FILE);
+}
+
+readembed %embed, $embedfile;
+
+sub skip_these {
+    my $list = shift;
+    foreach my $symbol (@$list) {
+	$skip_list{$symbol} = 1;
+    }
+}
+
+skip_these [qw(
+cando
+cast_ulong
+my_chsize
+condpair_magic
+deb
+deb_growlevel
+debprofdump
+debop
+debstack
+debstackptrs
+dump_fds
+dump_mstats
+fprintf
+find_threadsv
+magic_mutexfree
+my_memcmp
+my_memset
+my_pclose
+my_popen
+my_swap
+my_htonl
+my_ntohl
+new_struct_thread
+same_dirent
+unlnk
+unlock_condpair
+safexmalloc
+safexcalloc
+safexrealloc
+safexfree
+Perl_GetVars
+malloced_size
+)];
+
+
+
+if (!open(INFILE, "<$infile")) {
+    print "open of $infile failed: $!\n";
+    return 1;
+}
+
+if (!open(OUTFILE, ">perlCAPI.cpp")) {
+    print "open of perlCAPI.cpp failed: $!\n";
+    return 1;
+}
+
+print OUTFILE <<ENDCODE;
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+  
+#define DESTRUCTORFUNC (void (*)(void*))
+  
+ENDCODE
+
+print OUTFILE "#ifdef SetCPerlObj_defined\n" unless ($separateObj == 0);
+
+print OUTFILE <<ENDCODE;
+EXTERN_C void SetCPerlObj(void *pP)
+{
+    pPerl = (CPerlObj*)pP;
+}
+  
+ENDCODE
+
+print OUTFILE "#endif\n" unless ($separateObj == 0); 
+
+while () {
+    last unless defined ($_ = <INFILE>);
+    if (/^VIRTUAL\s/) {
+        while (!/;$/) {
+            chomp;
+            $_ .= <INFILE>;
+        }
+        $_ =~ s/^VIRTUAL\s*//;
+        $_ =~ s/\s*__attribute__.*$/;/;
+        if ( /(.*)\s([A-z_]*[0-9A-z_]+\s)_\(\((.*)\)\);/ ||
+             /(.*)\*([A-z_]*[0-9A-z_]+\s)_\(\((.*)\)\);/ ) {
+            $type = $1;
+            $name = $2;
+            $args = $3;
+ 
+            $name =~ s/\s*$//;
+            $type =~ s/\s*$//;
+	    next if (defined $skip_list{$name});
+
+	    if($args eq "ARGSproto") {
+		$args = "void";
+	    }
+
+            $return = ($type eq "void" or $type eq "Free_t") ? "\t" : "\treturn";
+
+	    if(defined $embed{$name}) {
+		$funcName = $embed{$name};
+	    } else {
+		$funcName = $name;
+	    }
+
+            @args = split(',', $args);
+            if ($args[$#args] =~ /\s*\.\.\.\s*/) {
+                if(($name eq "croak") or ($name eq "deb") or ($name eq "die")
+		        or ($name eq "form") or ($name eq "warn")) {
+                    print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
+                    $args[0] =~ /(\w+)\W*$/; 
+                    $arg = $1;
+                    print OUTFILE <<ENDCODE;
+
+#undef $name
+EXTERN_C $type $funcName ($args)
+{
+    char *pstr;
+    char *pmsg;
+    va_list args;
+    va_start(args, $arg);
+    pmsg = pPerl->Perl_mess($arg, &args);
+    New(0, pstr, strlen(pmsg)+1, char);
+    strcpy(pstr, pmsg);
+$return pPerl->Perl_$name(pstr);
+    va_end(args);
+}
+ENDCODE
+                    print OUTFILE "#endif\n" unless ($separateObj == 0);
+                }
+                elsif($name eq "newSVpvf") {
+                    print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
+                    $args[0] =~ /(\w+)\W*$/; 
+                    $arg = $1;
+                    print OUTFILE <<ENDCODE;
+
+#undef $name
+EXTERN_C $type $funcName ($args)
+{
+    SV *sv;
+    va_list args;
+    va_start(args, $arg);
+    sv = pPerl->Perl_newSV(0);
+    pPerl->Perl_sv_vcatpvfn(sv, $arg, strlen($arg), &args, NULL, 0, NULL);
+    va_end(args);
+    return sv;
+}
+ENDCODE
+                    print OUTFILE "#endif\n" unless ($separateObj == 0);
+                }
+                elsif($name eq "sv_catpvf") {
+                    print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
+                    $args[0] =~ /(\w+)\W*$/; 
+                    $arg0 = $1;
+                    $args[1] =~ /(\w+)\W*$/; 
+                    $arg1 = $1;
+                    print OUTFILE <<ENDCODE;
+
+#undef $name
+EXTERN_C $type $funcName ($args)
+{
+    va_list args;
+    va_start(args, $arg1);
+    pPerl->Perl_sv_vcatpvfn($arg0, $arg1, strlen($arg1), &args, NULL, 0, NULL);
+    va_end(args);
+}
+ENDCODE
+                    print OUTFILE "#endif\n" unless ($separateObj == 0);
+                }
+                elsif($name eq "sv_catpvf_mg") {
+                    print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
+                    $args[0] =~ /(\w+)\W*$/; 
+                    $arg0 = $1;
+                    $args[1] =~ /(\w+)\W*$/; 
+                    $arg1 = $1;
+                    print OUTFILE <<ENDCODE;
+
+#undef $name
+#ifndef mg_set
+#define mg_set pPerl->Perl_mg_set
+#endif
+EXTERN_C $type $funcName ($args)
+{
+    va_list args;
+    va_start(args, $arg1);
+    pPerl->Perl_sv_vcatpvfn($arg0, $arg1, strlen($arg1), &args, NULL, 0, NULL);
+    va_end(args);
+    SvSETMAGIC(sv);
+}
+ENDCODE
+                    print OUTFILE "#endif\n" unless ($separateObj == 0);
+                }
+                elsif($name eq "sv_setpvf") {
+                    print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
+                    $args[0] =~ /(\w+)\W*$/; 
+                    $arg0 = $1;
+                    $args[1] =~ /(\w+)\W*$/; 
+                    $arg1 = $1;
+                    print OUTFILE <<ENDCODE;
+
+#undef $name
+EXTERN_C $type $funcName ($args)
+{
+    va_list args;
+    va_start(args, $arg1);
+    pPerl->Perl_sv_vsetpvfn($arg0, $arg1, strlen($arg1), &args, NULL, 0, NULL);
+    va_end(args);
+}
+ENDCODE
+                    print OUTFILE "#endif\n" unless ($separateObj == 0);
+                }
+                elsif($name eq "sv_setpvf_mg") {
+                    print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
+                    $args[0] =~ /(\w+)\W*$/; 
+                    $arg0 = $1;
+                    $args[1] =~ /(\w+)\W*$/; 
+                    $arg1 = $1;
+                    print OUTFILE <<ENDCODE;
+
+#undef $name
+#ifndef mg_set
+#define mg_set pPerl->Perl_mg_set
+#endif
+EXTERN_C $type $funcName ($args)
+{
+    va_list args;
+    va_start(args, $arg1);
+    pPerl->Perl_sv_vsetpvfn($arg0, $arg1, strlen($arg1), &args, NULL, 0, NULL);
+    va_end(args);
+    SvSETMAGIC(sv);
+}
+ENDCODE
+                    print OUTFILE "#endif\n" unless ($separateObj == 0);
+                }
+                elsif($name eq "fprintf") {
+                    print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
+                    $args[0] =~ /(\w+)\W*$/; 
+                    $arg0 = $1;
+                    $args[1] =~ /(\w+)\W*$/; 
+                    $arg1 = $1;
+                    print OUTFILE <<ENDCODE;
+
+#undef $name
+EXTERN_C $type $name ($args)
+{
+    int nRet;
+    va_list args;
+    va_start(args, $arg1);
+    nRet = PerlIO_vprintf($arg0, $arg1, args);
+    va_end(args);
+    return nRet;
+}
+ENDCODE
+                    print OUTFILE "#endif\n" unless ($separateObj == 0);
+                } else {
+                    print "Warning: can't handle varargs function '$name'\n";
+                }
+                next;
+            }
+
+	    # newXS special case
+	    if ($name eq "newXS") {
+		next;
+	    }
+            
+            print OUTFILE "\n#ifdef $name" . "defined" unless ($separateObj == 0);
+
+	    # handle specical case for save_destructor
+	    if ($name eq "save_destructor") {
+		next;
+	    }
+	    # handle specical case for sighandler
+	    if ($name eq "sighandler") {
+		next;
+	    }
+	    # handle special case for sv_grow
+	    if ($name eq "sv_grow" and $args eq "SV* sv, unsigned long newlen") {
+		next;
+	    }
+	    # handle special case for newSV
+	    if ($name eq "newSV" and $args eq "I32 x, STRLEN len") {
+		next;
+	    }
+	    # handle special case for perl_parse
+	    if ($name eq "perl_parse") {
+		print OUTFILE <<ENDCODE;
+
+#undef $name
+EXTERN_C $type $name ($args)
+{
+    return pPerl->perl_parse(xsinit, argc, argv, env);
+}
+ENDCODE
+                print OUTFILE "#endif\n" unless ($separateObj == 0);
+		next;
+	    }
+	    # handle special case for perl_atexit
+	    if ($name eq "perl_atexit") {
+		print OUTFILE <<ENDCODE;
+
+#undef $name
+EXTERN_C $type $name ($args)
+{
+    pPerl->perl_atexit(fn, ptr);
+}
+ENDCODE
+                print OUTFILE "#endif\n" unless ($separateObj == 0);
+		next;
+	    }
+
+
+	    if($name eq "byterun" and $args eq "struct bytestream bs") {
+		next;
+	    }
+
+            # foo(void);
+            if ($args eq "void") {
+                print OUTFILE <<ENDCODE;
+
+#undef $name
+EXTERN_C $type $funcName ()
+{
+$return pPerl->$funcName();
+}
+
+ENDCODE
+                print OUTFILE "#endif\n" unless ($separateObj == 0);
+                next;
+            }
+
+            # foo(char *s, const int bar);
+            print OUTFILE <<ENDCODE;
+
+#undef $name
+EXTERN_C $type $funcName ($args)
+{
+ENDCODE
+	    print OUTFILE "$return pPerl->$funcName";
+            $doneone = 0;
+            foreach $arg (@args) {
+                if ($arg =~ /(\w+)\W*$/) {
+                    if ($doneone) {
+                        print OUTFILE ", $1";
+                    }
+                    else {
+                        print OUTFILE "($1";
+                        $doneone++;
+                    }
+                }
+            }
+            print OUTFILE ");\n}\n";
+            print OUTFILE "#endif\n" unless ($separateObj == 0);
+        }
+        else {
+            print "failed to match $_";
+        }
+    }
+}
+
+close INFILE;
+
+%skip_list = ();
+
+skip_these [qw(
+strchop
+filemode
+lastfd
+oldname
+curinterp
+Argv
+Cmd
+sortcop
+sortstash
+firstgv
+secondgv
+sortstack
+signalstack
+mystrk
+dumplvl
+oldlastpm
+gensym
+preambled
+preambleav
+Ilaststatval
+Ilaststype
+mess_sv
+ors
+opsave
+eval_mutex
+strtab_mutex
+orslen
+ofmt
+modcount
+generation
+DBcv
+archpat_auto
+sortcxix
+lastgotoprobe
+regdummy
+regcomp_parse
+regxend
+regcode
+regnaughty
+regsawback
+regprecomp
+regnpar
+regsize
+regflags
+regseen
+seen_zerolen
+regcomp_rx
+extralen
+colorset
+colors
+reginput
+regbol
+regeol
+regstartp
+regendp
+reglastparen
+regtill
+regprev
+reg_start_tmp
+reg_start_tmpl
+regdata
+bostr
+reg_flags
+reg_eval_set
+regnarrate
+regprogram
+regindent
+regcc
+in_clean_objs
+in_clean_all
+linestart
+pending_ident
+statusvalue_vms
+sublex_info
+thrsv
+threadnum
+PL_piMem
+PL_piENV
+PL_piStdIO
+PL_piLIO
+PL_piDir
+PL_piSock
+PL_piProc
+cshname
+threadsv_names
+thread
+nthreads
+thr_key
+threads_mutex
+malloc_mutex
+svref_mutex
+sv_mutex
+cred_mutex
+nthreads_cond
+eval_cond
+cryptseen
+cshlen
+)];
+
+sub readvars(\%$$) {
+    my ($syms, $file, $pre) = @_;
+    %$syms = ();
+    local (*FILE, $_);
+    open(FILE, "< $file")
+	or die "$0: Can't open $file: $!\n";
+    while (<FILE>) {
+	s/[ \t]*#.*//;		# Delete comments.
+	if (/PERLVARI?C?\($pre(\w+),\s*([^,)]+)/) {
+	    $$syms{$1} = $2;
+	}
+    }
+    close(FILE);
+}
+
+my %intrp;
+my %thread;
+my %globvar;
+
+readvars %intrp,  '..\intrpvar.h','I';
+readvars %thread, '..\thrdvar.h','T';
+readvars %globvar, '..\perlvars.h','G';
+
+open(HDRFILE, ">$hdrfile") or die "$0: Can't open $hdrfile: $!\n";
+print HDRFILE <<ENDCODE;
+EXTERN_C void SetCPerlObj(void* pP);
+EXTERN_C CV* Perl_newXS(char* name, void (*subaddr)(CV* cv), char* filename);
+
+ENDCODE
+
+sub DoVariable($$) {
+    my $name = shift;
+    my $type = shift;
+
+    return if (defined $skip_list{$name});
+    return if ($type eq 'struct perl_thread *');
+
+    print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
+    print OUTFILE <<ENDCODE;
+#undef PL_$name
+EXTERN_C $type * _PL_$name ()
+{
+    return (($type *)&pPerl->PL_$name);
+}
+
+ENDCODE
+
+    print OUTFILE "#endif\n" unless ($separateObj == 0);
+
+    print HDRFILE <<ENDCODE;
+
+#undef PL_$name
+EXTERN_C $type * _PL_$name ();
+#define PL_$name (*_PL_$name())
+
+ENDCODE
+
+}
+
+foreach $key (keys %intrp) {
+    DoVariable ($key, $intrp{$key});
+}
+
+foreach $key (keys %thread) {
+    DoVariable ($key, $thread{$key});
+}
+
+foreach $key (keys %globvar) {
+    DoVariable ($key, $globvar{$key});
+}
+
+print OUTFILE <<EOCODE;
+
+START_EXTERN_C
+
+char **	_Perl_op_desc(void)
+{
+    return pPerl->Perl_get_op_descs();
+}
+
+char **	_Perl_op_name(void)
+{
+    return pPerl->Perl_get_op_names();
+}
+
+char *	_Perl_no_modify(void)
+{
+    return pPerl->Perl_get_no_modify();
+}
+
+U32 *	_Perl_opargs(void)
+{
+    return pPerl->Perl_get_opargs();
+}
+
+void xs_handler(CV* cv, CPerlObj* p)
+{
+#ifndef NO_XSLOCKS
+    XSLock localLock(p);
+#endif
+    void(*func)(CV*);
+    SV* sv;
+    MAGIC* m = pPerl->Perl_mg_find((SV*)cv, '~');
+    if(m != NULL)
+    {
+	sv = m->mg_obj;
+	if(SvIOK(sv))
+	{
+	    func = (void(*)(CV*))SvIVX(sv);
+	}
+	else
+	{
+	    func = (void(*)(CV*))pPerl->Perl_sv_2iv(sv);
+	}
+	func(cv);
+    }
+}
+
+EXTERN_C CV* Perl_newXS(char* name, void (*subaddr)(CV* cv), char* filename)
+{
+    CV* cv = pPerl->Perl_newXS(name, xs_handler, filename);
+    pPerl->Perl_sv_magic((SV*)cv, pPerl->Perl_sv_2mortal(pPerl->Perl_newSViv((IV)subaddr)), '~', "CAPI", 4);
+    return cv;
+}
+
+
+void Perl_deb(const char pat, ...)
+{
+}
+
+#undef PL_piMem
+#undef PL_piENV
+#undef PL_piStdIO
+#undef PL_piLIO
+#undef PL_piDir
+#undef PL_piSock
+#undef PL_piProc
+
+int *        _win32_errno(void)
+{
+    return &pPerl->ErrorNo();
+}
+
+FILE*        _win32_stdin(void)
+{
+    return (FILE*)pPerl->PL_piStdIO->Stdin();
+}
+
+FILE*        _win32_stdout(void)
+{
+    return (FILE*)pPerl->PL_piStdIO->Stdout();
+}
+
+FILE*        _win32_stderr(void)
+{
+    return (FILE*)pPerl->PL_piStdIO->Stderr();
+}
+
+int          _win32_ferror(FILE *fp)
+{
+    return pPerl->PL_piStdIO->Error((PerlIO*)fp, ErrorNo());
+}
+
+int          _win32_feof(FILE *fp)
+{
+    return pPerl->PL_piStdIO->Eof((PerlIO*)fp, ErrorNo());
+}
+
+char*	     _win32_strerror(int e)
+{
+    return strerror(e);
+}
+
+void	     _win32_perror(const char *str)
+{
+    perror(str);
+}
+
+int          _win32_vfprintf(FILE *pf, const char *format, va_list arg)
+{
+    return pPerl->PL_piStdIO->Vprintf((PerlIO*)pf, ErrorNo(), format, arg);
+}
+
+int          _win32_vprintf(const char *format, va_list arg)
+{
+    return pPerl->PL_piStdIO->Vprintf(pPerl->PL_piStdIO->Stdout(), ErrorNo(), format, arg);
+}
+
+int          _win32_fprintf(FILE *pf, const char *format, ...)
+{
+    int ret;
+    va_list args;
+    va_start(args, format);
+    ret = _win32_vfprintf(pf, format, args);
+    va_end(args);
+    return ret;
+}
+
+int          _win32_printf(const char *format, ...)
+{
+    int ret;
+    va_list args;
+    va_start(args, format);
+    ret = _win32_vprintf(format, args);
+    va_end(args);
+    return ret;
+}
+
+size_t       _win32_fread(void *buf, size_t size, size_t count, FILE *pf)
+{
+    return pPerl->PL_piStdIO->Read((PerlIO*)pf, buf, (size*count), ErrorNo());
+}
+
+size_t       _win32_fwrite(const void *buf, size_t size, size_t count, FILE *pf)
+{
+    return pPerl->PL_piStdIO->Write((PerlIO*)pf, buf, (size*count), ErrorNo());
+}
+
+FILE*        _win32_fopen(const char *path, const char *mode)
+{
+    return (FILE*)pPerl->PL_piStdIO->Open(path, mode, ErrorNo());
+}
+
+FILE*        _win32_fdopen(int fh, const char *mode)
+{
+    return (FILE*)pPerl->PL_piStdIO->Fdopen(fh, mode, ErrorNo());
+}
+
+FILE*        _win32_freopen(const char *path, const char *mode, FILE *pf)
+{
+    return (FILE*)pPerl->PL_piStdIO->Reopen(path, mode, (PerlIO*)pf, ErrorNo());
+}
+
+int          _win32_fclose(FILE *pf)
+{
+    return pPerl->PL_piStdIO->Close((PerlIO*)pf, ErrorNo());
+}
+
+int          _win32_fputs(const char *s,FILE *pf)
+{
+    return pPerl->PL_piStdIO->Puts((PerlIO*)pf, s, ErrorNo());
+}
+
+int          _win32_fputc(int c,FILE *pf)
+{
+    return pPerl->PL_piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
+}
+
+int          _win32_ungetc(int c,FILE *pf)
+{
+    return pPerl->PL_piStdIO->Ungetc((PerlIO*)pf, c, ErrorNo());
+}
+
+int          _win32_getc(FILE *pf)
+{
+    return pPerl->PL_piStdIO->Getc((PerlIO*)pf, ErrorNo());
+}
+
+int          _win32_fileno(FILE *pf)
+{
+    return pPerl->PL_piStdIO->Fileno((PerlIO*)pf, ErrorNo());
+}
+
+void         _win32_clearerr(FILE *pf)
+{
+    pPerl->PL_piStdIO->Clearerr((PerlIO*)pf, ErrorNo());
+}
+
+int          _win32_fflush(FILE *pf)
+{
+    return pPerl->PL_piStdIO->Flush((PerlIO*)pf, ErrorNo());
+}
+
+long         _win32_ftell(FILE *pf)
+{
+    return pPerl->PL_piStdIO->Tell((PerlIO*)pf, ErrorNo());
+}
+
+int          _win32_fseek(FILE *pf,long offset,int origin)
+{
+    return pPerl->PL_piStdIO->Seek((PerlIO*)pf, offset, origin, ErrorNo());
+}
+
+int          _win32_fgetpos(FILE *pf,fpos_t *p)
+{
+    return pPerl->PL_piStdIO->Getpos((PerlIO*)pf, p, ErrorNo());
+}
+
+int          _win32_fsetpos(FILE *pf,const fpos_t *p)
+{
+    return pPerl->PL_piStdIO->Setpos((PerlIO*)pf, p, ErrorNo());
+}
+
+void         _win32_rewind(FILE *pf)
+{
+    pPerl->PL_piStdIO->Rewind((PerlIO*)pf, ErrorNo());
+}
+
+FILE*        _win32_tmpfile(void)
+{
+    return (FILE*)pPerl->PL_piStdIO->Tmpfile(ErrorNo());
+}
+
+void         _win32_setbuf(FILE *pf, char *buf)
+{
+    pPerl->PL_piStdIO->SetBuf((PerlIO*)pf, buf, ErrorNo());
+}
+
+int          _win32_setvbuf(FILE *pf, char *buf, int type, size_t size)
+{
+    return pPerl->PL_piStdIO->SetVBuf((PerlIO*)pf, buf, type, size, ErrorNo());
+}
+
+char*		_win32_fgets(char *s, int n, FILE *pf)
+{
+    return pPerl->PL_piStdIO->Gets((PerlIO*)pf, s, n, ErrorNo());
+}
+
+char*		_win32_gets(char *s)
+{
+    return _win32_fgets(s, 80, (FILE*)pPerl->PL_piStdIO->Stdin());
+}
+
+int          _win32_fgetc(FILE *pf)
+{
+    return pPerl->PL_piStdIO->Getc((PerlIO*)pf, ErrorNo());
+}
+
+int          _win32_putc(int c, FILE *pf)
+{
+    return pPerl->PL_piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
+}
+
+int          _win32_puts(const char *s)
+{
+    return pPerl->PL_piStdIO->Puts(pPerl->PL_piStdIO->Stdout(), s, ErrorNo());
+}
+
+int          _win32_getchar(void)
+{
+    return pPerl->PL_piStdIO->Getc(pPerl->PL_piStdIO->Stdin(), ErrorNo());
+}
+
+int          _win32_putchar(int c)
+{
+    return pPerl->PL_piStdIO->Putc(pPerl->PL_piStdIO->Stdout(), c, ErrorNo());
+}
+
+void*        _win32_malloc(size_t size)
+{
+    return pPerl->PL_piMem->Malloc(size);
+}
+
+void*        _win32_calloc(size_t numitems, size_t size)
+{
+    return pPerl->PL_piMem->Malloc(numitems*size);
+}
+
+void*        _win32_realloc(void *block, size_t size)
+{
+    return pPerl->PL_piMem->Realloc(block, size);
+}
+
+void         _win32_free(void *block)
+{
+    pPerl->PL_piMem->Free(block);
+}
+
+void         _win32_abort(void)
+{
+    pPerl->PL_piProc->Abort();
+}
+
+int          _win32_pipe(int *phandles, unsigned int psize, int textmode)
+{
+    return pPerl->PL_piProc->Pipe(phandles);
+}
+
+FILE*        _win32_popen(const char *command, const char *mode)
+{
+    return (FILE*)pPerl->PL_piProc->Popen(command, mode);
+}
+
+int          _win32_pclose(FILE *pf)
+{
+    return pPerl->PL_piProc->Pclose((PerlIO*)pf);
+}
+
+unsigned     _win32_sleep(unsigned int t)
+{
+    return pPerl->PL_piProc->Sleep(t);
+}
+
+int	_win32_spawnvp(int mode, const char *cmdname, const char *const *argv)
+{
+    return pPerl->PL_piProc->Spawnvp(mode, cmdname, argv);
+}
+
+int          _win32_mkdir(const char *dir, int mode)
+{
+    return pPerl->PL_piDir->Makedir(dir, mode, ErrorNo());
+}
+
+int          _win32_rmdir(const char *dir)
+{
+    return pPerl->PL_piDir->Rmdir(dir, ErrorNo());
+}
+
+int          _win32_chdir(const char *dir)
+{
+    return pPerl->PL_piDir->Chdir(dir, ErrorNo());
+}
+
+#undef stat
+int          _win32_fstat(int fd,struct stat *sbufptr)
+{
+    return pPerl->PL_piLIO->FileStat(fd, sbufptr, ErrorNo());
+}
+
+int          _win32_stat(const char *name,struct stat *sbufptr)
+{
+    return pPerl->PL_piLIO->NameStat(name, sbufptr, ErrorNo());
+}
+
+int          _win32_rename(const char *oname, const char *newname)
+{
+    return pPerl->PL_piLIO->Rename(oname, newname, ErrorNo());
+}
+
+int          _win32_setmode(int fd, int mode)
+{
+    return pPerl->PL_piLIO->Setmode(fd, mode, ErrorNo());
+}
+
+long         _win32_lseek(int fd, long offset, int origin)
+{
+    return pPerl->PL_piLIO->Lseek(fd, offset, origin, ErrorNo());
+}
+
+long         _win32_tell(int fd)
+{
+    return pPerl->PL_piStdIO->Tell((PerlIO*)fd, ErrorNo());
+}
+
+int          _win32_dup(int fd)
+{
+    return pPerl->PL_piLIO->Dup(fd, ErrorNo());
+}
+
+int          _win32_dup2(int h1, int h2)
+{
+    return pPerl->PL_piLIO->Dup2(h1, h2, ErrorNo());
+}
+
+int          _win32_open(const char *path, int oflag,...)
+{
+    return pPerl->PL_piLIO->Open(path, oflag, ErrorNo());
+}
+
+int          _win32_close(int fd)
+{
+    return pPerl->PL_piLIO->Close(fd, ErrorNo());
+}
+
+int          _win32_read(int fd, void *buf, unsigned int cnt)
+{
+    return pPerl->PL_piLIO->Read(fd, buf, cnt, ErrorNo());
+}
+
+int          _win32_write(int fd, const void *buf, unsigned int cnt)
+{
+    return pPerl->PL_piLIO->Write(fd, buf, cnt, ErrorNo());
+}
+
+int          _win32_times(struct tms *timebuf)
+{
+    return pPerl->PL_piProc->Times(timebuf);
+}
+
+int          _win32_ioctl(int i, unsigned int u, char *data)
+{
+    return pPerl->PL_piLIO->IOCtl(i, u, data, ErrorNo());
+}
+
+int          _win32_utime(const char *f, struct utimbuf *t)
+{
+    return pPerl->PL_piLIO->Utime((char*)f, t, ErrorNo());
+}
+
+char*   _win32_getenv(const char *name)
+{
+    return pPerl->PL_piENV->Getenv(name, ErrorNo());
+}
+
+int   _win32_putenv(const char *name)
+{
+    return pPerl->PL_piENV->Putenv(name, ErrorNo());
+}
+
+int          _win32_open_osfhandle(long handle, int flags)
+{
+    return pPerl->PL_piStdIO->OpenOSfhandle(handle, flags);
+}
+
+long         _win32_get_osfhandle(int fd)
+{
+    return pPerl->PL_piStdIO->GetOSfhandle(fd);
+}
+
+u_long _win32_htonl (u_long hostlong)
+{
+    return pPerl->PL_piSock->Htonl(hostlong);
+}
+
+u_short _win32_htons (u_short hostshort)
+{
+    return pPerl->PL_piSock->Htons(hostshort);
+}
+
+u_long _win32_ntohl (u_long netlong)
+{
+    return pPerl->PL_piSock->Ntohl(netlong);
+}
+
+u_short _win32_ntohs (u_short netshort)
+{
+    return pPerl->PL_piSock->Ntohs(netshort);
+}
+
+unsigned long _win32_inet_addr (const char * cp)
+{
+    return pPerl->PL_piSock->InetAddr(cp, ErrorNo());
+}
+
+char * _win32_inet_ntoa (struct in_addr in)
+{
+    return pPerl->PL_piSock->InetNtoa(in, ErrorNo());
+}
+
+SOCKET _win32_socket (int af, int type, int protocol)
+{
+    return pPerl->PL_piSock->Socket(af, type, protocol, ErrorNo());
+}
+
+int _win32_bind (SOCKET s, const struct sockaddr *addr, int namelen)
+{
+    return pPerl->PL_piSock->Bind(s, addr, namelen, ErrorNo());
+}
+
+int _win32_listen (SOCKET s, int backlog)
+{
+    return pPerl->PL_piSock->Listen(s, backlog, ErrorNo());
+}
+
+SOCKET _win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen)
+{
+    return pPerl->PL_piSock->Accept(s, addr, addrlen, ErrorNo());
+}
+
+int _win32_connect (SOCKET s, const struct sockaddr *name, int namelen)
+{
+    return pPerl->PL_piSock->Connect(s, name, namelen, ErrorNo());
+}
+
+int _win32_send (SOCKET s, const char * buf, int len, int flags)
+{
+    return pPerl->PL_piSock->Send(s, buf, len, flags, ErrorNo());
+}
+
+int _win32_sendto (SOCKET s, const char * buf, int len, int flags,
+                       const struct sockaddr *to, int tolen)
+{
+    return pPerl->PL_piSock->Sendto(s, buf, len, flags, to, tolen, ErrorNo());
+}
+
+int _win32_recv (SOCKET s, char * buf, int len, int flags)
+{
+    return pPerl->PL_piSock->Recv(s, buf, len, flags, ErrorNo());
+}
+
+int _win32_recvfrom (SOCKET s, char * buf, int len, int flags,
+                         struct sockaddr *from, int * fromlen)
+{
+    return pPerl->PL_piSock->Recvfrom(s, buf, len, flags, from, fromlen, ErrorNo());
+}
+
+int _win32_shutdown (SOCKET s, int how)
+{
+    return pPerl->PL_piSock->Shutdown(s, how, ErrorNo());
+}
+
+int _win32_closesocket (SOCKET s)
+{
+    return pPerl->PL_piSock->Closesocket(s, ErrorNo());
+}
+
+int _win32_ioctlsocket (SOCKET s, long cmd, u_long *argp)
+{
+    return pPerl->PL_piSock->Ioctlsocket(s, cmd, argp, ErrorNo());
+}
+
+int _win32_setsockopt (SOCKET s, int level, int optname,
+                           const char * optval, int optlen)
+{
+    return pPerl->PL_piSock->Setsockopt(s, level, optname, optval, optlen, ErrorNo());
+}
+
+int _win32_getsockopt (SOCKET s, int level, int optname, char * optval, int *optlen)
+{
+    return pPerl->PL_piSock->Getsockopt(s, level, optname, optval, optlen, ErrorNo());
+}
+
+int _win32_getpeername (SOCKET s, struct sockaddr *name, int * namelen)
+{
+    return pPerl->PL_piSock->Getpeername(s, name, namelen, ErrorNo());
+}
+
+int _win32_getsockname (SOCKET s, struct sockaddr *name, int * namelen)
+{
+    return pPerl->PL_piSock->Getsockname(s, name, namelen, ErrorNo());
+}
+
+int _win32_gethostname (char * name, int namelen)
+{
+    return pPerl->PL_piSock->Gethostname(name, namelen, ErrorNo());
+}
+
+struct hostent * _win32_gethostbyname(const char * name)
+{
+    return pPerl->PL_piSock->Gethostbyname(name, ErrorNo());
+}
+
+struct hostent * _win32_gethostbyaddr(const char * addr, int len, int type)
+{
+    return pPerl->PL_piSock->Gethostbyaddr(addr, len, type, ErrorNo());
+}
+
+struct protoent * _win32_getprotobyname(const char * name)
+{
+    return pPerl->PL_piSock->Getprotobyname(name, ErrorNo());
+}
+
+struct protoent * _win32_getprotobynumber(int proto)
+{
+    return pPerl->PL_piSock->Getprotobynumber(proto, ErrorNo());
+}
+
+struct servent * _win32_getservbyname(const char * name, const char * proto)
+{
+    return pPerl->PL_piSock->Getservbyname(name, proto, ErrorNo());
+}
+
+struct servent * _win32_getservbyport(int port, const char * proto)
+{
+    return pPerl->PL_piSock->Getservbyport(port, proto, ErrorNo());
+}
+
+int _win32_select (int nfds, Perl_fd_set *rfds, Perl_fd_set *wfds, Perl_fd_set *xfds,
+		  const struct timeval *timeout)
+{
+    return pPerl->PL_piSock->Select(nfds, (char*)rfds, (char*)wfds, (char*)xfds, timeout, ErrorNo());
+}
+
+void _win32_endnetent(void)
+{
+    pPerl->PL_piSock->Endnetent(ErrorNo());
+}
+
+void _win32_endhostent(void)
+{
+    pPerl->PL_piSock->Endhostent(ErrorNo());
+}
+
+void _win32_endprotoent(void)
+{
+    pPerl->PL_piSock->Endprotoent(ErrorNo());
+}
+
+void _win32_endservent(void)
+{
+    pPerl->PL_piSock->Endservent(ErrorNo());
+}
+
+struct netent * _win32_getnetent(void)
+{
+    return pPerl->PL_piSock->Getnetent(ErrorNo());
+}
+
+struct netent * _win32_getnetbyname(char *name)
+{
+    return pPerl->PL_piSock->Getnetbyname(name, ErrorNo());
+}
+
+struct netent * _win32_getnetbyaddr(long net, int type)
+{
+    return pPerl->PL_piSock->Getnetbyaddr(net, type, ErrorNo());
+}
+
+struct protoent *_win32_getprotoent(void)
+{
+    return pPerl->PL_piSock->Getprotoent(ErrorNo());
+}
+
+struct servent *_win32_getservent(void)
+{
+    return pPerl->PL_piSock->Getservent(ErrorNo());
+}
+
+void _win32_sethostent(int stayopen)
+{
+    pPerl->PL_piSock->Sethostent(stayopen, ErrorNo());
+}
+
+void _win32_setnetent(int stayopen)
+{
+    pPerl->PL_piSock->Setnetent(stayopen, ErrorNo());
+}
+
+void _win32_setprotoent(int stayopen)
+{
+    pPerl->PL_piSock->Setprotoent(stayopen, ErrorNo());
+}
+
+void _win32_setservent(int stayopen)
+{
+    pPerl->PL_piSock->Setservent(stayopen, ErrorNo());
+}
+END_EXTERN_C
+EOCODE
+
+
+print HDRFILE <<EOCODE;
+
+START_EXTERN_C
+
+#undef Perl_op_desc
+char ** _Perl_op_desc ();
+#define Perl_op_desc (_Perl_op_desc())
+
+#undef Perl_op_name
+char ** _Perl_op_name ();
+#define Perl_op_name (_Perl_op_name())
+
+#undef Perl_no_modify
+char * _Perl_no_modify ();
+#define Perl_no_modify (_Perl_no_modify())
+
+#undef Perl_opargs
+U32 * _Perl_opargs ();
+#define Perl_opargs (_Perl_opargs())
+
+
+#undef win32_errno
+#undef win32_stdin
+#undef win32_stdout
+#undef win32_stderr
+#undef win32_ferror
+#undef win32_feof
+#undef win32_fprintf
+#undef win32_printf
+#undef win32_vfprintf
+#undef win32_vprintf
+#undef win32_fread
+#undef win32_fwrite
+#undef win32_fopen
+#undef win32_fdopen
+#undef win32_freopen
+#undef win32_fclose
+#undef win32_fputs
+#undef win32_fputc
+#undef win32_ungetc
+#undef win32_getc
+#undef win32_fileno
+#undef win32_clearerr
+#undef win32_fflush
+#undef win32_ftell
+#undef win32_fseek
+#undef win32_fgetpos
+#undef win32_fsetpos
+#undef win32_rewind
+#undef win32_tmpfile
+#undef win32_abort
+#undef win32_fstat
+#undef win32_stat
+#undef win32_pipe
+#undef win32_popen
+#undef win32_pclose
+#undef win32_rename
+#undef win32_setmode
+#undef win32_lseek
+#undef win32_tell
+#undef win32_dup
+#undef win32_dup2
+#undef win32_open
+#undef win32_close
+#undef win32_eof
+#undef win32_read
+#undef win32_write
+#undef win32_mkdir
+#undef win32_rmdir
+#undef win32_chdir
+#undef win32_setbuf
+#undef win32_setvbuf
+#undef win32_fgetc
+#undef win32_fgets
+#undef win32_gets
+#undef win32_putc
+#undef win32_puts
+#undef win32_getchar
+#undef win32_putchar
+#undef win32_malloc
+#undef win32_calloc
+#undef win32_realloc
+#undef win32_free
+#undef win32_sleep
+#undef win32_times
+#undef win32_stat
+#undef win32_ioctl
+#undef win32_utime
+#undef win32_getenv
+
+#undef win32_htonl
+#undef win32_htons
+#undef win32_ntohl
+#undef win32_ntohs
+#undef win32_inet_addr
+#undef win32_inet_ntoa
+
+#undef win32_socket
+#undef win32_bind
+#undef win32_listen
+#undef win32_accept
+#undef win32_connect
+#undef win32_send
+#undef win32_sendto
+#undef win32_recv
+#undef win32_recvfrom
+#undef win32_shutdown
+#undef win32_closesocket
+#undef win32_ioctlsocket
+#undef win32_setsockopt
+#undef win32_getsockopt
+#undef win32_getpeername
+#undef win32_getsockname
+#undef win32_gethostname
+#undef win32_gethostbyname
+#undef win32_gethostbyaddr
+#undef win32_getprotobyname
+#undef win32_getprotobynumber
+#undef win32_getservbyname
+#undef win32_getservbyport
+#undef win32_select
+#undef win32_endhostent
+#undef win32_endnetent
+#undef win32_endprotoent
+#undef win32_endservent
+#undef win32_getnetent
+#undef win32_getnetbyname
+#undef win32_getnetbyaddr
+#undef win32_getprotoent
+#undef win32_getservent
+#undef win32_sethostent
+#undef win32_setnetent
+#undef win32_setprotoent
+#undef win32_setservent
+
+#define win32_errno    _win32_errno
+#define win32_stdin    _win32_stdin
+#define win32_stdout   _win32_stdout
+#define win32_stderr   _win32_stderr
+#define win32_ferror   _win32_ferror
+#define win32_feof     _win32_feof
+#define win32_strerror _win32_strerror
+#define win32_perror   _win32_perror
+#define win32_fprintf  _win32_fprintf
+#define win32_printf   _win32_printf
+#define win32_vfprintf _win32_vfprintf
+#define win32_vprintf  _win32_vprintf
+#define win32_fread    _win32_fread
+#define win32_fwrite   _win32_fwrite
+#define win32_fopen    _win32_fopen
+#define win32_fdopen   _win32_fdopen
+#define win32_freopen  _win32_freopen
+#define win32_fclose   _win32_fclose
+#define win32_fputs    _win32_fputs
+#define win32_fputc    _win32_fputc
+#define win32_ungetc   _win32_ungetc
+#define win32_getc     _win32_getc
+#define win32_fileno   _win32_fileno
+#define win32_clearerr _win32_clearerr
+#define win32_fflush   _win32_fflush
+#define win32_ftell    _win32_ftell
+#define win32_fseek    _win32_fseek
+#define win32_fgetpos  _win32_fgetpos
+#define win32_fsetpos  _win32_fsetpos
+#define win32_rewind   _win32_rewind
+#define win32_tmpfile  _win32_tmpfile
+#define win32_abort    _win32_abort
+#define win32_fstat    _win32_fstat
+#define win32_stat     _win32_stat
+#define win32_pipe     _win32_pipe
+#define win32_popen    _win32_popen
+#define win32_pclose   _win32_pclose
+#define win32_rename   _win32_rename
+#define win32_setmode  _win32_setmode
+#define win32_lseek    _win32_lseek
+#define win32_tell     _win32_tell
+#define win32_dup      _win32_dup
+#define win32_dup2     _win32_dup2
+#define win32_open     _win32_open
+#define win32_close    _win32_close
+#define win32_eof      _win32_eof
+#define win32_read     _win32_read
+#define win32_write    _win32_write
+#define win32_mkdir    _win32_mkdir
+#define win32_rmdir    _win32_rmdir
+#define win32_chdir    _win32_chdir
+#define win32_setbuf   _win32_setbuf
+#define win32_setvbuf  _win32_setvbuf
+#define win32_fgetc    _win32_fgetc
+#define win32_fgets    _win32_fgets
+#define win32_gets     _win32_gets
+#define win32_putc     _win32_putc
+#define win32_puts     _win32_puts
+#define win32_getchar  _win32_getchar
+#define win32_putchar  _win32_putchar
+#define win32_malloc   _win32_malloc
+#define win32_calloc   _win32_calloc
+#define win32_realloc  _win32_realloc
+#define win32_free     _win32_free
+#define win32_sleep    _win32_sleep
+#define win32_spawnvp  _win32_spawnvp
+#define win32_times    _win32_times
+#define win32_stat     _win32_stat
+#define win32_ioctl    _win32_ioctl
+#define win32_utime    _win32_utime
+#define win32_getenv   _win32_getenv
+#define win32_open_osfhandle _win32_open_osfhandle
+#define win32_get_osfhandle  _win32_get_osfhandle
+
+#define win32_htonl              _win32_htonl
+#define win32_htons              _win32_htons
+#define win32_ntohl              _win32_ntohl
+#define win32_ntohs              _win32_ntohs
+#define win32_inet_addr          _win32_inet_addr
+#define win32_inet_ntoa          _win32_inet_ntoa
+
+#define win32_socket             _win32_socket
+#define win32_bind               _win32_bind
+#define win32_listen             _win32_listen
+#define win32_accept             _win32_accept
+#define win32_connect            _win32_connect
+#define win32_send               _win32_send
+#define win32_sendto             _win32_sendto
+#define win32_recv               _win32_recv
+#define win32_recvfrom           _win32_recvfrom
+#define win32_shutdown           _win32_shutdown
+#define win32_closesocket        _win32_closesocket
+#define win32_ioctlsocket        _win32_ioctlsocket
+#define win32_setsockopt         _win32_setsockopt
+#define win32_getsockopt         _win32_getsockopt
+#define win32_getpeername        _win32_getpeername
+#define win32_getsockname        _win32_getsockname
+#define win32_gethostname        _win32_gethostname
+#define win32_gethostbyname      _win32_gethostbyname
+#define win32_gethostbyaddr      _win32_gethostbyaddr
+#define win32_getprotobyname     _win32_getprotobyname
+#define win32_getprotobynumber   _win32_getprotobynumber
+#define win32_getservbyname      _win32_getservbyname
+#define win32_getservbyport      _win32_getservbyport
+#define win32_select             _win32_select
+#define win32_endhostent         _win32_endhostent
+#define win32_endnetent          _win32_endnetent
+#define win32_endprotoent        _win32_endprotoent
+#define win32_endservent         _win32_endservent
+#define win32_getnetent          _win32_getnetent
+#define win32_getnetbyname       _win32_getnetbyname
+#define win32_getnetbyaddr       _win32_getnetbyaddr
+#define win32_getprotoent        _win32_getprotoent
+#define win32_getservent         _win32_getservent
+#define win32_sethostent         _win32_sethostent
+#define win32_setnetent          _win32_setnetent
+#define win32_setprotoent        _win32_setprotoent
+#define win32_setservent         _win32_setservent
+
+int * 	_win32_errno(void);
+FILE*	_win32_stdin(void);
+FILE*	_win32_stdout(void);
+FILE*	_win32_stderr(void);
+int	_win32_ferror(FILE *fp);
+int	_win32_feof(FILE *fp);
+char*	_win32_strerror(int e);
+void    _win32_perror(const char *str);
+int	_win32_fprintf(FILE *pf, const char *format, ...);
+int	_win32_printf(const char *format, ...);
+int	_win32_vfprintf(FILE *pf, const char *format, va_list arg);
+int	_win32_vprintf(const char *format, va_list arg);
+size_t	_win32_fread(void *buf, size_t size, size_t count, FILE *pf);
+size_t	_win32_fwrite(const void *buf, size_t size, size_t count, FILE *pf);
+FILE*	_win32_fopen(const char *path, const char *mode);
+FILE*	_win32_fdopen(int fh, const char *mode);
+FILE*	_win32_freopen(const char *path, const char *mode, FILE *pf);
+int	_win32_fclose(FILE *pf);
+int	_win32_fputs(const char *s,FILE *pf);
+int	_win32_fputc(int c,FILE *pf);
+int	_win32_ungetc(int c,FILE *pf);
+int	_win32_getc(FILE *pf);
+int	_win32_fileno(FILE *pf);
+void	_win32_clearerr(FILE *pf);
+int	_win32_fflush(FILE *pf);
+long	_win32_ftell(FILE *pf);
+int	_win32_fseek(FILE *pf,long offset,int origin);
+int	_win32_fgetpos(FILE *pf,fpos_t *p);
+int	_win32_fsetpos(FILE *pf,const fpos_t *p);
+void	_win32_rewind(FILE *pf);
+FILE*	_win32_tmpfile(void);
+void	_win32_abort(void);
+int  	_win32_fstat(int fd,struct stat *sbufptr);
+int  	_win32_stat(const char *name,struct stat *sbufptr);
+int	_win32_pipe( int *phandles, unsigned int psize, int textmode );
+FILE*	_win32_popen( const char *command, const char *mode );
+int	_win32_pclose( FILE *pf);
+int	_win32_rename( const char *oldname, const char *newname);
+int	_win32_setmode( int fd, int mode);
+long	_win32_lseek( int fd, long offset, int origin);
+long	_win32_tell( int fd);
+int	_win32_dup( int fd);
+int	_win32_dup2(int h1, int h2);
+int	_win32_open(const char *path, int oflag,...);
+int	_win32_close(int fd);
+int	_win32_eof(int fd);
+int	_win32_read(int fd, void *buf, unsigned int cnt);
+int	_win32_write(int fd, const void *buf, unsigned int cnt);
+int	_win32_mkdir(const char *dir, int mode);
+int	_win32_rmdir(const char *dir);
+int	_win32_chdir(const char *dir);
+void	_win32_setbuf(FILE *pf, char *buf);
+int	_win32_setvbuf(FILE *pf, char *buf, int type, size_t size);
+char*	_win32_fgets(char *s, int n, FILE *pf);
+char*	_win32_gets(char *s);
+int	_win32_fgetc(FILE *pf);
+int	_win32_putc(int c, FILE *pf);
+int	_win32_puts(const char *s);
+int	_win32_getchar(void);
+int	_win32_putchar(int c);
+void*	_win32_malloc(size_t size);
+void*	_win32_calloc(size_t numitems, size_t size);
+void*	_win32_realloc(void *block, size_t size);
+void	_win32_free(void *block);
+unsigned _win32_sleep(unsigned int);
+int	_win32_spawnvp(int mode, const char *cmdname, const char *const *argv);
+int	_win32_times(struct tms *timebuf);
+int	_win32_stat(const char *path, struct stat *buf);
+int	_win32_ioctl(int i, unsigned int u, char *data);
+int	_win32_utime(const char *f, struct utimbuf *t);
+char*   _win32_getenv(const char *name);
+int     _win32_open_osfhandle(long handle, int flags);
+long    _win32_get_osfhandle(int fd);
+
+u_long _win32_htonl (u_long hostlong);
+u_short _win32_htons (u_short hostshort);
+u_long _win32_ntohl (u_long netlong);
+u_short _win32_ntohs (u_short netshort);
+unsigned long _win32_inet_addr (const char * cp);
+char * _win32_inet_ntoa (struct in_addr in);
+
+SOCKET _win32_socket (int af, int type, int protocol);
+int _win32_bind (SOCKET s, const struct sockaddr *addr, int namelen);
+int _win32_listen (SOCKET s, int backlog);
+SOCKET _win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen);
+int _win32_connect (SOCKET s, const struct sockaddr *name, int namelen);
+int _win32_send (SOCKET s, const char * buf, int len, int flags);
+int _win32_sendto (SOCKET s, const char * buf, int len, int flags,
+                       const struct sockaddr *to, int tolen);
+int _win32_recv (SOCKET s, char * buf, int len, int flags);
+int _win32_recvfrom (SOCKET s, char * buf, int len, int flags,
+                         struct sockaddr *from, int * fromlen);
+int _win32_shutdown (SOCKET s, int how);
+int _win32_closesocket (SOCKET s);
+int _win32_ioctlsocket (SOCKET s, long cmd, u_long *argp);
+int _win32_setsockopt (SOCKET s, int level, int optname,
+                           const char * optval, int optlen);
+int _win32_getsockopt (SOCKET s, int level, int optname, char * optval, int *optlen);
+int _win32_getpeername (SOCKET s, struct sockaddr *name, int * namelen);
+int _win32_getsockname (SOCKET s, struct sockaddr *name, int * namelen);
+int _win32_gethostname (char * name, int namelen);
+struct hostent * _win32_gethostbyname(const char * name);
+struct hostent * _win32_gethostbyaddr(const char * addr, int len, int type);
+struct protoent * _win32_getprotobyname(const char * name);
+struct protoent * _win32_getprotobynumber(int proto);
+struct servent * _win32_getservbyname(const char * name, const char * proto);
+struct servent * _win32_getservbyport(int port, const char * proto);
+int _win32_select (int nfds, Perl_fd_set *rfds, Perl_fd_set *wfds, Perl_fd_set *xfds,
+		  const struct timeval *timeout);
+void _win32_endnetent(void);
+void _win32_endhostent(void);
+void _win32_endprotoent(void);
+void _win32_endservent(void);
+struct netent * _win32_getnetent(void);
+struct netent * _win32_getnetbyname(char *name);
+struct netent * _win32_getnetbyaddr(long net, int type);
+struct protoent *_win32_getprotoent(void);
+struct servent *_win32_getservent(void);
+void _win32_sethostent(int stayopen);
+void _win32_setnetent(int stayopen);
+void _win32_setprotoent(int stayopen);
+void _win32_setservent(int stayopen);
+
+END_EXTERN_C
+
+#pragma warning(once : 4113)
+EOCODE
+
+
+close HDRFILE;
+close OUTFILE;
diff --git a/gnu/usr.bin/perl/win32/bin/perlglob.pl b/gnu/usr.bin/perl/win32/bin/perlglob.pl
new file mode 100644
index 00000000000..6467e573b5f
--- /dev/null
+++ b/gnu/usr.bin/perl/win32/bin/perlglob.pl
@@ -0,0 +1,53 @@
+#!perl -w
+use File::DosGlob;
+$| = 1;
+while (@ARGV) {
+    my $arg = shift;
+    my @m = File::DosGlob::doglob(1,$arg);
+    print (@m ? join("\0", sort @m) : $arg);
+    print "\0" if @ARGV;
+}
+__END__
+
+=head1 NAME
+
+perlglob.bat - a more capable perlglob.exe replacement
+
+=head1 SYNOPSIS
+
+    @perlfiles = glob  "..\\pe?l/*.p?";
+    print <..\\pe?l/*.p?>;
+
+    # more efficient version
+    > perl -MFile::DosGlob=glob -e "print <../pe?l/*.p?>"
+
+=head1 DESCRIPTION
+
+This file is a portable replacement for perlglob.exe.  It
+is largely compatible with perlglob.exe (the Microsoft setargv.obj
+version) in all but one respect--it understands wildcards in
+directory components.
+
+It prints null-separated filenames to standard output.
+
+For details of the globbing features implemented, see
+L<File::DosGlob>.
+
+While one may replace perlglob.exe with this, usage by overriding
+CORE::glob with File::DosGlob::glob should be much more efficient,
+because it avoids launching a separate process, and is therefore
+strongly recommended.  See L<perlsub> for details of overriding
+builtins.
+
+=head1 AUTHOR
+
+Gurusamy Sarathy <gsar@umich.edu>
+
+=head1 SEE ALSO
+
+perl
+
+File::DosGlob
+
+=cut
+
diff --git a/gnu/usr.bin/perl/win32/config.gc b/gnu/usr.bin/perl/win32/config.gc
new file mode 100644
index 00000000000..b43c511013a
--- /dev/null
+++ b/gnu/usr.bin/perl/win32/config.gc
@@ -0,0 +1,563 @@
+## Configured by: ~cf_email~
+## Target system: WIN32 
+Author=''
+CONFIG='true'
+Date='$Date'
+Header=''
+Id='$Id'
+Locker=''
+Log='$Log'
+Mcc='Mcc'
+PATCHLEVEL='~PATCHLEVEL~'
+RCSfile='$RCSfile'
+Revision='$Revision'
+SUBVERSION='~SUBVERSION~'
+Source=''
+State=''
+_a='.a'
+_exe='.exe'
+_o='.o'
+afs='false'
+alignbytes='8'
+ansi2knr=''
+aphostname=''
+apiversion='5.005'
+ar='ar'
+archlib='~INST_TOP~~INST_VER~\lib\~archname~'
+archlibexp='~INST_TOP~~INST_VER~\lib\~archname~'
+archname='MSWin32'
+archobjs=''
+awk='awk'
+baserev='5.0'
+bash=''
+bin='~INST_TOP~~INST_VER~\bin\~archname~'
+binexp='~INST_TOP~~INST_VER~\bin\~archname~'
+bison=''
+byacc='byacc'
+byteorder='1234'
+c=''
+castflags='0'
+cat='type'
+cc='gcc'
+cccdlflags=' '
+ccdlflags=' '
+ccflags='-MD -DWIN32'
+cf_by='nobody'
+cf_email='nobody@no.where.net'
+cf_time=''
+chgrp=''
+chmod=''
+chown=''
+clocktype='clock_t'
+comm=''
+compress=''
+contains='grep'
+cp='copy'
+cpio=''
+cpp='gcc -E'
+cpp_stuff='42'
+cppflags='-DWIN32'
+cpplast=''
+cppminus='-'
+cpprun='gcc -E'
+cppstdin='gcc -E'
+cryptlib=''
+csh='undef'
+d_Gconvert='sprintf((b),"%.*g",(n),(x))'
+d_access='define'
+d_alarm='undef'
+d_archlib='define'
+d_attribut='define'
+d_bcmp='undef'
+d_bcopy='undef'
+d_bsd='define'
+d_bsdgetpgrp='undef'
+d_bsdsetpgrp='undef'
+d_bzero='undef'
+d_casti32='define'
+d_castneg='define'
+d_charvspr='undef'
+d_chown='undef'
+d_chroot='undef'
+d_chsize='define'
+d_closedir='define'
+d_const='define'
+d_crypt='undef'
+d_csh='undef'
+d_cuserid='undef'
+d_dbl_dig='define'
+d_difftime='define'
+d_dirnamlen='define'
+d_dlerror='define'
+d_dlopen='define'
+d_dlsymun='undef'
+d_dosuid='undef'
+d_dup2='define'
+d_endgrent='undef'
+d_endhent='undef'
+d_endnent='undef'
+d_endpent='undef'
+d_endpwent='undef'
+d_endsent='undef'
+d_eofnblk='define'
+d_eunice='undef'
+d_fchmod='undef'
+d_fchown='undef'
+d_fcntl='undef'
+d_fd_macros='define'
+d_fd_set='define'
+d_fds_bits='define'
+d_fgetpos='define'
+d_flexfnam='define'
+d_flock='define'
+d_fork='undef'
+d_fpathconf='undef'
+d_fsetpos='define'
+d_ftime='define'
+d_getgrent='undef'
+d_getgrps='undef'
+d_gethbyaddr='define'
+d_gethbyname='define'
+d_gethent='undef'
+d_gethname='define'
+d_gethostprotos='define'
+d_getlogin='define'
+d_getnbyaddr='undef'
+d_getnbyname='undef'
+d_getnent='undef'
+d_getnetprotos='undef'
+d_getpbyname='define'
+d_getpbynumber='define'
+d_getpent='undef'
+d_getpwent='undef'
+d_getpgid='undef'
+d_getpgrp2='undef'
+d_getpgrp='undef'
+d_getppid='undef'
+d_getprior='undef'
+d_getprotoprotos='define'
+d_getsbyname='define'
+d_getsbyport='define'
+d_getsent='undef'
+d_getservprotos='define'
+d_gettimeod='undef'
+d_grpasswd='undef'
+d_gnulibc='undef'
+d_htonl='define'
+d_index='undef'
+d_inetaton='undef'
+d_isascii='define'
+d_killpg='undef'
+d_lchown='undef'
+d_link='undef'
+d_locconv='define'
+d_lockf='undef'
+d_longdbl='define'
+d_longlong='undef'
+d_lstat='undef'
+d_mblen='define'
+d_mbstowcs='define'
+d_mbtowc='define'
+d_memcmp='define'
+d_memcpy='define'
+d_memmove='define'
+d_memset='define'
+d_mkdir='define'
+d_mkfifo='undef'
+d_mktime='define'
+d_msg='undef'
+d_msgctl='undef'
+d_msgget='undef'
+d_msgrcv='undef'
+d_msgsnd='undef'
+d_mymalloc='undef'
+d_nice='undef'
+d_oldpthreads='undef'
+d_oldsock='undef'
+d_open3='undef'
+d_pathconf='undef'
+d_pause='define'
+d_phostname='undef'
+d_pipe='define'
+d_poll='undef'
+d_portable='define'
+d_pthread_yield='undef'
+d_pthreads_created_joinable='undef'
+d_pwage='undef'
+d_pwchange='undef'
+d_pwclass='undef'
+d_pwcomment='undef'
+d_pwexpire='undef'
+d_pwgecos='undef'
+d_pwquota='undef'
+d_pwpasswd='undef'
+d_readdir='define'
+d_readlink='undef'
+d_rename='define'
+d_rewinddir='define'
+d_rmdir='define'
+d_safebcpy='undef'
+d_safemcpy='undef'
+d_sanemcmp='define'
+d_sched_yield='undef'
+d_seekdir='define'
+d_select='define'
+d_sem='undef'
+d_semctl='undef'
+d_semctl_semid_ds='undef'
+d_semctl_semun='undef'
+d_semget='undef'
+d_semop='undef'
+d_setegid='undef'
+d_seteuid='undef'
+d_setgrent='undef'
+d_setgrps='undef'
+d_sethent='undef'
+d_setpwent='undef'
+d_setlinebuf='undef'
+d_setlocale='define'
+d_setnent='undef'
+d_setpent='undef'
+d_setpgid='undef'
+d_setpgrp2='undef'
+d_setpgrp='undef'
+d_setprior='undef'
+d_setregid='undef'
+d_setresgid='undef'
+d_setresuid='undef'
+d_setreuid='undef'
+d_setrgid='undef'
+d_setruid='undef'
+d_setsent='undef'
+d_setsid='undef'
+d_setvbuf='define'
+d_sfio='undef'
+d_shm='undef'
+d_shmat='undef'
+d_shmatprototype='undef'
+d_shmctl='undef'
+d_shmdt='undef'
+d_shmget='undef'
+d_sigaction='undef'
+d_sigsetjmp='undef'
+d_socket='define'
+d_sockpair='undef'
+d_statblks='undef'
+d_stdio_cnt_lval='define'
+d_stdio_ptr_lval='define'
+d_stdiobase='undef'
+d_stdstdio='undef'
+d_strchr='define'
+d_strcoll='define'
+d_strctcpy='define'
+d_strerrm='strerror(e)'
+d_strerror='define'
+d_strtod='define'
+d_strtol='define'
+d_strtoul='define'
+d_strxfrm='define'
+d_suidsafe='undef'
+d_symlink='undef'
+d_syscall='undef'
+d_sysconf='undef'
+d_sysernlst=''
+d_syserrlst='define'
+d_system='define'
+d_tcgetpgrp='undef'
+d_tcsetpgrp='undef'
+d_telldir='define'
+d_time='define'
+d_times='define'
+d_truncate='undef'
+d_tzname='undef'
+d_umask='define'
+d_uname='undef'
+d_union_semun='define'
+d_vfork='undef'
+d_void_closedir='undef'
+d_voidsig='define'
+d_voidtty=''
+d_volatile='define'
+d_vprintf='define'
+d_wait4='undef'
+d_waitpid='define'
+d_wcstombs='define'
+d_wctomb='define'
+d_xenix='undef'
+date='date'
+db_hashtype='int'
+db_prefixtype='int'
+defvoidused='15'
+direntrytype='struct direct'
+dlext='dll'
+dlsrc='dl_win32.xs'
+doublesize='8'
+dynamic_ext='Socket IO Fcntl Opcode SDBM_File attrs Thread'
+eagain='EAGAIN'
+ebcdic='undef'
+echo='echo'
+egrep='egrep'
+emacs=''
+eunicefix=':'
+exe_ext='.exe'
+expr='expr'
+extensions='~static_ext~ ~dynamic_ext~ ~nonxs_ext~'
+find='find'
+firstmakefile='makefile'
+flex=''
+fpostype='fpos_t'
+freetype='void'
+full_csh=''
+full_sed=''
+gccversion=''
+gidtype='gid_t'
+glibpth='/usr/shlib  /lib/pa1.1 /usr/lib/large /lib /usr/lib /usr/lib/386 /lib/386 /lib/large /usr/lib/small /lib/small /usr/ccs/lib /usr/ucblib /usr/shlib '
+grep='grep'
+groupcat=''
+groupstype='gid_t'
+gzip='gzip'
+h_fcntl='false'
+h_sysfile='true'
+hint='recommended'
+hostcat='ypcat hosts'
+huge=''
+i_arpainet='define'
+i_bsdioctl=''
+i_db='undef'
+i_dbm='undef'
+i_dirent='define'
+i_dld='undef'
+i_dlfcn='define'
+i_fcntl='define'
+i_float='define'
+i_gdbm='undef'
+i_grp='undef'
+i_limits='define'
+i_locale='define'
+i_malloc='define'
+i_math='define'
+i_memory='undef'
+i_ndbm='undef'
+i_netdb='undef'
+i_neterrno='undef'
+i_niin='undef'
+i_pwd='undef'
+i_rpcsvcdbm='define'
+i_sfio='undef'
+i_sgtty='undef'
+i_stdarg='define'
+i_stddef='define'
+i_stdlib='define'
+i_string='define'
+i_sysdir='undef'
+i_sysfile='undef'
+i_sysfilio='define'
+i_sysin='undef'
+i_sysioctl='undef'
+i_sysndir='undef'
+i_sysparam='undef'
+i_sysresrc='undef'
+i_sysselct='undef'
+i_syssockio=''
+i_sysstat='define'
+i_systime='undef'
+i_systimek='undef'
+i_systimes='undef'
+i_systypes='define'
+i_sysun='undef'
+i_syswait='undef'
+i_termio='undef'
+i_termios='undef'
+i_time='define'
+i_unistd='undef'
+i_utime='define'
+i_values='undef'
+i_varargs='undef'
+i_varhdr='varargs.h'
+i_vfork='undef'
+incpath=''
+inews=''
+installarchlib='~INST_TOP~~INST_VER~\lib\~archname~'
+installbin='~INST_TOP~~INST_VER~\bin\~archname~'
+installman1dir='~INST_TOP~~INST_VER~\man\man1'
+installman3dir='~INST_TOP~~INST_VER~\man\man3'
+installhtmldir='~INST_TOP~~INST_VER~\html'
+installhtmlhelpdir='~INST_TOP~~INST_VER~\htmlhelp'
+installprivlib='~INST_TOP~~INST_VER~\lib'
+installscript='~INST_TOP~~INST_VER~\bin'
+installsitearch='~INST_TOP~\site~INST_VER~\lib\~archname~'
+installsitelib='~INST_TOP~\site~INST_VER~\lib'
+intsize='4'
+known_extensions='DB_File Fcntl GDBM_File NDBM_File ODBM_File Opcode POSIX SDBM_File Socket IO attrs Thread'
+ksh=''
+large=''
+ld='gcc'
+lddlflags='-mdll ~LINK_FLAGS~'
+ldflags='~LINK_FLAGS~'
+less='less'
+lib_ext='.a'
+libc='libcrtdll.a'
+libperl='libperl.a'
+libpth=''
+libs=''
+libswanted='net socket inet nsl nm ndbm gdbm dbm db malloc dl dld ld sun m c cposix posix ndir dir crypt ucb bsd BSD PW x'
+line='line'
+lint=''
+lkflags=''
+ln=''
+lns='copy'
+locincpth='/usr/local/include /opt/local/include /usr/gnu/include /opt/gnu/include /usr/GNU/include /opt/GNU/include'
+loclibpth='/usr/local/lib /opt/local/lib /usr/gnu/lib /opt/gnu/lib /usr/GNU/lib /opt/GNU/lib'
+longdblsize='12'
+longlongsize='8'
+longsize='4'
+lp=''
+lpr=''
+ls='dir'
+lseektype='off_t'
+mail=''
+mailx=''
+make='dmake'
+make_set_make='#'
+mallocobj='malloc.o'
+mallocsrc='malloc.c'
+malloctype='void *'
+man1dir='~INST_TOP~~INST_VER~\man\man1'
+man1direxp='~INST_TOP~~INST_VER~\man\man1'
+man1ext='1'
+man3dir='~INST_TOP~~INST_VER~\man\man3'
+man3direxp='~INST_TOP~~INST_VER~\man\man3'
+man3ext='3'
+medium=''
+mips=''
+mips_type=''
+mkdir='mkdir'
+models='none'
+modetype='mode_t'
+more='more /e'
+mv=''
+myarchname='MSWin32'
+mydomain=''
+myhostname=''
+myuname=''
+n='-n'
+netdb_hlen_type='int'
+netdb_host_type='char *'
+netdb_name_type='char *'
+netdb_net_type='long'
+nm='nm'
+nm_opt=''
+nm_so_opt=''
+nonxs_ext='Errno'
+nroff=''
+o_nonblock='O_NONBLOCK'
+obj_ext='.o'
+optimize='-O2'
+orderlib='false'
+osname='MSWin32'
+osvers='4.0'
+package='perl5'
+pager='more /e'
+passcat=''
+patchlevel='~PATCHLEVEL~'
+path_sep=';'
+perl='perl'
+perladmin=''
+perlpath='~INST_TOP~~INST_VER~\bin\~archname~\perl.exe'
+pg=''
+phostname='hostname'
+pidtype='int'
+plibpth=''
+pmake=''
+pr=''
+prefix='~INST_TOP~'
+prefixexp='~INST_DRV~'
+privlib='~INST_TOP~~INST_VER~\lib'
+privlibexp='~INST_TOP~~INST_VER~\lib'
+prototype='define'
+ptrsize='4'
+randbits='15'
+ranlib='rem'
+rd_nodata='-1'
+rm='del'
+rmail=''
+runnm='true'
+scriptdir='~INST_TOP~~INST_VER~\bin'
+scriptdirexp='~INST_TOP~~INST_VER~\bin'
+sed='sed'
+selecttype='Perl_fd_set *'
+sendmail='blat'
+sh='cmd /x /c'
+shar=''
+sharpbang='#!'
+shmattype='void *'
+shortsize='2'
+shrpenv=''
+shsharp='true'
+sig_name='ZERO NUM01 INT QUIT ILL NUM05 NUM06 NUM07 FPE KILL NUM10 SEGV NUM12 PIPE ALRM TERM NUM16 NUM17 NUM18 NUM19 CHLD BREAK ABRT STOP NUM24 CONT CLD'
+sig_name_init='"ZERO", "NUM01", "INT", "QUIT", "ILL", "NUM05", "NUM06", "NUM07", "FPE", "KILL", "NUM10", "SEGV", "NUM12", "PIPE", "ALRM", "TERM", "NUM16", "NUM17", "NUM18", "NUM19", "CHLD", "BREAK", "ABRT", "STOP", "NUM24", "CONT", "CLD", 0'
+sig_num='0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 20 0'
+sig_num_init='0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 20, 0'
+signal_t='void'
+sitearch='~INST_TOP~\site~INST_VER~\lib\~archname~'
+sitearchexp='~INST_TOP~\site~INST_VER~\lib\~archname~'
+sitelib='~INST_TOP~\site~INST_VER~\lib'
+sitelibexp='~INST_TOP~\site~INST_VER~\lib'
+sizetype='size_t'
+sleep=''
+smail=''
+small=''
+so='dll'
+sockethdr=''
+socketlib=''
+sort='sort'
+spackage='Perl5'
+spitshell=''
+split=''
+src=''
+ssizetype='int'
+startperl='#!perl'
+startsh='#!/bin/sh'
+static_ext='DynaLoader'
+stdchar='char'
+stdio_base='((fp)->_base)'
+stdio_bufsiz='((fp)->_cnt + (fp)->_ptr - (fp)->_base)'
+stdio_cnt='((fp)->_cnt)'
+stdio_filbuf=''
+stdio_ptr='((fp)->_ptr)'
+strings='/usr/include/string.h'
+submit=''
+subversion='~SUBVERSION~'
+sysman='/usr/man/man1'
+tail=''
+tar=''
+tbl=''
+tee=''
+test=''
+timeincl='/usr/include/sys/time.h '
+timetype='time_t'
+touch='touch'
+tr=''
+trnl='\012'
+troff=''
+uidtype='uid_t'
+uname='uname'
+uniq='uniq'
+usedl='define'
+usemymalloc='n'
+usenm='false'
+useopcode='true'
+useperlio='undef'
+useposix='true'
+usesfio='false'
+useshrplib='yes'
+usethreads='undef'
+usevfork='false'
+usrinc='/usr/include'
+uuname=''
+version='~VERSION~'
+vi=''
+voidflags='15'
+xlibpth='/usr/lib/386 /lib/386'
+zcat=''
+zip='zip'
diff --git a/gnu/usr.bin/perl/win32/config_H.gc b/gnu/usr.bin/perl/win32/config_H.gc
new file mode 100644
index 00000000000..0cb45e45841
--- /dev/null
+++ b/gnu/usr.bin/perl/win32/config_H.gc
@@ -0,0 +1,2094 @@
+/*
+ * This file was produced by running the config_h.SH script, which
+ * gets its values from config.sh, which is generally produced by
+ * running Configure.
+ *
+ * Feel free to modify any of this as the need arises.  Note, however,
+ * that running config_h.SH again will wipe out any changes you've made.
+ * For a more permanent change edit config.sh and rerun config_h.SH.
+ *
+ * $Id: Config_h.U,v 3.0.1.5 1997/02/28 14:57:43 ram Exp $
+ */
+
+/*
+ * Package name      : perl5
+ * Source directory  : 
+ * Configuration time: undef
+ * Configured by     : gsar
+ * Target system     : 
+ */
+
+#ifndef _config_h_
+#define _config_h_
+
+/* LOC_SED:
+ *	This symbol holds the complete pathname to the sed program.
+ */
+#define LOC_SED 	""	/**/
+
+/* BIN:
+ *	This symbol holds the path of the bin directory where the package will
+ *	be installed. Program must be prepared to deal with ~name substitution.
+ */
+/* BIN_EXP:
+ *	This symbol is the filename expanded version of the BIN symbol, for
+ *	programs that do not want to deal with that at run-time.
+ */
+#define BIN "c:\\perl\\5.00503\\bin\\MSWin32-x86"	/**/
+#define BIN_EXP "c:\\perl\\5.00503\\bin\\MSWin32-x86"	/**/
+
+/* CPPSTDIN:
+ *	This symbol contains the first part of the string which will invoke
+ *	the C preprocessor on the standard input and produce to standard
+ *	output.	 Typical value of "cc -E" or "/lib/cpp", but it can also
+ *	call a wrapper. See CPPRUN.
+ */
+/* CPPMINUS:
+ *	This symbol contains the second part of the string which will invoke
+ *	the C preprocessor on the standard input and produce to standard
+ *	output.  This symbol will have the value "-" if CPPSTDIN needs a minus
+ *	to specify standard input, otherwise the value is "".
+ */
+#define CPPSTDIN "gcc -E"
+#define CPPMINUS "-"
+
+/* HAS_ALARM:
+ *	This symbol, if defined, indicates that the alarm routine is
+ *	available.
+ */
+/*#define HAS_ALARM		/**/
+
+/* HASATTRIBUTE:
+ *	This symbol indicates the C compiler can check for function attributes,
+ *	such as printf formats. This is normally only supported by GNU cc.
+ */
+#define HASATTRIBUTE 	/**/
+#ifndef HASATTRIBUTE
+#define __attribute__(_arg_)
+#endif
+
+/* HAS_BCMP:
+ *	This symbol is defined if the bcmp() routine is available to
+ *	compare blocks of memory.
+ */
+/*#define HAS_BCMP	/**/
+
+/* HAS_BCOPY:
+ *	This symbol is defined if the bcopy() routine is available to
+ *	copy blocks of memory.
+ */
+/*#define HAS_BCOPY	/**/
+
+/* HAS_BZERO:
+ *	This symbol is defined if the bzero() routine is available to
+ *	set a memory block to 0.
+ */
+/*#define HAS_BZERO	/**/
+
+/* HAS_CHOWN:
+ *	This symbol, if defined, indicates that the chown routine is
+ *	available.
+ */
+/*#define HAS_CHOWN		/**/
+
+/* HAS_CHROOT:
+ *	This symbol, if defined, indicates that the chroot routine is
+ *	available.
+ */
+/*#define HAS_CHROOT		/**/
+
+/* HAS_CHSIZE:
+ *	This symbol, if defined, indicates that the chsize routine is available
+ *	to truncate files.  You might need a -lx to get this routine.
+ */
+#define	HAS_CHSIZE		/**/
+
+/* HASCONST:
+ *	This symbol, if defined, indicates that this C compiler knows about
+ *	the const type. There is no need to actually test for that symbol
+ *	within your programs. The mere use of the "const" keyword will
+ *	trigger the necessary tests.
+ */
+#define HASCONST	/**/
+#ifndef HASCONST
+#define const
+#endif
+
+/* HAS_CRYPT:
+ *	This symbol, if defined, indicates that the crypt routine is available
+ *	to encrypt passwords and the like.
+ */
+/*#define HAS_CRYPT		/**/
+
+/* HAS_CUSERID:
+ *	This symbol, if defined, indicates that the cuserid routine is
+ *	available to get character login names.
+ */
+/*#define HAS_CUSERID		/**/
+
+/* HAS_DBL_DIG:
+ *	This symbol, if defined, indicates that this system's <float.h>
+ *	or <limits.h> defines the symbol DBL_DIG, which is the number
+ *	of significant digits in a double precision number.  If this
+ *	symbol is not defined, a guess of 15 is usually pretty good.
+ */
+#define HAS_DBL_DIG 	/**/
+
+/* HAS_DIFFTIME:
+ *	This symbol, if defined, indicates that the difftime routine is
+ *	available.
+ */
+#define HAS_DIFFTIME		/**/
+
+/* HAS_DLERROR:
+ *	This symbol, if defined, indicates that the dlerror routine is
+ *	available to return a string describing the last error that
+ *	occurred from a call to dlopen(), dlclose() or dlsym().
+ */
+#define HAS_DLERROR	/**/
+
+/* SETUID_SCRIPTS_ARE_SECURE_NOW:
+ *	This symbol, if defined, indicates that the bug that prevents
+ *	setuid scripts from being secure is not present in this kernel.
+ */
+/* DOSUID:
+ *	This symbol, if defined, indicates that the C program should
+ *	check the script that it is executing for setuid/setgid bits, and
+ *	attempt to emulate setuid/setgid on systems that have disabled
+ *	setuid #! scripts because the kernel can't do it securely.
+ *	It is up to the package designer to make sure that this emulation
+ *	is done securely.  Among other things, it should do an fstat on
+ *	the script it just opened to make sure it really is a setuid/setgid
+ *	script, it should make sure the arguments passed correspond exactly
+ *	to the argument on the #! line, and it should not trust any
+ *	subprocesses to which it must pass the filename rather than the
+ *	file descriptor of the script to be executed.
+ */
+/*#define SETUID_SCRIPTS_ARE_SECURE_NOW	/**/
+/*#define DOSUID		/**/
+
+/* HAS_DUP2:
+ *	This symbol, if defined, indicates that the dup2 routine is
+ *	available to duplicate file descriptors.
+ */
+#define HAS_DUP2	/**/
+
+/* HAS_FCHMOD:
+ *	This symbol, if defined, indicates that the fchmod routine is available
+ *	to change mode of opened files.  If unavailable, use chmod().
+ */
+/*#define HAS_FCHMOD		/**/
+
+/* HAS_FCHOWN:
+ *	This symbol, if defined, indicates that the fchown routine is available
+ *	to change ownership of opened files.  If unavailable, use chown().
+ */
+/*#define HAS_FCHOWN		/**/
+
+/* HAS_FCNTL:
+ *	This symbol, if defined, indicates to the C program that
+ *	the fcntl() function exists.
+ */
+/*#define HAS_FCNTL		/**/
+
+/* HAS_FGETPOS:
+ *	This symbol, if defined, indicates that the fgetpos routine is
+ *	available to get the file position indicator, similar to ftell().
+ */
+#define HAS_FGETPOS	/**/
+
+/* FLEXFILENAMES:
+ *	This symbol, if defined, indicates that the system supports filenames
+ *	longer than 14 characters.
+ */
+#define	FLEXFILENAMES		/**/
+
+/* HAS_FLOCK:
+ *	This symbol, if defined, indicates that the flock routine is
+ *	available to do file locking.
+ */
+#define HAS_FLOCK		/**/
+
+/* HAS_FORK:
+ *	This symbol, if defined, indicates that the fork routine is
+ *	available.
+ */
+/*#define HAS_FORK		/**/
+
+/* HAS_FSETPOS:
+ *	This symbol, if defined, indicates that the fsetpos routine is
+ *	available to set the file position indicator, similar to fseek().
+ */
+#define HAS_FSETPOS	/**/
+
+/* HAS_GETTIMEOFDAY:
+ *	This symbol, if defined, indicates that the gettimeofday() system
+ *	call is available for a sub-second accuracy clock. Usually, the file
+ *	<sys/resource.h> needs to be included (see I_SYS_RESOURCE).
+ *	The type "Timeval" should be used to refer to "struct timeval".
+ */
+/*#define HAS_GETTIMEOFDAY	/**/
+#ifdef HAS_GETTIMEOFDAY
+#define Timeval struct timeval	/* Structure used by gettimeofday() */
+#endif
+
+/* HAS_GETGROUPS:
+ *	This symbol, if defined, indicates that the getgroups() routine is
+ *	available to get the list of process groups.  If unavailable, multiple
+ *	groups are probably not supported.
+ */
+/*#define HAS_GETGROUPS		/**/
+
+/* HAS_UNAME:
+ *	This symbol, if defined, indicates that the C program may use the
+ *	uname() routine to derive the host name.  See also HAS_GETHOSTNAME
+ *	and PHOSTNAME.
+ */
+/*#define HAS_UNAME		/**/
+
+/* HAS_GETLOGIN:
+ *	This symbol, if defined, indicates that the getlogin routine is
+ *	available to get the login name.
+ */
+#define HAS_GETLOGIN		/**/
+
+/* HAS_GETPGID:
+ *	This symbol, if defined, indicates to the C program that 
+ *	the getpgid(pid) function is available to get the
+ *	process group id.
+ */
+/*#define HAS_GETPGID		/**/
+
+/* HAS_GETPGRP:
+ *	This symbol, if defined, indicates that the getpgrp routine is
+ *	available to get the current process group.
+ */
+/* USE_BSD_GETPGRP:
+ *	This symbol, if defined, indicates that getpgrp needs one
+ *	arguments whereas USG one needs none.
+ */
+/*#define HAS_GETPGRP		/**/
+/*#define USE_BSD_GETPGRP	/**/
+
+/* HAS_GETPGRP2:
+ *	This symbol, if defined, indicates that the getpgrp2() (as in DG/UX)
+ *	routine is available to get the current process group.
+ */
+/*#define HAS_GETPGRP2		/**/
+
+/* HAS_GETPPID:
+ *	This symbol, if defined, indicates that the getppid routine is
+ *	available to get the parent process ID.
+ */
+/*#define HAS_GETPPID		/**/
+
+/* HAS_GETPRIORITY:
+ *	This symbol, if defined, indicates that the getpriority routine is
+ *	available to get a process's priority.
+ */
+/*#define HAS_GETPRIORITY		/**/
+
+/* HAS_HTONL:
+ *	This symbol, if defined, indicates that the htonl() routine (and
+ *	friends htons() ntohl() ntohs()) are available to do network
+ *	order byte swapping.
+ */
+/* HAS_HTONS:
+ *	This symbol, if defined, indicates that the htons() routine (and
+ *	friends htonl() ntohl() ntohs()) are available to do network
+ *	order byte swapping.
+ */
+/* HAS_NTOHL:
+ *	This symbol, if defined, indicates that the ntohl() routine (and
+ *	friends htonl() htons() ntohs()) are available to do network
+ *	order byte swapping.
+ */
+/* HAS_NTOHS:
+ *	This symbol, if defined, indicates that the ntohs() routine (and
+ *	friends htonl() htons() ntohl()) are available to do network
+ *	order byte swapping.
+ */
+#define HAS_HTONL		/**/
+#define HAS_HTONS		/**/
+#define HAS_NTOHL		/**/
+#define HAS_NTOHS		/**/
+
+/* HAS_INET_ATON:
+ *	This symbol, if defined, indicates to the C program that the
+ *	inet_aton() function is available to parse IP address "dotted-quad"
+ *	strings.
+ */
+/*#define HAS_INET_ATON		/**/
+
+/* HAS_KILLPG:
+ *	This symbol, if defined, indicates that the killpg routine is available
+ *	to kill process groups.  If unavailable, you probably should use kill
+ *	with a negative process number.
+ */
+/*#define HAS_KILLPG	/**/
+
+/* HAS_LINK:
+ *	This symbol, if defined, indicates that the link routine is
+ *	available to create hard links.
+ */
+/*#define HAS_LINK	/**/
+
+/* HAS_LOCALECONV:
+ *	This symbol, if defined, indicates that the localeconv routine is
+ *	available for numeric and monetary formatting conventions.
+ */
+#define HAS_LOCALECONV	/**/
+
+/* HAS_LOCKF:
+ *	This symbol, if defined, indicates that the lockf routine is
+ *	available to do file locking.
+ */
+/*#define HAS_LOCKF		/**/
+
+/* HAS_LSTAT:
+ *	This symbol, if defined, indicates that the lstat routine is
+ *	available to do file stats on symbolic links.
+ */
+/*#define HAS_LSTAT		/**/
+
+/* HAS_MBLEN:
+ *	This symbol, if defined, indicates that the mblen routine is available
+ *	to find the number of bytes in a multibye character.
+ */
+#define HAS_MBLEN		/**/
+
+/* HAS_MBSTOWCS:
+ *	This symbol, if defined, indicates that the mbstowcs routine is
+ *	available to covert a multibyte string into a wide character string.
+ */
+#define	HAS_MBSTOWCS		/**/
+
+/* HAS_MBTOWC:
+ *	This symbol, if defined, indicates that the mbtowc routine is available
+ *	to covert a multibyte to a wide character.
+ */
+#define HAS_MBTOWC		/**/
+
+/* HAS_MEMCMP:
+ *	This symbol, if defined, indicates that the memcmp routine is available
+ *	to compare blocks of memory.
+ */
+#define HAS_MEMCMP	/**/
+
+/* HAS_MEMCPY:
+ *	This symbol, if defined, indicates that the memcpy routine is available
+ *	to copy blocks of memory.
+ */
+#define HAS_MEMCPY	/**/
+
+/* HAS_MEMMOVE:
+ *	This symbol, if defined, indicates that the memmove routine is available
+ *	to copy potentially overlapping blocks of memory. This should be used
+ *	only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your
+ *	own version.
+ */
+#define HAS_MEMMOVE	/**/
+
+/* HAS_MEMSET:
+ *	This symbol, if defined, indicates that the memset routine is available
+ *	to set blocks of memory.
+ */
+#define HAS_MEMSET	/**/
+
+/* HAS_MKDIR:
+ *	This symbol, if defined, indicates that the mkdir routine is available
+ *	to create directories.  Otherwise you should fork off a new process to
+ *	exec /bin/mkdir.
+ */
+#define HAS_MKDIR		/**/
+
+/* HAS_MKFIFO:
+ *	This symbol, if defined, indicates that the mkfifo routine is
+ *	available to create FIFOs. Otherwise, mknod should be able to
+ *	do it for you. However, if mkfifo is there, mknod might require
+ *	super-user privileges which mkfifo will not.
+ */
+/*#define HAS_MKFIFO		/**/
+
+/* HAS_MKTIME:
+ *	This symbol, if defined, indicates that the mktime routine is
+ *	available.
+ */
+#define HAS_MKTIME		/**/
+
+/* HAS_MSG:
+ *	This symbol, if defined, indicates that the entire msg*(2) library is
+ *	supported (IPC mechanism based on message queues).
+ */
+/*#define HAS_MSG		/**/
+
+/* HAS_NICE:
+ *	This symbol, if defined, indicates that the nice routine is
+ *	available.
+ */
+/*#define HAS_NICE		/**/
+
+/* HAS_PATHCONF:
+ *	This symbol, if defined, indicates that pathconf() is available
+ *	to determine file-system related limits and options associated
+ *	with a given filename.
+ */
+/* HAS_FPATHCONF:
+ *	This symbol, if defined, indicates that pathconf() is available
+ *	to determine file-system related limits and options associated
+ *	with a given open file descriptor.
+ */
+/*#define HAS_PATHCONF		/**/
+/*#define HAS_FPATHCONF		/**/
+
+/* HAS_PAUSE:
+ *	This symbol, if defined, indicates that the pause routine is
+ *	available to suspend a process until a signal is received.
+ */
+#define HAS_PAUSE		/**/
+
+/* HAS_PIPE:
+ *	This symbol, if defined, indicates that the pipe routine is
+ *	available to create an inter-process channel.
+ */
+#define HAS_PIPE		/**/
+
+/* HAS_POLL:
+ *	This symbol, if defined, indicates that the poll routine is
+ *	available to poll active file descriptors. You may safely
+ *	include <poll.h> when this symbol is defined.
+ */
+/*#define HAS_POLL		/**/
+
+/* HAS_READDIR:
+ *	This symbol, if defined, indicates that the readdir routine is
+ *	available to read directory entries. You may have to include
+ *	<dirent.h>. See I_DIRENT.
+ */
+#define HAS_READDIR		/**/
+
+/* HAS_SEEKDIR:
+ *	This symbol, if defined, indicates that the seekdir routine is
+ *	available. You may have to include <dirent.h>. See I_DIRENT.
+ */
+#define HAS_SEEKDIR		/**/
+
+/* HAS_TELLDIR:
+ *	This symbol, if defined, indicates that the telldir routine is
+ *	available. You may have to include <dirent.h>. See I_DIRENT.
+ */
+#define HAS_TELLDIR		/**/
+
+/* HAS_REWINDDIR:
+ *	This symbol, if defined, indicates that the rewinddir routine is
+ *	available. You may have to include <dirent.h>. See I_DIRENT.
+ */
+#define HAS_REWINDDIR		/**/
+
+/* HAS_READLINK:
+ *	This symbol, if defined, indicates that the readlink routine is
+ *	available to read the value of a symbolic link.
+ */
+/*#define HAS_READLINK		/**/
+
+/* HAS_RENAME:
+ *	This symbol, if defined, indicates that the rename routine is available
+ *	to rename files.  Otherwise you should do the unlink(), link(), unlink()
+ *	trick.
+ */
+#define HAS_RENAME	/**/
+
+/* HAS_RMDIR:
+ *	This symbol, if defined, indicates that the rmdir routine is
+ *	available to remove directories. Otherwise you should fork off a
+ *	new process to exec /bin/rmdir.
+ */
+#define HAS_RMDIR		/**/
+
+/* HAS_SELECT:
+ *	This symbol, if defined, indicates that the select routine is
+ *	available to select active file descriptors. If the timeout field
+ *	is used, <sys/time.h> may need to be included.
+ */
+#define HAS_SELECT	/**/
+
+/* HAS_SEM:
+ *	This symbol, if defined, indicates that the entire sem*(2) library is
+ *	supported.
+ */
+/*#define HAS_SEM		/**/
+
+/* HAS_SETEGID:
+ *	This symbol, if defined, indicates that the setegid routine is available
+ *	to change the effective gid of the current program.
+ */
+/*#define HAS_SETEGID		/**/
+
+/* HAS_SETEUID:
+ *	This symbol, if defined, indicates that the seteuid routine is available
+ *	to change the effective uid of the current program.
+ */
+/*#define HAS_SETEUID		/**/
+
+/* HAS_SETLINEBUF:
+ *	This symbol, if defined, indicates that the setlinebuf routine is
+ *	available to change stderr or stdout from block-buffered or unbuffered
+ *	to a line-buffered mode.
+ */
+/*#define HAS_SETLINEBUF		/**/
+
+/* HAS_SETLOCALE:
+ *	This symbol, if defined, indicates that the setlocale routine is
+ *	available to handle locale-specific ctype implementations.
+ */
+#define HAS_SETLOCALE	/**/
+
+/* HAS_SETPGID:
+ *	This symbol, if defined, indicates that the setpgid(pid, gpid)
+ *	routine is available to set process group ID.
+ */
+/*#define HAS_SETPGID	/**/
+
+/* HAS_SETPGRP:
+ *	This symbol, if defined, indicates that the setpgrp routine is
+ *	available to set the current process group.
+ */
+/* USE_BSD_SETPGRP:
+ *	This symbol, if defined, indicates that setpgrp needs two
+ *	arguments whereas USG one needs none.  See also HAS_SETPGID
+ *	for a POSIX interface.
+ */
+/*#define HAS_SETPGRP		/**/
+/*#define USE_BSD_SETPGRP	/**/
+
+/* HAS_SETPGRP2:
+ *	This symbol, if defined, indicates that the setpgrp2() (as in DG/UX)
+ *	routine is available to set the current process group.
+ */
+/*#define HAS_SETPGRP2		/**/
+
+/* HAS_SETPRIORITY:
+ *	This symbol, if defined, indicates that the setpriority routine is
+ *	available to set a process's priority.
+ */
+/*#define HAS_SETPRIORITY		/**/
+
+/* HAS_SETREGID:
+ *	This symbol, if defined, indicates that the setregid routine is
+ *	available to change the real and effective gid of the current
+ *	process.
+ */
+/* HAS_SETRESGID:
+ *	This symbol, if defined, indicates that the setresgid routine is
+ *	available to change the real, effective and saved gid of the current
+ *	process.
+ */
+/*#define HAS_SETREGID		/**/
+/*#define HAS_SETRESGID		/**/
+
+/* HAS_SETREUID:
+ *	This symbol, if defined, indicates that the setreuid routine is
+ *	available to change the real and effective uid of the current
+ *	process.
+ */
+/* HAS_SETRESUID:
+ *	This symbol, if defined, indicates that the setresuid routine is
+ *	available to change the real, effective and saved uid of the current
+ *	process.
+ */
+/*#define HAS_SETREUID		/**/
+/*#define HAS_SETRESUID		/**/
+
+/* HAS_SETRGID:
+ *	This symbol, if defined, indicates that the setrgid routine is available
+ *	to change the real gid of the current program.
+ */
+/*#define HAS_SETRGID		/**/
+
+/* HAS_SETRUID:
+ *	This symbol, if defined, indicates that the setruid routine is available
+ *	to change the real uid of the current program.
+ */
+/*#define HAS_SETRUID		/**/
+
+/* HAS_SETSID:
+ *	This symbol, if defined, indicates that the setsid routine is
+ *	available to set the process group ID.
+ */
+/*#define HAS_SETSID	/**/
+
+/* HAS_SHM:
+ *	This symbol, if defined, indicates that the entire shm*(2) library is
+ *	supported.
+ */
+/*#define HAS_SHM		/**/
+
+/* Shmat_t:
+ *	This symbol holds the return type of the shmat() system call.
+ *	Usually set to 'void *' or 'char *'.
+ */
+/* HAS_SHMAT_PROTOTYPE:
+ *	This symbol, if defined, indicates that the sys/shm.h includes
+ *	a prototype for shmat().  Otherwise, it is up to the program to
+ *	guess one.  Shmat_t shmat _((int, Shmat_t, int)) is a good guess,
+ *	but not always right so it should be emitted by the program only
+ *	when HAS_SHMAT_PROTOTYPE is not defined to avoid conflicting defs.
+ */
+#define Shmat_t void *	/**/
+/*#define HAS_SHMAT_PROTOTYPE	/**/
+
+/* USE_STAT_BLOCKS:
+ *	This symbol is defined if this system has a stat structure declaring
+ *	st_blksize and st_blocks.
+ */
+/*#define USE_STAT_BLOCKS 	/**/
+
+/* HAS_STRCHR:
+ *	This symbol is defined to indicate that the strchr()/strrchr()
+ *	functions are available for string searching. If not, try the
+ *	index()/rindex() pair.
+ */
+/* HAS_INDEX:
+ *	This symbol is defined to indicate that the index()/rindex()
+ *	functions are available for string searching.
+ */
+#define HAS_STRCHR	/**/
+/*#define HAS_INDEX	/**/
+
+/* HAS_STRCOLL:
+ *	This symbol, if defined, indicates that the strcoll routine is
+ *	available to compare strings using collating information.
+ */
+#define HAS_STRCOLL	/**/
+
+/* USE_STRUCT_COPY:
+ *	This symbol, if defined, indicates that this C compiler knows how
+ *	to copy structures.  If undefined, you'll need to use a block copy
+ *	routine of some sort instead.
+ */
+#define	USE_STRUCT_COPY	/**/
+
+/* HAS_STRERROR:
+ *	This symbol, if defined, indicates that the strerror routine is
+ *	available to translate error numbers to strings. See the writeup
+ *	of Strerror() in this file before you try to define your own.
+ */
+/* HAS_SYS_ERRLIST:
+ *	This symbol, if defined, indicates that the sys_errlist array is
+ *	available to translate error numbers to strings. The extern int
+ *	sys_nerr gives the size of that table.
+ */
+/* Strerror:
+ *	This preprocessor symbol is defined as a macro if strerror() is
+ *	not available to translate error numbers to strings but sys_errlist[]
+ *	array is there.
+ */
+#define HAS_STRERROR		/**/
+#define HAS_SYS_ERRLIST	/**/
+#define Strerror(e) strerror(e)
+
+/* HAS_STRTOD:
+ *	This symbol, if defined, indicates that the strtod routine is
+ *	available to provide better numeric string conversion than atof().
+ */
+#define HAS_STRTOD	/**/
+
+/* HAS_STRTOL:
+ *	This symbol, if defined, indicates that the strtol routine is available
+ *	to provide better numeric string conversion than atoi() and friends.
+ */
+#define HAS_STRTOL	/**/
+
+/* HAS_STRTOUL:
+ *	This symbol, if defined, indicates that the strtoul routine is
+ *	available to provide conversion of strings to unsigned long.
+ */
+#define HAS_STRTOUL	/**/
+
+/* HAS_STRXFRM:
+ *	This symbol, if defined, indicates that the strxfrm() routine is
+ *	available to transform strings.
+ */
+#define HAS_STRXFRM	/**/
+
+/* HAS_SYMLINK:
+ *	This symbol, if defined, indicates that the symlink routine is available
+ *	to create symbolic links.
+ */
+/*#define HAS_SYMLINK	/**/
+
+/* HAS_SYSCALL:
+ *	This symbol, if defined, indicates that the syscall routine is
+ *	available to call arbitrary system calls. If undefined, that's tough.
+ */
+/*#define HAS_SYSCALL	/**/
+
+/* HAS_SYSCONF:
+ *	This symbol, if defined, indicates that sysconf() is available
+ *	to determine system related limits and options.
+ */
+/*#define HAS_SYSCONF	/**/
+
+/* HAS_SYSTEM:
+ *	This symbol, if defined, indicates that the system routine is
+ *	available to issue a shell command.
+ */
+#define HAS_SYSTEM	/**/
+
+/* HAS_TCGETPGRP:
+ *	This symbol, if defined, indicates that the tcgetpgrp routine is
+ *	available to get foreground process group ID.
+ */
+/*#define HAS_TCGETPGRP		/**/
+
+/* HAS_TCSETPGRP:
+ *	This symbol, if defined, indicates that the tcsetpgrp routine is
+ *	available to set foreground process group ID.
+ */
+/*#define HAS_TCSETPGRP		/**/
+
+/* HAS_TRUNCATE:
+ *	This symbol, if defined, indicates that the truncate routine is
+ *	available to truncate files.
+ */
+/*#define HAS_TRUNCATE	/**/
+
+/* HAS_TZNAME:
+ *	This symbol, if defined, indicates that the tzname[] array is
+ *	available to access timezone names.
+ */
+/*#define HAS_TZNAME		/**/
+
+/* HAS_UMASK:
+ *	This symbol, if defined, indicates that the umask routine is
+ *	available to set and get the value of the file creation mask.
+ */
+#define HAS_UMASK		/**/
+
+/* HAS_VFORK:
+ *	This symbol, if defined, indicates that vfork() exists.
+ */
+/*#define HAS_VFORK	/**/
+
+/* HASVOLATILE:
+ *	This symbol, if defined, indicates that this C compiler knows about
+ *	the volatile declaration.
+ */
+#define	HASVOLATILE	/**/
+#ifndef HASVOLATILE
+#define volatile
+#endif
+
+/* HAS_WAIT4:
+ *	This symbol, if defined, indicates that wait4() exists.
+ */
+/*#define HAS_WAIT4	/**/
+
+/* HAS_WAITPID:
+ *	This symbol, if defined, indicates that the waitpid routine is
+ *	available to wait for child process.
+ */
+#define HAS_WAITPID	/**/
+
+/* HAS_WCSTOMBS:
+ *	This symbol, if defined, indicates that the wcstombs routine is
+ *	available to convert wide character strings to multibyte strings.
+ */
+#define HAS_WCSTOMBS	/**/
+
+/* HAS_WCTOMB:
+ *	This symbol, if defined, indicates that the wctomb routine is available
+ *	to covert a wide character to a multibyte.
+ */
+#define HAS_WCTOMB		/**/
+
+/* I_ARPA_INET:
+ *	This symbol, if defined, indicates that <arpa/inet.h> exists and should
+ *	be included.
+ */
+/*#define I_ARPA_INET	/**/
+
+/* I_DBM:
+ *	This symbol, if defined, indicates that <dbm.h> exists and should
+ *	be included.
+ */
+/* I_RPCSVC_DBM:
+ *	This symbol, if defined, indicates that <rpcsvc/dbm.h> exists and
+ *	should be included.
+ */
+/*#define I_DBM	/**/
+#define I_RPCSVC_DBM	/**/
+
+/* I_DIRENT:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <dirent.h>. Using this symbol also triggers the definition
+ *	of the Direntry_t define which ends up being 'struct dirent' or
+ *	'struct direct' depending on the availability of <dirent.h>.
+ */
+/* DIRNAMLEN:
+ *	This symbol, if defined, indicates to the C program that the length
+ *	of directory entry names is provided by a d_namlen field.  Otherwise
+ *	you need to do strlen() on the d_name field.
+ */
+/* Direntry_t:
+ *	This symbol is set to 'struct direct' or 'struct dirent' depending on
+ *	whether dirent is available or not. You should use this pseudo type to
+ *	portably declare your directory entries.
+ */
+#define I_DIRENT		/**/
+#define DIRNAMLEN	/**/
+#define Direntry_t struct direct
+
+/* I_DLFCN:
+ *	This symbol, if defined, indicates that <dlfcn.h> exists and should
+ *	be included.
+ */
+#define I_DLFCN		/**/
+
+/* I_FCNTL:
+ *	This manifest constant tells the C program to include <fcntl.h>.
+ */
+#define I_FCNTL	/**/
+
+/* I_FLOAT:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <float.h> to get definition of symbols like DBL_MAX or
+ *	DBL_MIN, i.e. machine dependent floating point values.
+ */
+#define I_FLOAT		/**/
+
+/* I_GRP:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <grp.h>.
+ */
+/* GRPASSWD:
+ *	This symbol, if defined, indicates to the C program that struct group
+ *	contains gr_passwd.
+ */
+/* HAS_SETGRENT:
+ *	This symbol, if defined, indicates that the getgrent routine is
+ *	available for initializing sequential access of the group database.
+ */
+/* HAS_GETGRENT:
+ *	This symbol, if defined, indicates that the getgrent routine is
+ *	available for sequential access of the group database.
+ */
+/* HAS_ENDGRENT:
+ *	This symbol, if defined, indicates that the getgrent routine is
+ *	available for finalizing sequential access of the group database.
+ */
+/*#define I_GRP		/**/
+/*#define GRPASSWD	/**/
+/*#define HAS_SETGRENT	/**/
+/*#define HAS_GETGRENT	/**/
+/*#define HAS_ENDGRENT	/**/
+
+/* I_LIMITS:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <limits.h> to get definition of symbols like WORD_BIT or
+ *	LONG_MAX, i.e. machine dependant limitations.
+ */
+#define I_LIMITS		/**/
+
+/* I_LOCALE:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <locale.h>.
+ */
+#define	I_LOCALE		/**/
+
+/* I_MATH:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <math.h>.
+ */
+#define I_MATH		/**/
+
+/* I_MEMORY:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <memory.h>.
+ */
+/*#define I_MEMORY		/**/
+
+/* I_NDBM:
+ *	This symbol, if defined, indicates that <ndbm.h> exists and should
+ *	be included.
+ */
+/*#define I_NDBM	/**/
+
+/* I_NET_ERRNO:
+ *	This symbol, if defined, indicates that <net/errno.h> exists and 
+ *	should be included.
+ */
+/*#define I_NET_ERRNO		/**/
+
+/* I_NETINET_IN:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <netinet/in.h>. Otherwise, you may try <sys/in.h>.
+ */
+/*#define I_NETINET_IN	/**/
+
+/* I_SFIO:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sfio.h>.
+ */
+/*#define	I_SFIO		/**/
+
+/* I_STDDEF:
+ *	This symbol, if defined, indicates that <stddef.h> exists and should
+ *	be included.
+ */
+#define I_STDDEF	/**/
+
+/* I_STDLIB:
+ *	This symbol, if defined, indicates that <stdlib.h> exists and should
+ *	be included.
+ */
+#define I_STDLIB		/**/
+
+/* I_STRING:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <string.h> (USG systems) instead of <strings.h> (BSD systems).
+ */
+#define I_STRING		/**/
+
+/* I_SYS_DIR:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/dir.h>.
+ */
+/*#define I_SYS_DIR		/**/
+
+/* I_SYS_FILE:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/file.h> to get definition of R_OK and friends.
+ */
+/*#define I_SYS_FILE		/**/
+
+/* I_SYS_IOCTL:
+ *	This symbol, if defined, indicates that <sys/ioctl.h> exists and should
+ *	be included. Otherwise, include <sgtty.h> or <termio.h>.
+ */
+/*#define	I_SYS_IOCTL		/**/
+
+/* I_SYS_NDIR:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/ndir.h>.
+ */
+/*#define I_SYS_NDIR	/**/
+
+/* I_SYS_PARAM:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/param.h>.
+ */
+/*#define I_SYS_PARAM		/**/
+
+/* I_SYS_RESOURCE:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/resource.h>.
+ */
+/*#define I_SYS_RESOURCE		/**/
+
+/* I_SYS_SELECT:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/select.h> in order to get definition of struct timeval.
+ */
+/*#define I_SYS_SELECT	/**/
+
+/* I_SYS_STAT:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/stat.h>.
+ */
+#define	I_SYS_STAT		/**/
+
+/* I_SYS_TIMES:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/times.h>.
+ */
+/*#define	I_SYS_TIMES		/**/
+
+/* I_SYS_TYPES:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/types.h>.
+ */
+#define	I_SYS_TYPES		/**/
+
+/* I_SYS_UN:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/un.h> to get UNIX domain socket definitions.
+ */
+/*#define I_SYS_UN		/**/
+
+/* I_SYS_WAIT:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/wait.h>.
+ */
+/*#define I_SYS_WAIT	/**/
+
+/* I_TERMIO:
+ *	This symbol, if defined, indicates that the program should include
+ *	<termio.h> rather than <sgtty.h>.  There are also differences in
+ *	the ioctl() calls that depend on the value of this symbol.
+ */
+/* I_TERMIOS:
+ *	This symbol, if defined, indicates that the program should include
+ *	the POSIX termios.h rather than sgtty.h or termio.h.
+ *	There are also differences in the ioctl() calls that depend on the
+ *	value of this symbol.
+ */
+/* I_SGTTY:
+ *	This symbol, if defined, indicates that the program should include
+ *	<sgtty.h> rather than <termio.h>.  There are also differences in
+ *	the ioctl() calls that depend on the value of this symbol.
+ */
+/*#define I_TERMIO		/**/
+/*#define I_TERMIOS		/**/
+/*#define I_SGTTY		/**/
+
+/* I_UNISTD:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <unistd.h>.
+ */
+/*#define I_UNISTD		/**/
+
+/* I_UTIME:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <utime.h>.
+ */
+#define I_UTIME		/**/
+
+/* I_VALUES:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <values.h> to get definition of symbols like MINFLOAT or
+ *	MAXLONG, i.e. machine dependant limitations.  Probably, you
+ *	should use <limits.h> instead, if it is available.
+ */
+/*#define I_VALUES		/**/
+
+/* I_STDARG:
+ *	This symbol, if defined, indicates that <stdarg.h> exists and should
+ *	be included.
+ */
+/* I_VARARGS:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <varargs.h>.
+ */
+#define I_STDARG		/**/
+/*#define I_VARARGS	/**/
+
+/* I_VFORK:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include vfork.h.
+ */
+/*#define I_VFORK	/**/
+
+/* CAN_PROTOTYPE:
+ *	If defined, this macro indicates that the C compiler can handle
+ *	function prototypes.
+ */
+/* _:
+ *	This macro is used to declare function parameters for folks who want
+ *	to make declarations with prototypes using a different style than
+ *	the above macros.  Use double parentheses.  For example:
+ *
+ *		int main _((int argc, char *argv[]));
+ */
+#define	CAN_PROTOTYPE	/**/
+#ifdef CAN_PROTOTYPE
+#define	_(args) args
+#else
+#define	_(args) ()
+#endif
+
+/* SH_PATH:
+ *	This symbol contains the full pathname to the shell used on this
+ *	on this system to execute Bourne shell scripts.  Usually, this will be
+ *	/bin/sh, though it's possible that some systems will have /bin/ksh,
+ *	/bin/pdksh, /bin/ash, /bin/bash, or even something such as
+ *	D:/bin/sh.exe.
+ */
+#define SH_PATH "cmd /x /c"  /**/
+
+/* STDCHAR:
+ *	This symbol is defined to be the type of char used in stdio.h.
+ *	It has the values "unsigned char" or "char".
+ */
+#define STDCHAR char	/**/
+
+/* MEM_ALIGNBYTES:
+ *	 This symbol contains the number of bytes required to align a
+ *	 double. Usual values are 2, 4 and 8.
+ *	 On NeXT starting with 3.2, you can build "Fat" Multiple Architecture
+ *	 Binaries (MAB) for targets with varying alignment.  This only matters
+ *	 for perl, where the config.h can be generated and installed on one
+ *	 system, and used by a different architecture to build an extension.
+ *	 The default is eight, for safety.
+ */
+#define MEM_ALIGNBYTES 8	/**/
+
+/* BYTEORDER:
+ *	This symbol holds the hexadecimal constant defined in byteorder,
+ *	i.e. 0x1234 or 0x4321, etc...
+ *	On NeXT 3.2 (and greater), you can build "Fat" Multiple Architecture
+ *	Binaries (MAB) on either big endian or little endian machines.
+ *	The endian-ness is available at compile-time.  This only matters
+ *	for perl, where the config.h can be generated and installed on 
+ *	one system, and used by a different architecture to build an
+ *	extension.  Older versions of NeXT that might not have
+ *	defined either *_ENDIAN__ were all on Motorola 680x0 series,
+ *	so the default case (for NeXT) is big endian to catch them. 
+ *	This might matter for NeXT 3.0.
+ */
+#ifndef NeXT
+#define BYTEORDER 0x1234	/* large digits for MSB */
+#else  /* NeXT */
+#ifdef __LITTLE_ENDIAN__
+#define BYTEORDER 0x1234
+#else /* __BIG_ENDIAN__ */
+#define BYTEORDER 0x4321
+#endif /* ENDIAN CHECK */
+#endif /* NeXT */
+
+/* CASTI32:
+ *	This symbol is defined if the C compiler can cast negative
+ *	or large floating point numbers to 32-bit ints.
+ */
+#define	CASTI32		/**/
+
+/* CASTNEGFLOAT:
+ *	This symbol is defined if the C compiler can cast negative
+ *	numbers to unsigned longs, ints and shorts.
+ */
+/* CASTFLAGS:
+ *	This symbol contains flags that say what difficulties the compiler
+ *	has casting odd floating values to unsigned long:
+ *		0 = ok
+ *		1 = couldn't cast < 0
+ *		2 = couldn't cast >= 0x80000000
+ *		4 = couldn't cast in argument expression list
+ */
+#define	CASTNEGFLOAT		/**/
+#define CASTFLAGS 0		/**/
+
+/* VOID_CLOSEDIR:
+ *	This symbol, if defined, indicates that the closedir() routine
+ *	does not return a value.
+ */
+/*#define VOID_CLOSEDIR		/**/
+
+/* Gconvert:
+ *	This preprocessor macro is defined to convert a floating point
+ *	number to a string without a trailing decimal point.  This
+ *	emulates the behavior of sprintf("%g"), but is sometimes much more
+ *	efficient.  If gconvert() is not available, but gcvt() drops the
+ *	trailing decimal point, then gcvt() is used.  If all else fails,
+ *	a macro using sprintf("%g") is used. Arguments for the Gconvert
+ *	macro are: value, number of digits, whether trailing zeros should
+ *	be retained, and the output buffer.
+ *	Possible values are:
+ *		d_Gconvert='gconvert((x),(n),(t),(b))'
+ *		d_Gconvert='gcvt((x),(n),(b))'
+ *		d_Gconvert='sprintf((b),"%.*g",(n),(x))'
+ *	The last two assume trailing zeros should not be kept.
+ */
+#define Gconvert(x,n,t,b) sprintf((b),"%.*g",(n),(x))
+
+/* HAS_GNULIBC:
+ *	This symbol, if defined, indicates to the C program that 
+ *	the GNU C library is being used.
+ */
+/*#define HAS_GNULIBC  	/**/
+/* HAS_ISASCII:
+ *	This manifest constant lets the C program know that isascii 
+ *	is available.
+ */
+#define HAS_ISASCII		/**/
+
+/* HAS_LCHOWN:
+ *	This symbol, if defined, indicates that the lchown routine is
+ *	available to operate on a symbolic link (instead of following the
+ *	link).
+ */
+/*#define HAS_LCHOWN		/**/
+
+/* HAS_OPEN3:
+ *	This manifest constant lets the C program know that the three
+ *	argument form of open(2) is available.
+ */
+/*#define HAS_OPEN3		/**/
+
+/* HAS_SAFE_BCOPY:
+ *	This symbol, if defined, indicates that the bcopy routine is available
+ *	to copy potentially overlapping memory blocks. Otherwise you should
+ *	probably use memmove() or memcpy(). If neither is defined, roll your
+ *	own version.
+ */
+/*#define HAS_SAFE_BCOPY	/**/
+
+/* HAS_SAFE_MEMCPY:
+ *	This symbol, if defined, indicates that the memcpy routine is available
+ *	to copy potentially overlapping memory blocks. Otherwise you should
+ *	probably use memmove() or memcpy(). If neither is defined, roll your
+ *	own version.
+ */
+/*#define HAS_SAFE_MEMCPY	/**/
+
+/* HAS_SANE_MEMCMP:
+ *	This symbol, if defined, indicates that the memcmp routine is available
+ *	and can be used to compare relative magnitudes of chars with their high
+ *	bits set.  If it is not defined, roll your own version.
+ */
+#define HAS_SANE_MEMCMP	/**/
+
+/* HAS_SIGACTION:
+ *	This symbol, if defined, indicates that Vr4's sigaction() routine
+ *	is available.
+ */
+/*#define HAS_SIGACTION	/**/
+
+/* Sigjmp_buf:
+ *	This is the buffer type to be used with Sigsetjmp and Siglongjmp.
+ */
+/* Sigsetjmp:
+ *	This macro is used in the same way as sigsetjmp(), but will invoke
+ *	traditional setjmp() if sigsetjmp isn't available.
+ *	See HAS_SIGSETJMP.
+ */
+/* Siglongjmp:
+ *	This macro is used in the same way as siglongjmp(), but will invoke
+ *	traditional longjmp() if siglongjmp isn't available.
+ *	See HAS_SIGSETJMP.
+ */
+/*#define HAS_SIGSETJMP	/**/
+#ifdef HAS_SIGSETJMP
+#define Sigjmp_buf sigjmp_buf
+#define Sigsetjmp(buf,save_mask) sigsetjmp((buf),(save_mask))
+#define Siglongjmp(buf,retval) siglongjmp((buf),(retval))
+#else
+#define Sigjmp_buf jmp_buf
+#define Sigsetjmp(buf,save_mask) setjmp((buf))
+#define Siglongjmp(buf,retval) longjmp((buf),(retval))
+#endif
+
+/* USE_STDIO_PTR:
+ *	This symbol is defined if the _ptr and _cnt fields (or similar)
+ *	of the stdio FILE structure can be used to access the stdio buffer
+ *	for a file handle.  If this is defined, then the FILE_ptr(fp)
+ *	and FILE_cnt(fp) macros will also be defined and should be used
+ *	to access these fields.
+ */
+/* FILE_ptr:
+ *	This macro is used to access the _ptr field (or equivalent) of the
+ *	FILE structure pointed to by its argument. This macro will always be
+ *	defined if USE_STDIO_PTR is defined.
+ */
+/* STDIO_PTR_LVALUE:
+ *	This symbol is defined if the FILE_ptr macro can be used as an
+ *	lvalue.
+ */
+/* FILE_cnt:
+ *	This macro is used to access the _cnt field (or equivalent) of the
+ *	FILE structure pointed to by its argument. This macro will always be
+ *	defined if USE_STDIO_PTR is defined.
+ */
+/* STDIO_CNT_LVALUE:
+ *	This symbol is defined if the FILE_cnt macro can be used as an
+ *	lvalue.
+ */
+/*#define USE_STDIO_PTR 	/**/
+#ifdef USE_STDIO_PTR
+#define FILE_ptr(fp)	((fp)->_ptr)
+#define STDIO_PTR_LVALUE 		/**/
+#define FILE_cnt(fp)	((fp)->_cnt)
+#define STDIO_CNT_LVALUE 		/**/
+#endif
+
+/* USE_STDIO_BASE:
+ *	This symbol is defined if the _base field (or similar) of the
+ *	stdio FILE structure can be used to access the stdio buffer for
+ *	a file handle.  If this is defined, then the FILE_base(fp) macro
+ *	will also be defined and should be used to access this field.
+ *	Also, the FILE_bufsiz(fp) macro will be defined and should be used
+ *	to determine the number of bytes in the buffer.  USE_STDIO_BASE
+ *	will never be defined unless USE_STDIO_PTR is.
+ */
+/* FILE_base:
+ *	This macro is used to access the _base field (or equivalent) of the
+ *	FILE structure pointed to by its argument. This macro will always be
+ *	defined if USE_STDIO_BASE is defined.
+ */
+/* FILE_bufsiz:
+ *	This macro is used to determine the number of bytes in the I/O
+ *	buffer pointed to by _base field (or equivalent) of the FILE
+ *	structure pointed to its argument. This macro will always be defined
+ *	if USE_STDIO_BASE is defined.
+ */
+/*#define USE_STDIO_BASE 	/**/
+#ifdef USE_STDIO_BASE
+#define FILE_base(fp)	((fp)->_base)
+#define FILE_bufsiz(fp)	((fp)->_cnt + (fp)->_ptr - (fp)->_base)
+#endif
+
+/* HAS_VPRINTF:
+ *	This symbol, if defined, indicates that the vprintf routine is available
+ *	to printf with a pointer to an argument list.  If unavailable, you
+ *	may need to write your own, probably in terms of _doprnt().
+ */
+/* USE_CHAR_VSPRINTF:
+ *	This symbol is defined if this system has vsprintf() returning type
+ *	(char*).  The trend seems to be to declare it as "int vsprintf()".  It
+ *	is up to the package author to declare vsprintf correctly based on the
+ *	symbol.
+ */
+#define HAS_VPRINTF	/**/
+/*#define USE_CHAR_VSPRINTF 	/**/
+
+/* DOUBLESIZE:
+ *	This symbol contains the size of a double, so that the C preprocessor
+ *	can make decisions based on it.
+ */
+#define DOUBLESIZE 8		/**/
+
+/* I_TIME:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <time.h>.
+ */
+/* I_SYS_TIME:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/time.h>.
+ */
+/* I_SYS_TIME_KERNEL:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/time.h> with KERNEL defined.
+ */
+#define I_TIME		/**/
+/*#define I_SYS_TIME		/**/
+/*#define I_SYS_TIME_KERNEL		/**/
+
+/* INTSIZE:
+ *	This symbol contains the value of sizeof(int) so that the C
+ *	preprocessor can make decisions based on it.
+ */
+/* LONGSIZE:
+ *	This symbol contains the value of sizeof(long) so that the C
+ *	preprocessor can make decisions based on it.
+ */
+/* SHORTSIZE:
+ *	This symbol contains the value of sizeof(short) so that the C
+ *	preprocessor can make decisions based on it.
+ */
+#define INTSIZE 4		/**/
+#define LONGSIZE 4		/**/
+#define SHORTSIZE 2		/**/
+
+/* VAL_O_NONBLOCK:
+ *	This symbol is to be used during open() or fcntl(F_SETFL) to turn on
+ *	non-blocking I/O for the file descriptor. Note that there is no way
+ *	back, i.e. you cannot turn it blocking again this way. If you wish to
+ *	alternatively switch between blocking and non-blocking, use the
+ *	ioctl(FIOSNBIO) call instead, but that is not supported by all devices.
+ */
+/* VAL_EAGAIN:
+ *	This symbol holds the errno error code set by read() when no data was
+ *	present on the non-blocking file descriptor.
+ */
+/* RD_NODATA:
+ *	This symbol holds the return code from read() when no data is present
+ *	on the non-blocking file descriptor. Be careful! If EOF_NONBLOCK is
+ *	not defined, then you can't distinguish between no data and EOF by
+ *	issuing a read(). You'll have to find another way to tell for sure!
+ */
+/* EOF_NONBLOCK:
+ *	This symbol, if defined, indicates to the C program that a read() on
+ *	a non-blocking file descriptor will return 0 on EOF, and not the value
+ *	held in RD_NODATA (-1 usually, in that case!).
+ */
+#define VAL_O_NONBLOCK O_NONBLOCK
+#define VAL_EAGAIN EAGAIN
+#define RD_NODATA -1
+#define EOF_NONBLOCK
+
+/* PTRSIZE:
+ *	This symbol contains the size of a pointer, so that the C preprocessor
+ *	can make decisions based on it.  It will be sizeof(void *) if
+ *	the compiler supports (void *); otherwise it will be
+ *	sizeof(char *).
+ */
+#define PTRSIZE 4		/**/
+
+/* RANDBITS:
+ *	This symbol contains the number of bits of random number the rand()
+ *	function produces.  Usual values are 15, 16, and 31.
+ */
+#define RANDBITS 15		/**/
+
+/* SSize_t:
+ *	This symbol holds the type used by functions that return
+ *	a count of bytes or an error condition.  It must be a signed type.
+ *	It is usually ssize_t, but may be long or int, etc.
+ *	It may be necessary to include <sys/types.h> or <unistd.h>
+ *	to get any typedef'ed information.
+ *	We will pick a type such that sizeof(SSize_t) == sizeof(Size_t).
+ */
+#define SSize_t int	 /* signed count of bytes */
+
+/* OSNAME:
+ *	This symbol contains the name of the operating system, as determined
+ *	by Configure.  You shouldn't rely on it too much; the specific
+ *	feature tests from Configure are generally more reliable.
+ */
+#define OSNAME "MSWin32"		/**/
+
+/* CAT2:
+ *	This macro catenates 2 tokens together.
+ */
+/* STRINGIFY:
+ *	This macro surrounds its token with double quotes.
+ */
+#if 42 == 1
+#define CAT2(a,b)a/**/b
+#define STRINGIFY(a)"a"
+		/* If you can get stringification with catify, tell me how! */
+#endif
+#if 42 == 42
+#define CAT2(a,b)a ## b
+#define StGiFy(a)# a
+#define STRINGIFY(a)StGiFy(a)
+#endif
+#if 42 != 1 && 42 != 42
+#include "Bletch: How does this C preprocessor catenate tokens?"
+#endif
+
+/* CSH:
+ *	This symbol, if defined, contains the full pathname of csh.
+ */
+/*#define HAS_CSH		/**/
+#ifdef HAS_CSH
+#define CSH ""	/**/
+#endif
+
+/* HAS_ENDHOSTENT:
+ *	This symbol, if defined, indicates that the endhostent() routine is
+ *	available to close whatever was being used for host queries.
+ */
+/*#define HAS_ENDHOSTENT		/**/
+
+/* HAS_ENDNETENT:
+ *	This symbol, if defined, indicates that the endnetent() routine is
+ *	available to close whatever was being used for network queries.
+ */
+/*#define HAS_ENDNETENT		/**/
+
+/* HAS_ENDPROTOENT:
+ *	This symbol, if defined, indicates that the endprotoent() routine is
+ *	available to close whatever was being used for protocol queries.
+ */
+/*#define HAS_ENDPROTOENT		/**/
+
+/* HAS_ENDSERVENT:
+ *	This symbol, if defined, indicates that the endservent() routine is
+ *	available to close whatever was being used for service queries.
+ */
+/*#define HAS_ENDSERVENT		/**/
+
+/* HAS_GETHOSTBYADDR:
+ *	This symbol, if defined, indicates that the gethostbyaddr() routine is
+ *	available to look up hosts by their IP addresses.
+ */
+#define HAS_GETHOSTBYADDR		/**/
+
+/* HAS_GETHOSTBYNAME:
+ *	This symbol, if defined, indicates that the gethostbyname() routine is
+ *	available to look up host names in some data base or other.
+ */
+#define HAS_GETHOSTBYNAME		/**/
+
+/* HAS_GETHOSTENT:
+ *	This symbol, if defined, indicates that the gethostent() routine is
+ *	available to look up host names in some data base or another.
+ */
+/*#define HAS_GETHOSTENT		/**/
+
+/* HAS_GETNETBYADDR:
+ *	This symbol, if defined, indicates that the getnetbyaddr() routine is
+ *	available to look up networks by their IP addresses.
+ */
+/*#define HAS_GETNETBYADDR		/**/
+
+/* HAS_GETNETBYNAME:
+ *	This symbol, if defined, indicates that the getnetbyname() routine is
+ *	available to look up networks by their names.
+ */
+/*#define HAS_GETNETBYNAME		/**/
+
+/* HAS_GETNETENT:
+ *	This symbol, if defined, indicates that the getnetent() routine is
+ *	available to look up network names in some data base or another.
+ */
+/*#define HAS_GETNETENT		/**/
+
+/* HAS_GETPROTOENT:
+ *	This symbol, if defined, indicates that the getprotoent() routine is
+ *	available to look up protocols in some data base or another.
+ */
+/*#define HAS_GETPROTOENT		/**/
+
+/* HAS_GETPROTOBYNAME:
+ *	This symbol, if defined, indicates that the getprotobyname()
+ *	routine is available to look up protocols by their name.
+ */
+/* HAS_GETPROTOBYNUMBER:
+ *	This symbol, if defined, indicates that the getprotobynumber()
+ *	routine is available to look up protocols by their number.
+ */
+#define HAS_GETPROTOBYNAME		/**/
+#define HAS_GETPROTOBYNUMBER		/**/
+
+/* HAS_GETSERVENT:
+ *	This symbol, if defined, indicates that the getservent() routine is
+ *	available to look up network services in some data base or another.
+ */
+/*#define HAS_GETSERVENT		/**/
+
+/* HAS_GETSERVBYNAME:
+ *	This symbol, if defined, indicates that the getservbyname()
+ *	routine is available to look up services by their name.
+ */
+/* HAS_GETSERVBYPORT:
+ *	This symbol, if defined, indicates that the getservbyport()
+ *	routine is available to look up services by their port.
+ */
+#define HAS_GETSERVBYNAME		/**/
+#define HAS_GETSERVBYPORT		/**/
+
+/* HAS_LONG_DOUBLE:
+ *	This symbol will be defined if the C compiler supports long
+ *	doubles.
+ */
+/* LONG_DOUBLESIZE:
+ *	This symbol contains the size of a long double, so that the 
+ *	C preprocessor can make decisions based on it.  It is only
+ *	defined if the system supports long doubles.
+ */
+#define HAS_LONG_DOUBLE		/**/
+#ifdef HAS_LONG_DOUBLE
+#define LONG_DOUBLESIZE 12		/**/
+#endif
+
+/* HAS_LONG_LONG:
+ *	This symbol will be defined if the C compiler supports
+ *	long long.
+ */
+/* LONGLONGSIZE:
+ *	This symbol contains the size of a long long, so that the 
+ *	C preprocessor can make decisions based on it.  It is only
+ *	defined if the system supports long long.
+ */
+/*#define HAS_LONG_LONG		/**/
+#ifdef HAS_LONG_LONG
+#define LONGLONGSIZE 8		/**/
+#endif
+
+/* HAS_SETGROUPS:
+ *	This symbol, if defined, indicates that the setgroups() routine is
+ *	available to set the list of process groups.  If unavailable, multiple
+ *	groups are probably not supported.
+ */
+/*#define HAS_SETGROUPS		/**/
+
+/* HAS_SETHOSTENT:
+ *	This symbol, if defined, indicates that the sethostent() routine is
+ *	available.
+ */
+/*#define HAS_SETHOSTENT		/**/
+
+/* HAS_SETNETENT:
+ *	This symbol, if defined, indicates that the setnetent() routine is
+ *	available.
+ */
+/*#define HAS_SETNETENT		/**/
+
+/* HAS_SETPROTOENT:
+ *	This symbol, if defined, indicates that the setprotoent() routine is
+ *	available.
+ */
+/*#define HAS_SETPROTOENT		/**/
+
+/* HAS_SETSERVENT:
+ *	This symbol, if defined, indicates that the setservent() routine is
+ *	available.
+ */
+/*#define HAS_SETSERVENT		/**/
+
+/* HAS_SETVBUF:
+ *	This symbol, if defined, indicates that the setvbuf routine is
+ *	available to change buffering on an open stdio stream.
+ *	to a line-buffered mode.
+ */
+#define HAS_SETVBUF		/**/
+
+/* HAS_SOCKET:
+ *	This symbol, if defined, indicates that the BSD socket interface is
+ *	supported.
+ */
+/* HAS_SOCKETPAIR:
+ *	This symbol, if defined, indicates that the BSD socketpair() call is
+ *	supported.
+ */
+#define HAS_SOCKET		/**/
+/*#define HAS_SOCKETPAIR	/**/
+
+/* HAS_UNION_SEMUN:
+ *	This symbol, if defined, indicates that the union semun is
+ *	defined by including <sys/sem.h>.  If not, the user code
+ *	probably needs to define it as:
+ *	union semun {
+ *	    int val;
+ *	    struct semid_ds *buf;
+ *	    unsigned short *array;
+ *	}
+ */
+/* USE_SEMCTL_SEMUN:
+ *	This symbol, if defined, indicates that union semun is
+ *	used for semctl IPC_STAT.
+ */
+/* USE_SEMCTL_SEMID_DS:
+ *	This symbol, if defined, indicates that struct semid_ds * is
+ *	used for semctl IPC_STAT.
+ */
+#define HAS_UNION_SEMUN	/**/
+/*#define USE_SEMCTL_SEMUN	/**/
+/*#define USE_SEMCTL_SEMID_DS	/**/
+
+/* Signal_t:
+ *	This symbol's value is either "void" or "int", corresponding to the
+ *	appropriate return type of a signal handler.  Thus, you can declare
+ *	a signal handler using "Signal_t (*handler)()", and define the
+ *	handler using "Signal_t handler(sig)".
+ */
+#define Signal_t void	/* Signal handler's return type */
+
+/* Groups_t:
+ *	This symbol holds the type used for the second argument to
+ *	getgroups() and setgropus().  Usually, this is the same as
+ *	gidtype (gid_t) , but sometimes it isn't.
+ *	It can be int, ushort, uid_t, etc... 
+ *	It may be necessary to include <sys/types.h> to get any 
+ *	typedef'ed information.  This is only required if you have
+ *	getgroups() or setgropus()..
+ */
+#if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
+#define Groups_t gid_t	/* Type for 2nd arg to [sg]etgroups() */
+#endif
+
+/* I_NETDB:
+ *	This symbol, if defined, indicates that <netdb.h> exists and
+ *	should be included.
+ */
+/*#define I_NETDB		/**/
+
+/* I_PWD:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <pwd.h>.
+ */
+/* PWQUOTA:
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_quota.
+ */
+/* PWAGE:
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_age.
+ */
+/* PWCHANGE:
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_change.
+ */
+/* PWCLASS:
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_class.
+ */
+/* PWEXPIRE:
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_expire.
+ */
+/* PWCOMMENT:
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_comment.
+ */
+/* PWGECOS:
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_gecos.
+ */
+/* PWPASSWD:
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_passwd.
+ */
+/* HAS_SETPWENT:
+ *	This symbol, if defined, indicates that the getpwrent routine is
+ *	available for initializing sequential access of the passwd database.
+ */
+/* HAS_GETPWENT:
+ *	This symbol, if defined, indicates that the getpwent routine is
+ *	available for sequential access of the password database.
+ */
+/* HAS_ENDPWENT:
+ *	This symbol, if defined, indicates that the getpwent routine is
+ *	available for finalizing sequential access of the passwd database.
+ */
+/*#define I_PWD		/**/
+/*#define PWQUOTA	/**/
+/*#define PWAGE	/**/
+/*#define PWCHANGE	/**/
+/*#define PWCLASS	/**/
+/*#define PWEXPIRE	/**/
+/*#define PWCOMMENT	/**/
+/*#define PWGECOS	/**/
+/*#define PWPASSWD	/**/
+/*#define HAS_SETPWENT	/**/
+/*#define HAS_GETPWENT	/**/
+/*#define HAS_ENDPWENT	/**/
+
+/* Free_t:
+ *	This variable contains the return type of free().  It is usually
+ * void, but occasionally int.
+ */
+/* Malloc_t:
+ *	This symbol is the type of pointer returned by malloc and realloc.
+ */
+#define Malloc_t void *			/**/
+#define Free_t void			/**/
+
+/* MYMALLOC:
+ *	This symbol, if defined, indicates that we're using our own malloc.
+ */
+/*#define MYMALLOC			/**/
+
+/* SIG_NAME:
+ *	This symbol contains a list of signal names in order of
+ *	signal number. This is intended
+ *	to be used as a static array initialization, like this:
+ *		char *sig_name[] = { SIG_NAME };
+ *	The signals in the list are separated with commas, and each signal
+ *	is surrounded by double quotes. There is no leading SIG in the signal
+ *	name, i.e. SIGQUIT is known as "QUIT".
+ *	Gaps in the signal numbers (up to NSIG) are filled in with NUMnn,
+ *	etc., where nn is the actual signal number (e.g. NUM37).
+ *	The signal number for sig_name[i] is stored in sig_num[i].
+ *	The last element is 0 to terminate the list with a NULL.  This
+ *	corresponds to the 0 at the end of the sig_num list.
+ */
+/* SIG_NUM:
+ *	This symbol contains a list of signal numbers, in the same order as the
+ *	SIG_NAME list. It is suitable for static array initialization, as in:
+ *		int sig_num[] = { SIG_NUM };
+ *	The signals in the list are separated with commas, and the indices
+ *	within that list and the SIG_NAME list match, so it's easy to compute
+ *	the signal name from a number or vice versa at the price of a small
+ *	dynamic linear lookup. 
+ *	Duplicates are allowed, but are moved to the end of the list.
+ *	The signal number corresponding to sig_name[i] is sig_number[i].
+ *	if (i < NSIG) then sig_number[i] == i.  
+ *	The last element is 0, corresponding to the 0 at the end of
+ *	the sig_name list.
+ */
+#define SIG_NAME "ZERO", "INT", "QUIT", "ILL", "FPE", "KILL", "SEGV", "PIPE", "ALRM", "TERM", "CHLD", "BREAK", "ABRT", "STOP", "CONT", "CLD", 0		/**/
+#define SIG_NUM  0, 2, 3, 4, 8, 9, 11, 13, 14, 15, 20, 21, 22, 23, 25, 20, 0			/**/
+
+/* VOIDFLAGS:
+ *	This symbol indicates how much support of the void type is given by this
+ *	compiler.  What various bits mean:
+ *
+ *	    1 = supports declaration of void
+ *	    2 = supports arrays of pointers to functions returning void
+ *	    4 = supports comparisons between pointers to void functions and
+ *		    addresses of void functions
+ *	    8 = suports declaration of generic void pointers
+ *
+ *	The package designer should define VOIDUSED to indicate the requirements
+ *	of the package.  This can be done either by #defining VOIDUSED before
+ *	including config.h, or by defining defvoidused in Myinit.U.  If the
+ *	latter approach is taken, only those flags will be tested.  If the
+ *	level of void support necessary is not present, defines void to int.
+ */
+#ifndef VOIDUSED
+#define VOIDUSED 15
+#endif
+#define VOIDFLAGS 15
+#if (VOIDFLAGS & VOIDUSED) != VOIDUSED
+#define void int		/* is void to be avoided? */
+#define M_VOID			/* Xenix strikes again */
+#endif
+
+/* ARCHLIB:
+ *	This variable, if defined, holds the name of the directory in
+ *	which the user wants to put architecture-dependent public
+ *	library files for perl5.  It is most often a local directory
+ *	such as /usr/local/lib.  Programs using this variable must be
+ *	prepared to deal with filename expansion.  If ARCHLIB is the
+ *	same as PRIVLIB, it is not defined, since presumably the
+ *	program already searches PRIVLIB.
+ */
+/* ARCHLIB_EXP:
+ *	This symbol contains the ~name expanded version of ARCHLIB, to be used
+ *	in programs that are not prepared to deal with ~ expansion at run-time.
+ */
+#define ARCHLIB "c:\\perl\\5.00503\\lib\\MSWin32-x86"		/**/
+/*#define ARCHLIB_EXP ""	/**/
+
+/* DLSYM_NEEDS_UNDERSCORE:
+ *	This symbol, if defined, indicates that we need to prepend an
+ *	underscore to the symbol name before calling dlsym().  This only
+ *	makes sense if you *have* dlsym, which we will presume is the
+ *	case if you're using dl_dlopen.xs.
+ */
+/*#define 	DLSYM_NEEDS_UNDERSCORE 	/**/
+
+/* USE_SFIO:
+ *	This symbol, if defined, indicates that sfio should
+ *	be used.
+ */
+/*#define	USE_SFIO		/**/
+
+/* USE_DYNAMIC_LOADING:
+ *	This symbol, if defined, indicates that dynamic loading of
+ *	some sort is available.
+ */
+#define USE_DYNAMIC_LOADING		/**/
+
+/* DB_Prefix_t:
+ *	This symbol contains the type of the prefix structure element
+ *	in the <db.h> header file.  In older versions of DB, it was
+ *	int, while in newer ones it is u_int32_t.
+ */
+/* DB_Hash_t:
+ *	This symbol contains the type of the prefix structure element
+ *	in the <db.h> header file.  In older versions of DB, it was
+ *	int, while in newer ones it is size_t.
+ */
+#define DB_Hash_t	int		/**/
+#define DB_Prefix_t	int  	/**/
+
+/* PRIVLIB:
+ *	This symbol contains the name of the private library for this package.
+ *	The library is private in the sense that it needn't be in anyone's
+ *	execution path, but it should be accessible by the world.  The program
+ *	should be prepared to do ~ expansion.
+ */
+/* PRIVLIB_EXP:
+ *	This symbol contains the ~name expanded version of PRIVLIB, to be used
+ *	in programs that are not prepared to deal with ~ expansion at run-time.
+ */
+#define PRIVLIB "c:\\perl\\5.00503\\lib"		/**/
+#define PRIVLIB_EXP (win32_get_privlib("5.00503"))	/**/
+
+/* SITEARCH:
+ *	This symbol contains the name of the private library for this package.
+ *	The library is private in the sense that it needn't be in anyone's
+ *	execution path, but it should be accessible by the world.  The program
+ *	should be prepared to do ~ expansion.
+ *	The standard distribution will put nothing in this directory.
+ *	Individual sites may place their own extensions and modules in
+ *	this directory.
+ */
+/* SITEARCH_EXP:
+ *	This symbol contains the ~name expanded version of SITEARCH, to be used
+ *	in programs that are not prepared to deal with ~ expansion at run-time.
+ */
+#define SITEARCH "c:\\perl\\site\\5.00503\\lib\\MSWin32-x86"		/**/
+/*#define SITEARCH_EXP ""	/**/
+
+/* SITELIB:
+ *	This symbol contains the name of the private library for this package.
+ *	The library is private in the sense that it needn't be in anyone's
+ *	execution path, but it should be accessible by the world.  The program
+ *	should be prepared to do ~ expansion.
+ *	The standard distribution will put nothing in this directory.
+ *	Individual sites may place their own extensions and modules in
+ *	this directory.
+ */
+/* SITELIB_EXP:
+ *	This symbol contains the ~name expanded version of SITELIB, to be used
+ *	in programs that are not prepared to deal with ~ expansion at run-time.
+ */
+#define SITELIB "c:\\perl\\site\\5.00503\\lib"		/**/
+#define SITELIB_EXP (win32_get_sitelib("5.00503"))	/**/
+
+/* STARTPERL:
+ *	This variable contains the string to put in front of a perl
+ *	script to make sure (one hopes) that it runs with perl and not
+ *	some shell.
+ */
+#define STARTPERL "#!perl"		/**/
+
+/* USE_PERLIO:
+ *	This symbol, if defined, indicates that the PerlIO abstraction should
+ *	be used throughout.  If not defined, stdio should be
+ *	used in a fully backward compatible manner.
+ */
+/*#define	USE_PERLIO		/**/
+
+/* HAS_GETHOST_PROTOS:
+ *	This symbol, if defined, indicates that <netdb.h> includes
+ *	prototypes for gethostent(), gethostbyname(), and
+ *	gethostbyaddr().  Otherwise, it is up to the program to guess
+ *	them.  See netdbtype.U for probing for various Netdb_xxx_t types.
+ */
+#define	HAS_GETHOST_PROTOS	/**/
+
+/* HAS_GETNET_PROTOS:
+ *	This symbol, if defined, indicates that <netdb.h> includes
+ *	prototypes for getnetent(), getnetbyname(), and
+ *	getnetbyaddr().  Otherwise, it is up to the program to guess
+ *	them.  See netdbtype.U for probing for various Netdb_xxx_t types.
+ */
+/*#define	HAS_GETNET_PROTOS	/**/
+
+/* HAS_GETPROTO_PROTOS:
+ *	This symbol, if defined, indicates that <netdb.h> includes
+ *	prototypes for getprotoent(), getprotobyname(), and
+ *	getprotobyaddr().  Otherwise, it is up to the program to guess
+ *	them.  See netdbtype.U for probing for various Netdb_xxx_t types.
+ */
+#define	HAS_GETPROTO_PROTOS	/**/
+
+/* HAS_GETSERV_PROTOS:
+ *	This symbol, if defined, indicates that <netdb.h> includes
+ *	prototypes for getservent(), getservbyname(), and
+ *	getservbyaddr().  Otherwise, it is up to the program to guess
+ *	them.  See netdbtype.U for probing for various Netdb_xxx_t types.
+ */
+#define	HAS_GETSERV_PROTOS	/**/
+
+/* Netdb_host_t:
+ *	This symbol holds the type used for the 1st argument
+ *	to gethostbyaddr().
+ */
+/* Netdb_hlen_t:
+ *	This symbol holds the type used for the 2nd argument
+ *	to gethostbyaddr().
+ */
+/* Netdb_name_t:
+ *	This symbol holds the type used for the argument to
+ *	gethostbyname().
+ */
+/* Netdb_net_t:
+ *	This symbol holds the type used for the 1st argument to
+ *	getnetbyaddr().
+ */
+#define Netdb_host_t		char * /**/
+#define Netdb_hlen_t		int /**/
+#define Netdb_name_t		char * /**/
+#define Netdb_net_t		long /**/
+
+/* Select_fd_set_t:
+ *	This symbol holds the type used for the 2nd, 3rd, and 4th
+ *	arguments to select.  Usually, this is 'fd_set *', if HAS_FD_SET
+ *	is defined, and 'int *' otherwise.  This is only useful if you 
+ *	have select(), of course.
+ */
+#define Select_fd_set_t 	Perl_fd_set *	/**/
+
+/* ARCHNAME:
+ *	This symbol holds a string representing the architecture name.
+ *	It may be used to construct an architecture-dependant pathname
+ *	where library files may be held under a private library, for
+ *	instance.
+ */
+#define ARCHNAME "MSWin32-x86"		/**/
+
+/* HAS_PTHREAD_YIELD:
+ *	This symbol, if defined, indicates that the pthread_yield 
+ *	routine is available to yield the execution of the current
+ *	thread.
+ */
+/* HAS_SCHED_YIELD:
+ *	This symbol, if defined, indicates that the sched_yield
+ *	routine is available to yield the execution of the current
+ *	thread.
+ */
+/*#define HAS_PTHREAD_YIELD	/**/
+/*#define HAS_SCHED_YIELD	/**/
+
+/* PTHREADS_CREATED_JOINABLE:
+ *	This symbol, if defined, indicates that pthreads are created
+ *	in the joinable (aka undetached) state.
+ */
+/*#define PTHREADS_CREATED_JOINABLE /**/
+
+/* USE_THREADS:
+ *	This symbol, if defined, indicates that Perl should
+ *	be built to use threads.
+ */
+/* OLD_PTHREADS_API:
+ *	This symbol, if defined, indicates that Perl should
+ *	be built to use the old draft POSIX threads API.
+ */
+/*#define	USE_THREADS		/**/
+/*#define	OLD_PTHREADS_API		/**/
+
+/* Time_t:
+ *	This symbol holds the type returned by time(). It can be long,
+ *	or time_t on BSD sites (in which case <sys/types.h> should be
+ *	included).
+ */
+#define Time_t time_t		/* Time type */
+
+/* HAS_TIMES:
+ *	This symbol, if defined, indicates that the times() routine exists.
+ *	Note that this became obsolete on some systems (SUNOS), which now
+ * use getrusage(). It may be necessary to include <sys/times.h>.
+ */
+#define HAS_TIMES		/**/
+
+/* Fpos_t:
+ *	This symbol holds the type used to declare file positions in libc.
+ *	It can be fpos_t, long, uint, etc... It may be necessary to include
+ *	<sys/types.h> to get any typedef'ed information.
+ */
+#define Fpos_t fpos_t		/* File position type */
+
+/* Gid_t:
+ *	This symbol holds the return type of getgid() and the type of
+ *	argument to setrgid() and related functions.  Typically,
+ *	it is the type of group ids in the kernel. It can be int, ushort,
+ *	uid_t, etc... It may be necessary to include <sys/types.h> to get
+ *	any typedef'ed information.
+ */
+#define Gid_t gid_t		/* Type for getgid(), etc... */
+
+/* Off_t:
+ *	This symbol holds the type used to declare offsets in the kernel.
+ *	It can be int, long, off_t, etc... It may be necessary to include
+ *	<sys/types.h> to get any typedef'ed information.
+ */
+#define Off_t off_t		/* <offset> type */
+
+/* Mode_t:
+ *	This symbol holds the type used to declare file modes 
+ *	for systems calls.  It is usually mode_t, but may be
+ *	int or unsigned short.  It may be necessary to include <sys/types.h>
+ *	to get any typedef'ed information.
+ */
+#define Mode_t mode_t	 /* file mode parameter for system calls */
+
+/* Pid_t:
+ *	This symbol holds the type used to declare process ids in the kernel.
+ *	It can be int, uint, pid_t, etc... It may be necessary to include
+ *	<sys/types.h> to get any typedef'ed information.
+ */
+#define Pid_t int		/* PID type */
+
+/* Size_t:
+ *	This symbol holds the type used to declare length parameters
+ *	for string functions.  It is usually size_t, but may be
+ *	unsigned long, int, etc.  It may be necessary to include
+ *	<sys/types.h> to get any typedef'ed information.
+ */
+#define Size_t size_t	 /* length paramater for string functions */
+
+/* Uid_t:
+ *	This symbol holds the type used to declare user ids in the kernel.
+ *	It can be int, ushort, uid_t, etc... It may be necessary to include
+ *	<sys/types.h> to get any typedef'ed information.
+ */
+#define Uid_t uid_t		/* UID type */
+
+#endif
+#include <win32.h>
diff --git a/gnu/usr.bin/perl/win32/des_fcrypt.patch b/gnu/usr.bin/perl/win32/des_fcrypt.patch
new file mode 100644
index 00000000000..7088e94a7ea
--- /dev/null
+++ b/gnu/usr.bin/perl/win32/des_fcrypt.patch
@@ -0,0 +1,75 @@
+You need the GNU `patch' utility to apply this patch.  Get:
+
+    ftp://fractal.mta.ca/pub/crypto/SSLeay/DES/libdes-3.06.tar.gz
+
+Uncompress it somewhere, and use the command line:
+
+    patch -p1 -N < this_file
+
+to apply the patch.  Move the fcrypt.c file to the win32 subdirectory
+of the Perl source distribution.
+
+--- libdes-3.06/fcrypt.c.dist	Tue Aug  4 18:41:49 1998
++++ libdes-3.06/fcrypt.c	Tue Aug  4 18:42:03 1998
+@@ -325,12 +325,15 @@
+ 
+ static char shifts2[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};
+ 
+-static int body();
+-static int des_set_key();
++static int body(
++	unsigned long *out0,
++	unsigned long *out1,
++	des_key_schedule ks,
++	unsigned long Eswap0,
++	unsigned long Eswap1);
+ 
+-static int des_set_key(key,schedule)
+-des_cblock *key;
+-des_key_schedule schedule;
++static int
++des_set_key(des_cblock *key, des_key_schedule schedule)
+ 	{
+ 	register unsigned long c,d,t,s;
+ 	register unsigned char *in;
+@@ -460,16 +463,14 @@
+ 0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A
+ };
+ 
+-char *crypt(buf,salt)
+-char *buf;
+-char *salt;
++char *
++des_fcrypt(const char *buf, const char *salt, char *buff)
+ 	{
+ 	unsigned int i,j,x,y;
+ 	unsigned long Eswap0=0,Eswap1=0;
+ 	unsigned long out[2],ll;
+ 	des_cblock key;
+ 	des_key_schedule ks;
+-	static unsigned char buff[20];
+ 	unsigned char bb[9];
+ 	unsigned char *b=bb;
+ 	unsigned char c,u;
+@@ -521,13 +522,15 @@
+ 		buff[i]=cov_2char[c];
+ 		}
+ 	buff[13]='\0';
+-	return((char *)buff);
++	return buff;
+ 	}
+ 
+-static int body(out0,out1,ks,Eswap0,Eswap1)
+-unsigned long *out0,*out1;
+-des_key_schedule *ks;
+-unsigned long Eswap0,Eswap1;
++static int 
++body(	unsigned long *out0,
++	unsigned long *out1,
++	des_key_schedule ks,
++	unsigned long Eswap0,
++	unsigned long Eswap1)
+ 	{
+ 	register unsigned long l,r,t,u,v;
+ #ifdef ALT_ECB
+End of Patch.
diff --git a/gnu/usr.bin/perl/win32/perlhost.h b/gnu/usr.bin/perl/win32/perlhost.h
new file mode 100644
index 00000000000..a0f7783019c
--- /dev/null
+++ b/gnu/usr.bin/perl/win32/perlhost.h
@@ -0,0 +1,941 @@
+
+#include "iperlsys.h"
+
+extern CPerlObj *pPerl;
+
+#define CALLFUNC0RET(x)\
+    int ret = x;\
+    if (ret < 0)\
+	err = errno;\
+    return ret;
+
+#define PROCESS_AND_RETURN  \
+    if (errno)		    \
+	err = errno;	    \
+    return r
+
+#define CALLFUNCRET(x)\
+    int ret = x;\
+    if (ret)\
+	err = errno;\
+    return ret;
+
+#define CALLFUNCERR(x)\
+    int ret = x;\
+    if (errno)\
+	err = errno;\
+    return ret;
+
+#define LCALLFUNCERR(x)\
+    long ret = x;\
+    if (errno)\
+	err = errno;\
+    return ret;
+
+class CPerlDir : public IPerlDir
+{
+public:
+    CPerlDir() {};
+    virtual int Makedir(const char *dirname, int mode, int &err)
+    {
+	CALLFUNC0RET(win32_mkdir(dirname, mode));
+    };
+    virtual int Chdir(const char *dirname, int &err)
+    {
+	CALLFUNC0RET(win32_chdir(dirname));
+    };
+    virtual int Rmdir(const char *dirname, int &err)
+    {
+	CALLFUNC0RET(win32_rmdir(dirname));
+    };
+    virtual int Close(DIR *dirp, int &err)
+    {
+	return win32_closedir(dirp);
+    };
+    virtual DIR *Open(char *filename, int &err)
+    {
+	return win32_opendir(filename);
+    };
+    virtual struct direct *Read(DIR *dirp, int &err)
+    {
+	return win32_readdir(dirp);
+    };
+    virtual void Rewind(DIR *dirp, int &err)
+    {
+	win32_rewinddir(dirp);
+    };
+    virtual void Seek(DIR *dirp, long loc, int &err)
+    {
+	win32_seekdir(dirp, loc);
+    };
+    virtual long Tell(DIR *dirp, int &err)
+    {
+	return win32_telldir(dirp);
+    };
+};
+
+
+extern char *		g_win32_get_privlib(char *pl);
+extern char *		g_win32_get_sitelib(char *pl);
+
+class CPerlEnv : public IPerlEnv
+{
+public:
+    CPerlEnv() {};
+    virtual char *Getenv(const char *varname, int &err)
+    {
+	return win32_getenv(varname);
+    };
+    virtual int Putenv(const char *envstring, int &err)
+    {
+	return win32_putenv(envstring);
+    };
+    virtual char* LibPath(char *pl)
+    {
+	return g_win32_get_privlib(pl);
+    };
+    virtual char* SiteLibPath(char *pl)
+    {
+	return g_win32_get_sitelib(pl);
+    };
+};
+
+class CPerlSock : public IPerlSock
+{
+public:
+    CPerlSock() {};
+    virtual u_long Htonl(u_long hostlong)
+    {
+	return win32_htonl(hostlong);
+    };
+    virtual u_short Htons(u_short hostshort)
+    {
+	return win32_htons(hostshort);
+    };
+    virtual u_long Ntohl(u_long netlong)
+    {
+	return win32_ntohl(netlong);
+    };
+    virtual u_short Ntohs(u_short netshort)
+    {
+	return win32_ntohs(netshort);
+    }
+
+    virtual SOCKET Accept(SOCKET s, struct sockaddr* addr, int* addrlen, int &err)
+    {
+	SOCKET r = win32_accept(s, addr, addrlen);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Bind(SOCKET s, const struct sockaddr* name, int namelen, int &err)
+    {
+	int r = win32_bind(s, name, namelen);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Connect(SOCKET s, const struct sockaddr* name, int namelen, int &err)
+    {
+	int r = win32_connect(s, name, namelen);
+	PROCESS_AND_RETURN;
+    };
+    virtual void Endhostent(int &err)
+    {
+	win32_endhostent();
+    };
+    virtual void Endnetent(int &err)
+    {
+	win32_endnetent();
+    };
+    virtual void Endprotoent(int &err)
+    {
+	win32_endprotoent();
+    };
+    virtual void Endservent(int &err)
+    {
+	win32_endservent();
+    };
+    virtual struct hostent* Gethostbyaddr(const char* addr, int len, int type, int &err)
+    {
+	struct hostent *r = win32_gethostbyaddr(addr, len, type);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct hostent* Gethostbyname(const char* name, int &err)
+    {
+	struct hostent *r = win32_gethostbyname(name);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct hostent* Gethostent(int &err)
+    {
+        croak("gethostent not implemented!\n");
+	return NULL;
+    };
+    virtual int Gethostname(char* name, int namelen, int &err)
+    {
+	int r = win32_gethostname(name, namelen);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct netent *Getnetbyaddr(long net, int type, int &err)
+    {
+	struct netent *r = win32_getnetbyaddr(net, type);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct netent *Getnetbyname(const char *name, int &err)
+    {
+	struct netent *r = win32_getnetbyname((char*)name);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct netent *Getnetent(int &err)
+    {
+	struct netent *r = win32_getnetent();
+	PROCESS_AND_RETURN;
+    };
+    virtual int Getpeername(SOCKET s, struct sockaddr* name, int* namelen, int &err)
+    {
+	int r = win32_getpeername(s, name, namelen);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct protoent* Getprotobyname(const char* name, int &err)
+    {
+	struct protoent *r = win32_getprotobyname(name);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct protoent* Getprotobynumber(int number, int &err)
+    {
+	struct protoent *r = win32_getprotobynumber(number);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct protoent* Getprotoent(int &err)
+    {
+	struct protoent *r = win32_getprotoent();
+	PROCESS_AND_RETURN;
+    };
+    virtual struct servent* Getservbyname(const char* name, const char* proto, int &err)
+    {
+	struct servent *r = win32_getservbyname(name, proto);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct servent* Getservbyport(int port, const char* proto, int &err)
+    {
+	struct servent *r = win32_getservbyport(port, proto);
+	PROCESS_AND_RETURN;
+    };
+    virtual struct servent* Getservent(int &err)
+    {
+	struct servent *r = win32_getservent();
+	PROCESS_AND_RETURN;
+    };
+    virtual int Getsockname(SOCKET s, struct sockaddr* name, int* namelen, int &err)
+    {
+	int r = win32_getsockname(s, name, namelen);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Getsockopt(SOCKET s, int level, int optname, char* optval, int* optlen, int &err)
+    {
+	int r = win32_getsockopt(s, level, optname, optval, optlen);
+	PROCESS_AND_RETURN;
+    };
+    virtual unsigned long InetAddr(const char* cp, int &err)
+    {
+	unsigned long r = win32_inet_addr(cp);
+	PROCESS_AND_RETURN;
+    };
+    virtual char* InetNtoa(struct in_addr in, int &err)
+    {
+	char *r = win32_inet_ntoa(in);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Listen(SOCKET s, int backlog, int &err)
+    {
+	int r = win32_listen(s, backlog);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Recv(SOCKET s, char* buffer, int len, int flags, int &err)
+    {
+	int r = win32_recv(s, buffer, len, flags);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Recvfrom(SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen, int &err)
+    {
+	int r = win32_recvfrom(s, buffer, len, flags, from, fromlen);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Select(int nfds, char* readfds, char* writefds, char* exceptfds, const struct timeval* timeout, int &err)
+    {
+	int r = win32_select(nfds, (Perl_fd_set*)readfds, (Perl_fd_set*)writefds, (Perl_fd_set*)exceptfds, timeout);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Send(SOCKET s, const char* buffer, int len, int flags, int &err)
+    {
+	int r = win32_send(s, buffer, len, flags);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Sendto(SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen, int &err)
+    {
+	int r = win32_sendto(s, buffer, len, flags, to, tolen);
+	PROCESS_AND_RETURN;
+    };
+    virtual void Sethostent(int stayopen, int &err)
+    {
+	win32_sethostent(stayopen);
+    };
+    virtual void Setnetent(int stayopen, int &err)
+    {
+	win32_setnetent(stayopen);
+    };
+    virtual void Setprotoent(int stayopen, int &err)
+    {
+	win32_setprotoent(stayopen);
+    };
+    virtual void Setservent(int stayopen, int &err)
+    {
+	win32_setservent(stayopen);
+    };
+    virtual int Setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen, int &err)
+    {
+	int r = win32_setsockopt(s, level, optname, optval, optlen);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Shutdown(SOCKET s, int how, int &err)
+    {
+	int r = win32_shutdown(s, how);
+	PROCESS_AND_RETURN;
+    };
+    virtual SOCKET Socket(int af, int type, int protocol, int &err)
+    {
+	SOCKET r = win32_socket(af, type, protocol);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Socketpair(int domain, int type, int protocol, int* fds, int &err)
+    {
+        croak("socketpair not implemented!\n");
+	return 0;
+    };
+    virtual int Closesocket(SOCKET s, int& err)
+    {
+	int r = win32_closesocket(s);
+	PROCESS_AND_RETURN;
+    };
+    virtual int Ioctlsocket(SOCKET s, long cmd, u_long *argp, int& err)
+    {
+	int r = win32_ioctlsocket(s, cmd, argp);
+	PROCESS_AND_RETURN;
+    };
+};
+
+class CPerlLIO : public IPerlLIO
+{
+public:
+    CPerlLIO() {};
+    virtual int Access(const char *path, int mode, int &err)
+    {
+	CALLFUNCRET(access(path, mode))
+    };
+    virtual int Chmod(const char *filename, int pmode, int &err)
+    {
+	CALLFUNCRET(chmod(filename, pmode))
+    };
+    virtual int Chown(const char *filename, uid_t owner, gid_t group, int &err)
+    {
+	CALLFUNCERR(chown(filename, owner, group))
+    };
+    virtual int Chsize(int handle, long size, int &err)
+    {
+	CALLFUNCRET(chsize(handle, size))
+    };
+    virtual int Close(int handle, int &err)
+    {
+	CALLFUNCRET(win32_close(handle))
+    };
+    virtual int Dup(int handle, int &err)
+    {
+	CALLFUNCERR(win32_dup(handle))
+    };
+    virtual int Dup2(int handle1, int handle2, int &err)
+    {
+	CALLFUNCERR(win32_dup2(handle1, handle2))
+    };
+    virtual int Flock(int fd, int oper, int &err)
+    {
+	CALLFUNCERR(win32_flock(fd, oper))
+    };
+    virtual int FileStat(int handle, struct stat *buffer, int &err)
+    {
+	CALLFUNCERR(fstat(handle, buffer))
+    };
+    virtual int IOCtl(int i, unsigned int u, char *data, int &err)
+    {
+	CALLFUNCERR(win32_ioctlsocket((SOCKET)i, (long)u, (u_long*)data))
+    };
+    virtual int Isatty(int fd, int &err)
+    {
+	return isatty(fd);
+    };
+    virtual long Lseek(int handle, long offset, int origin, int &err)
+    {
+	LCALLFUNCERR(win32_lseek(handle, offset, origin))
+    };
+    virtual int Lstat(const char *path, struct stat *buffer, int &err)
+    {
+	return NameStat(path, buffer, err);
+    };
+    virtual char *Mktemp(char *Template, int &err)
+    {
+	return mktemp(Template);
+    };
+    virtual int Open(const char *filename, int oflag, int &err)
+    {
+	CALLFUNCERR(win32_open(filename, oflag))
+    };
+    virtual int Open(const char *filename, int oflag, int pmode, int &err)
+    {
+	int ret;
+	if(stricmp(filename, "/dev/null") == 0)
+	    ret = open("NUL", oflag, pmode);
+	else
+	    ret = open(filename, oflag, pmode);
+
+	if(errno)
+	    err = errno;
+	return ret;
+    };
+    virtual int Read(int handle, void *buffer, unsigned int count, int &err)
+    {
+	CALLFUNCERR(win32_read(handle, buffer, count))
+    };
+    virtual int Rename(const char *OldFileName, const char *newname, int &err)
+    {
+	CALLFUNCRET(win32_rename(OldFileName, newname))
+    };
+    virtual int Setmode(int handle, int mode, int &err)
+    {
+	CALLFUNCRET(win32_setmode(handle, mode))
+    };
+    virtual int NameStat(const char *path, struct stat *buffer, int &err)
+    {
+	return win32_stat(path, buffer);
+    };
+    virtual char *Tmpnam(char *string, int &err)
+    {
+	return tmpnam(string);
+    };
+    virtual int Umask(int pmode, int &err)
+    {
+	return umask(pmode);
+    };
+    virtual int Unlink(const char *filename, int &err)
+    {
+	chmod(filename, S_IREAD | S_IWRITE);
+	CALLFUNCRET(unlink(filename))
+    };
+    virtual int Utime(char *filename, struct utimbuf *times, int &err)
+    {
+	CALLFUNCRET(win32_utime(filename, times))
+    };
+    virtual int Write(int handle, const void *buffer, unsigned int count, int &err)
+    {
+	CALLFUNCERR(win32_write(handle, buffer, count))
+    };
+};
+
+class CPerlMem : public IPerlMem
+{
+public:
+    CPerlMem() {};
+    virtual void* Malloc(size_t size)
+    {
+	return win32_malloc(size);
+    };
+    virtual void* Realloc(void* ptr, size_t size)
+    {
+	return win32_realloc(ptr, size);
+    };
+    virtual void Free(void* ptr)
+    {
+	win32_free(ptr);
+    };
+};
+
+#define EXECF_EXEC 1
+#define EXECF_SPAWN 2
+
+extern char *		g_getlogin(void);
+extern int		do_spawn2(char *cmd, int exectype);
+extern int		g_do_aspawn(void *vreally, void **vmark, void **vsp);
+
+class CPerlProc : public IPerlProc
+{
+public:
+    CPerlProc() {};
+    virtual void Abort(void)
+    {
+	win32_abort();
+    };
+    virtual char * Crypt(const char* clear, const char* salt)
+    {
+	return win32_crypt(clear, salt);
+    };
+    virtual void Exit(int status)
+    {
+	exit(status);
+    };
+    virtual void _Exit(int status)
+    {
+	_exit(status);
+    };
+    virtual int Execl(const char *cmdname, const char *arg0, const char *arg1, const char *arg2, const char *arg3)
+    {
+	return execl(cmdname, arg0, arg1, arg2, arg3);
+    };
+    virtual int Execv(const char *cmdname, const char *const *argv)
+    {
+	return win32_execvp(cmdname, argv);
+    };
+    virtual int Execvp(const char *cmdname, const char *const *argv)
+    {
+	return win32_execvp(cmdname, argv);
+    };
+    virtual uid_t Getuid(void)
+    {
+	return getuid();
+    };
+    virtual uid_t Geteuid(void)
+    {
+	return geteuid();
+    };
+    virtual gid_t Getgid(void)
+    {
+	return getgid();
+    };
+    virtual gid_t Getegid(void)
+    {
+	return getegid();
+    };
+    virtual char *Getlogin(void)
+    {
+	return g_getlogin();
+    };
+    virtual int Kill(int pid, int sig)
+    {
+	return win32_kill(pid, sig);
+    };
+    virtual int Killpg(int pid, int sig)
+    {
+	croak("killpg not implemented!\n");
+	return 0;
+    };
+    virtual int PauseProc(void)
+    {
+	return win32_sleep((32767L << 16) + 32767);
+    };
+    virtual PerlIO* Popen(const char *command, const char *mode)
+    {
+	win32_fflush(stdout);
+	win32_fflush(stderr);
+	return (PerlIO*)win32_popen(command, mode);
+    };
+    virtual int Pclose(PerlIO *stream)
+    {
+	return win32_pclose((FILE*)stream);
+    };
+    virtual int Pipe(int *phandles)
+    {
+	return win32_pipe(phandles, 512, O_BINARY);
+    };
+    virtual int Setuid(uid_t u)
+    {
+	return setuid(u);
+    };
+    virtual int Setgid(gid_t g)
+    {
+	return setgid(g);
+    };
+    virtual int Sleep(unsigned int s)
+    {
+	return win32_sleep(s);
+    };
+    virtual int Times(struct tms *timebuf)
+    {
+	return win32_times(timebuf);
+    };
+    virtual int Wait(int *status)
+    {
+	return win32_wait(status);
+    };
+    virtual int Waitpid(int pid, int *status, int flags)
+    {
+	return win32_waitpid(pid, status, flags);
+    };
+    virtual Sighandler_t Signal(int sig, Sighandler_t subcode)
+    {
+	return 0;
+    };
+    virtual void GetSysMsg(char*& sMsg, DWORD& dwLen, DWORD dwErr)
+    {
+	dwLen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
+			  |FORMAT_MESSAGE_IGNORE_INSERTS
+			  |FORMAT_MESSAGE_FROM_SYSTEM, NULL,
+			   dwErr, 0, (char *)&sMsg, 1, NULL);
+	if (0 < dwLen) {
+	    while (0 < dwLen  &&  isspace(sMsg[--dwLen]))
+		;
+	    if ('.' != sMsg[dwLen])
+		dwLen++;
+	    sMsg[dwLen]= '\0';
+	}
+	if (0 == dwLen) {
+	    sMsg = (char*)LocalAlloc(0, 64/**sizeof(TCHAR)*/);
+	    dwLen = sprintf(sMsg,
+			"Unknown error #0x%lX (lookup 0x%lX)",
+			dwErr, GetLastError());
+	}
+    };
+    virtual void FreeBuf(char* sMsg)
+    {
+	LocalFree(sMsg);
+    };
+    virtual BOOL DoCmd(char *cmd)
+    {
+	do_spawn2(cmd, EXECF_EXEC);
+        return FALSE;
+    };
+    virtual int Spawn(char* cmds)
+    {
+	return do_spawn2(cmds, EXECF_SPAWN);
+    };
+    virtual int Spawnvp(int mode, const char *cmdname, const char *const *argv)
+    {
+	return win32_spawnvp(mode, cmdname, argv);
+    };
+    virtual int ASpawn(void *vreally, void **vmark, void **vsp)
+    {
+	return g_do_aspawn(vreally, vmark, vsp);
+    };
+};
+
+
+class CPerlStdIO : public IPerlStdIO
+{
+public:
+    CPerlStdIO() {};
+    virtual PerlIO* Stdin(void)
+    {
+	return (PerlIO*)win32_stdin();
+    };
+    virtual PerlIO* Stdout(void)
+    {
+	return (PerlIO*)win32_stdout();
+    };
+    virtual PerlIO* Stderr(void)
+    {
+	return (PerlIO*)win32_stderr();
+    };
+    virtual PerlIO* Open(const char *path, const char *mode, int &err)
+    {
+	PerlIO*pf = (PerlIO*)win32_fopen(path, mode);
+	if(errno)
+	    err = errno;
+	return pf;
+    };
+    virtual int Close(PerlIO* pf, int &err)
+    {
+	CALLFUNCERR(win32_fclose(((FILE*)pf)))
+    };
+    virtual int Eof(PerlIO* pf, int &err)
+    {
+	CALLFUNCERR(win32_feof((FILE*)pf))
+    };
+    virtual int Error(PerlIO* pf, int &err)
+    {
+	CALLFUNCERR(win32_ferror((FILE*)pf))
+    };
+    virtual void Clearerr(PerlIO* pf, int &err)
+    {
+	win32_clearerr((FILE*)pf);
+    };
+    virtual int Getc(PerlIO* pf, int &err)
+    {
+	CALLFUNCERR(win32_getc((FILE*)pf))
+    };
+    virtual char* GetBase(PerlIO* pf, int &err)
+    {
+#ifdef FILE_base
+	FILE *f = (FILE*)pf;
+	return FILE_base(f);
+#else
+	return Nullch;
+#endif
+    };
+    virtual int GetBufsiz(PerlIO* pf, int &err)
+    {
+#ifdef FILE_bufsiz
+	FILE *f = (FILE*)pf;
+	return FILE_bufsiz(f);
+#else
+	return (-1);
+#endif
+    };
+    virtual int GetCnt(PerlIO* pf, int &err)
+    {
+#ifdef USE_STDIO_PTR
+	FILE *f = (FILE*)pf;
+	return FILE_cnt(f);
+#else
+	return (-1);
+#endif
+    };
+    virtual char* GetPtr(PerlIO* pf, int &err)
+    {
+#ifdef USE_STDIO_PTR
+	FILE *f = (FILE*)pf;
+	return FILE_ptr(f);
+#else
+	return Nullch;
+#endif
+    };
+    virtual char* Gets(PerlIO* pf, char* s, int n, int& err)
+    {
+	char* ret = win32_fgets(s, n, (FILE*)pf);
+	if(errno)
+	    err = errno;
+	return ret;
+    };
+    virtual int Putc(PerlIO* pf, int c, int &err)
+    {
+	CALLFUNCERR(win32_fputc(c, (FILE*)pf))
+    };
+    virtual int Puts(PerlIO* pf, const char *s, int &err)
+    {
+	CALLFUNCERR(win32_fputs(s, (FILE*)pf))
+    };
+    virtual int Flush(PerlIO* pf, int &err)
+    {
+	CALLFUNCERR(win32_fflush((FILE*)pf))
+    };
+    virtual int Ungetc(PerlIO* pf,int c, int &err)
+    {
+	CALLFUNCERR(win32_ungetc(c, (FILE*)pf))
+    };
+    virtual int Fileno(PerlIO* pf, int &err)
+    {
+	CALLFUNCERR(win32_fileno((FILE*)pf))
+    };
+    virtual PerlIO* Fdopen(int fd, const char *mode, int &err)
+    {
+	PerlIO* pf = (PerlIO*)win32_fdopen(fd, mode);
+	if(errno)
+	    err = errno;
+	return pf;
+    };
+    virtual PerlIO* Reopen(const char*path, const char*mode, PerlIO* pf, int &err)
+    {
+	PerlIO* newPf = (PerlIO*)win32_freopen(path, mode, (FILE*)pf);
+	if(errno)
+	    err = errno;
+	return newPf;
+    };
+    virtual SSize_t Read(PerlIO* pf, void *buffer, Size_t size, int &err)
+    {
+	SSize_t i = win32_fread(buffer, 1, size, (FILE*)pf);
+	if(errno)
+	    err = errno;
+	return i;
+    };
+    virtual SSize_t Write(PerlIO* pf, const void *buffer, Size_t size, int &err)
+    {
+	SSize_t i = win32_fwrite(buffer, 1, size, (FILE*)pf);
+	if(errno)
+	    err = errno;
+	return i;
+    };
+    virtual void SetBuf(PerlIO* pf, char* buffer, int &err)
+    {
+	win32_setbuf((FILE*)pf, buffer);
+    };
+    virtual int SetVBuf(PerlIO* pf, char* buffer, int type, Size_t size, int &err)
+    {
+	int i = win32_setvbuf((FILE*)pf, buffer, type, size);
+	if(errno)
+	    err = errno;
+	return i;
+    };
+    virtual void SetCnt(PerlIO* pf, int n, int &err)
+    {
+#ifdef STDIO_CNT_LVALUE
+	FILE *f = (FILE*)pf;
+	FILE_cnt(f) = n;
+#endif
+    };
+    virtual void SetPtrCnt(PerlIO* pf, char * ptr, int n, int& err)
+    {
+#ifdef STDIO_PTR_LVALUE
+	FILE *f = (FILE*)pf;
+	FILE_ptr(f) = ptr;
+	FILE_cnt(f) = n;
+#endif
+    };
+    virtual void Setlinebuf(PerlIO* pf, int &err)
+    {
+	win32_setvbuf((FILE*)pf, NULL, _IOLBF, 0);
+    };
+    virtual int Printf(PerlIO* pf, int &err, const char *format,...)
+    {
+	va_list(arglist);
+	va_start(arglist, format);
+	int i = win32_vfprintf((FILE*)pf, format, arglist);
+	if(errno)
+	    err = errno;
+	return i;
+    };
+    virtual int Vprintf(PerlIO* pf, int &err, const char *format, va_list arglist)
+    {
+	int i = win32_vfprintf((FILE*)pf, format, arglist);
+	if(errno)
+	    err = errno;
+	return i;
+    };
+    virtual long Tell(PerlIO* pf, int &err)
+    {
+	long l = win32_ftell((FILE*)pf);
+	if(errno)
+	    err = errno;
+	return l;
+    };
+    virtual int Seek(PerlIO* pf, off_t offset, int origin, int &err)
+    {
+	int i = win32_fseek((FILE*)pf, offset, origin);
+	if(errno)
+	    err = errno;
+	return i;
+    };
+    virtual void Rewind(PerlIO* pf, int &err)
+    {
+	win32_rewind((FILE*)pf);
+    };
+    virtual PerlIO* Tmpfile(int &err)
+    {
+	PerlIO* pf = (PerlIO*)win32_tmpfile();
+	if(errno)
+	    err = errno;
+	return pf;
+    };
+    virtual int Getpos(PerlIO* pf, Fpos_t *p, int &err)
+    {
+	int i = win32_fgetpos((FILE*)pf, p);
+	if(errno)
+	    err = errno;
+	return i;
+    };
+    virtual int Setpos(PerlIO* pf, const Fpos_t *p, int &err)
+    {
+	int i = win32_fsetpos((FILE*)pf, p);
+	if(errno)
+	    err = errno;
+	return i;
+    };
+    virtual void Init(int &err)
+    {
+    };
+    virtual void InitOSExtras(void* p)
+    {
+	Perl_init_os_extras();
+    };
+    virtual int OpenOSfhandle(long osfhandle, int flags)
+    {
+	return win32_open_osfhandle(osfhandle, flags);
+    }
+    virtual int GetOSfhandle(int filenum)
+    {
+	return win32_get_osfhandle(filenum);
+    }
+};
+
+class CPerlHost
+{
+public:
+    CPerlHost() { pPerl = NULL; };
+    inline BOOL PerlCreate(void)
+    {
+	try
+	{
+	    pPerl = perl_alloc(&perlMem, &perlEnv, &perlStdIO, &perlLIO,
+			       &perlDir, &perlSock, &perlProc);
+	    if(pPerl != NULL)
+	    {
+		try
+		{
+		    pPerl->perl_construct();
+		}
+		catch(...)
+		{
+		    win32_fprintf(stderr, "%s\n",
+				  "Error: Unable to construct data structures");
+		    pPerl->perl_free();
+		    pPerl = NULL;
+		}
+	    }
+	}
+	catch(...)
+	{
+	    win32_fprintf(stderr, "%s\n", "Error: Unable to allocate memory");
+	    pPerl = NULL;
+	}
+	return (pPerl != NULL);
+    };
+    inline int PerlParse(void (*xs_init)(CPerlObj*), int argc, char** argv, char** env)
+    {
+	int retVal;
+	try
+	{
+	    retVal = pPerl->perl_parse(xs_init, argc, argv, env);
+	}
+	catch(int x)
+	{
+	    // this is where exit() should arrive
+	    retVal = x;
+	}
+	catch(...)
+	{
+	    win32_fprintf(stderr, "Error: Parse exception\n");
+	    retVal = -1;
+	}
+	*win32_errno() = 0;
+	return retVal;
+    };
+    inline int PerlRun(void)
+    {
+	int retVal;
+	try
+	{
+	    retVal = pPerl->perl_run();
+	}
+	catch(int x)
+	{
+	    // this is where exit() should arrive
+	    retVal = x;
+	}
+	catch(...)
+	{
+	    win32_fprintf(stderr, "Error: Runtime exception\n");
+	    retVal = -1;
+	}
+	return retVal;
+    };
+    inline void PerlDestroy(void)
+    {
+	try
+	{
+	    pPerl->perl_destruct();
+	    pPerl->perl_free();
+	}
+	catch(...)
+	{
+	}
+    };
+
+protected:
+    CPerlDir	perlDir;
+    CPerlEnv	perlEnv;
+    CPerlLIO	perlLIO;
+    CPerlMem	perlMem;
+    CPerlProc	perlProc;
+    CPerlSock	perlSock;
+    CPerlStdIO	perlStdIO;
+};
diff --git a/gnu/usr.bin/perl/win32/win32thread.c b/gnu/usr.bin/perl/win32/win32thread.c
new file mode 100644
index 00000000000..b40c5aa251c
--- /dev/null
+++ b/gnu/usr.bin/perl/win32/win32thread.c
@@ -0,0 +1,131 @@
+#include "EXTERN.h"
+#include "perl.h"
+
+#if defined(PERL_OBJECT)
+#define NO_XSLOCKS
+extern CPerlObj* pPerl;
+#include "XSUB.h"
+#endif
+
+#ifdef USE_DECLSPEC_THREAD
+__declspec(thread) struct perl_thread *Perl_current_thread = NULL;
+#endif
+
+void
+Perl_setTHR(struct perl_thread *t)
+{
+#ifdef USE_THREADS
+#ifdef USE_DECLSPEC_THREAD
+ Perl_current_thread = t;
+#else
+ TlsSetValue(PL_thr_key,t);
+#endif
+#endif
+}
+
+struct perl_thread *
+Perl_getTHR(void)
+{
+#ifdef USE_THREADS
+#ifdef USE_DECLSPEC_THREAD
+ return Perl_current_thread;
+#else
+ return (struct perl_thread *) TlsGetValue(PL_thr_key);
+#endif
+#else
+ return NULL;
+#endif
+}
+
+void
+Perl_alloc_thread_key(void)
+{
+#ifdef USE_THREADS
+    static int key_allocated = 0;
+    if (!key_allocated) {
+	if ((PL_thr_key = TlsAlloc()) == TLS_OUT_OF_INDEXES)
+	    croak("panic: TlsAlloc");
+	key_allocated = 1;
+    }
+#endif
+}
+
+void
+Perl_init_thread_intern(struct perl_thread *athr)
+{
+#ifdef USE_THREADS
+#ifndef USE_DECLSPEC_THREAD
+
+ /* 
+  * Initialize port-specific per-thread data in thr->i
+  * as only things we have there are just static areas for
+  * return values we don't _need_ to do anything but 
+  * this is good practice:
+  */
+ memset(&athr->i,0,sizeof(athr->i));
+
+#endif
+#endif
+}
+
+void
+Perl_set_thread_self(struct perl_thread *thr)
+{
+#ifdef USE_THREADS
+    /* Set thr->self.  GetCurrentThread() retrurns a pseudo handle, need
+       this to convert it into a handle another thread can use.
+     */
+    DuplicateHandle(GetCurrentProcess(),
+		    GetCurrentThread(),
+		    GetCurrentProcess(),
+		    &thr->self,
+		    0,
+		    FALSE,
+		    DUPLICATE_SAME_ACCESS);
+#endif
+}
+
+#ifdef USE_THREADS
+int
+Perl_thread_create(struct perl_thread *thr, thread_func_t *fn)
+{
+    DWORD junk;
+    unsigned long th;
+
+    DEBUG_S(PerlIO_printf(PerlIO_stderr(),
+			  "%p: create OS thread\n", thr));
+#ifdef USE_RTL_THREAD_API
+    /* See comment about USE_RTL_THREAD_API in win32thread.h */
+#if defined(__BORLANDC__)
+    th = _beginthreadNT(fn,				/* start address */
+			0,				/* stack size */
+			(void *)thr,			/* parameters */
+			(void *)NULL,			/* security attrib */
+			0,				/* creation flags */
+			(unsigned long *)&junk);	/* tid */
+    if (th == (unsigned long)-1)
+	th = 0;
+#elif defined(_MSC_VER_)
+    th = _beginthreadex((void *)NULL,			/* security attrib */
+			0,				/* stack size */
+			fn,				/* start address */
+			(void*)thr,			/* parameters */
+			0,				/* creation flags */
+			(unsigned *)&junk);		/* tid */
+#else /* compilers using CRTDLL.DLL only have _beginthread() */
+    th = _beginthread(fn,				/* start address */
+		      0,				/* stack size */
+		      (void*)thr);			/* parameters */
+    if (th == (unsigned long)-1)
+	th = 0;
+#endif
+    thr->self = (HANDLE)th;
+#else	/* !USE_RTL_THREAD_API */
+    thr->self = CreateThread(NULL, 0, fn, (void*)thr, 0, &junk);
+#endif	/* !USE_RTL_THREAD_API */
+    DEBUG_S(PerlIO_printf(PerlIO_stderr(),
+			  "%p: OS thread = %p, id=%ld\n", thr, thr->self, junk));
+    return thr->self ? 0 : -1;
+}
+#endif
+
diff --git a/gnu/usr.bin/perl/win32/win32thread.h b/gnu/usr.bin/perl/win32/win32thread.h
new file mode 100644
index 00000000000..512e6296e5d
--- /dev/null
+++ b/gnu/usr.bin/perl/win32/win32thread.h
@@ -0,0 +1,187 @@
+#ifndef _WIN32THREAD_H
+#define _WIN32THREAD_H
+typedef struct win32_cond { LONG waiters; HANDLE sem; } perl_cond;
+typedef DWORD perl_key;
+typedef HANDLE perl_os_thread;
+
+#ifndef DONT_USE_CRITICAL_SECTION
+
+/* Critical Sections used instead of mutexes: lightweight,
+ * but can't be communicated to child processes, and can't get
+ * HANDLE to it for use elsewhere.
+ */
+typedef CRITICAL_SECTION perl_mutex;
+#define MUTEX_INIT(m) InitializeCriticalSection(m)
+#define MUTEX_LOCK(m) EnterCriticalSection(m)
+#define MUTEX_UNLOCK(m) LeaveCriticalSection(m)
+#define MUTEX_DESTROY(m) DeleteCriticalSection(m)
+
+#else
+
+typedef HANDLE perl_mutex;
+#define MUTEX_INIT(m) \
+    STMT_START {						\
+	if ((*(m) = CreateMutex(NULL,FALSE,NULL)) == NULL)	\
+	    croak("panic: MUTEX_INIT");				\
+    } STMT_END
+#define MUTEX_LOCK(m) \
+    STMT_START {						\
+	if (WaitForSingleObject(*(m),INFINITE) == WAIT_FAILED)	\
+	    croak("panic: MUTEX_LOCK");				\
+    } STMT_END
+#define MUTEX_UNLOCK(m) \
+    STMT_START {						\
+	if (ReleaseMutex(*(m)) == 0)				\
+	    croak("panic: MUTEX_UNLOCK");			\
+    } STMT_END
+#define MUTEX_DESTROY(m) \
+    STMT_START {						\
+	if (CloseHandle(*(m)) == 0)				\
+	    croak("panic: MUTEX_DESTROY");			\
+    } STMT_END
+
+#endif
+
+/* These macros assume that the mutex associated with the condition
+ * will always be held before COND_{SIGNAL,BROADCAST,WAIT,DESTROY},
+ * so there's no separate mutex protecting access to (c)->waiters
+ */
+#define COND_INIT(c) \
+    STMT_START {						\
+	(c)->waiters = 0;					\
+	(c)->sem = CreateSemaphore(NULL,0,LONG_MAX,NULL);	\
+	if ((c)->sem == NULL)					\
+	    croak("panic: COND_INIT (%ld)",GetLastError());	\
+    } STMT_END
+
+#define COND_SIGNAL(c) \
+    STMT_START {						\
+	if ((c)->waiters > 0 &&					\
+	    ReleaseSemaphore((c)->sem,1,NULL) == 0)		\
+	    croak("panic: COND_SIGNAL (%ld)",GetLastError());	\
+    } STMT_END
+
+#define COND_BROADCAST(c) \
+    STMT_START {						\
+	if ((c)->waiters > 0 &&					\
+	    ReleaseSemaphore((c)->sem,(c)->waiters,NULL) == 0)	\
+	    croak("panic: COND_BROADCAST (%ld)",GetLastError());\
+    } STMT_END
+
+#define COND_WAIT(c, m) \
+    STMT_START {						\
+	(c)->waiters++;						\
+	MUTEX_UNLOCK(m);					\
+	/* Note that there's no race here, since a		\
+	 * COND_BROADCAST() on another thread will have seen the\
+	 * right number of waiters (i.e. including this one) */	\
+	if (WaitForSingleObject((c)->sem,INFINITE)==WAIT_FAILED)\
+	    croak("panic: COND_WAIT (%ld)",GetLastError());	\
+	/* XXX there may be an inconsequential race here */	\
+	MUTEX_LOCK(m);						\
+	(c)->waiters--;						\
+    } STMT_END
+
+#define COND_DESTROY(c) \
+    STMT_START {						\
+	(c)->waiters = 0;					\
+	if (CloseHandle((c)->sem) == 0)				\
+	    croak("panic: COND_DESTROY (%ld)",GetLastError());	\
+    } STMT_END
+
+#define DETACH(t) \
+    STMT_START {						\
+	if (CloseHandle((t)->self) == 0) {			\
+	    MUTEX_UNLOCK(&(t)->mutex);				\
+	    croak("panic: DETACH");				\
+	}							\
+    } STMT_END
+
+
+#define THREAD_CREATE(t, f)	Perl_thread_create(t, f)
+#define THREAD_POST_CREATE(t)	NOOP
+
+/* XXX Docs mention that the RTL versions of thread creation routines
+ * should be used, but that advice only seems applicable when the RTL
+ * is not in a DLL.  RTL DLLs in both Borland and VC seem to do all of
+ * the init/deinit required upon DLL_THREAD_ATTACH/DETACH.  So we seem
+ * to be completely safe using straight Win32 API calls, rather than
+ * the much braindamaged RTL calls.
+ *
+ * _beginthread() in the RTLs call CloseHandle() just after the thread
+ * function returns, which means: 1) we have a race on our hands
+ * 2) it is impossible to implement join() semantics.
+ *
+ * IOW, do *NOT* turn on USE_RTL_THREAD_API!  It is here
+ * for experimental purposes only. GSAR 98-01-02
+ */
+#ifdef USE_RTL_THREAD_API
+#  include <process.h>
+#  if defined(__BORLANDC__)
+     /* Borland RTL doesn't allow a return value from thread function! */
+#    define THREAD_RET_TYPE	void _USERENTRY
+#    define THREAD_RET_CAST(p)	((void)(thr->i.retv = (void *)(p)))
+#  elif defined (_MSC_VER)
+#    define THREAD_RET_TYPE	unsigned __stdcall
+#    define THREAD_RET_CAST(p)	((unsigned)(p))
+#  else
+     /* CRTDLL.DLL doesn't allow a return value from thread function! */
+#    define THREAD_RET_TYPE	void __cdecl
+#    define THREAD_RET_CAST(p)	((void)(thr->i.retv = (void *)(p)))
+#  endif
+#else	/* !USE_RTL_THREAD_API */
+#  define THREAD_RET_TYPE	DWORD WINAPI
+#  define THREAD_RET_CAST(p)	((DWORD)(p))
+#endif	/* !USE_RTL_THREAD_API */
+
+typedef THREAD_RET_TYPE thread_func_t(void *);
+
+
+START_EXTERN_C
+
+#if defined(PERLDLL) && defined(USE_DECLSPEC_THREAD) && (!defined(__BORLANDC__) || defined(_DLL))
+extern __declspec(thread) struct perl_thread *Perl_current_thread;
+#define SET_THR(t)   		(Perl_current_thread = t)
+#define THR			Perl_current_thread
+#else
+#define THR			Perl_getTHR()
+#define SET_THR(t)		Perl_setTHR(t)
+#endif
+struct perl_thread;
+
+void Perl_alloc_thread_key _((void));
+int Perl_thread_create _((struct perl_thread *thr, thread_func_t *fn));
+void Perl_set_thread_self _((struct perl_thread *thr));
+struct perl_thread *Perl_getTHR _((void));
+void Perl_setTHR _((struct perl_thread *t));
+void Perl_init_thread_intern _((struct perl_thread *t));
+
+END_EXTERN_C
+
+#define INIT_THREADS NOOP
+#define ALLOC_THREAD_KEY Perl_alloc_thread_key()
+#define SET_THREAD_SELF(thr) Perl_set_thread_self(thr)
+
+#if defined(USE_RTL_THREAD_API) && !defined(_MSC_VER)
+#define JOIN(t, avp)							\
+    STMT_START {							\
+	if ((WaitForSingleObject((t)->self,INFINITE) == WAIT_FAILED)	\
+	     || (GetExitCodeThread((t)->self,(LPDWORD)(avp)) == 0)	\
+	     || (CloseHandle((t)->self) == 0))				\
+	    croak("panic: JOIN");					\
+	*avp = (AV *)((t)->i.retv);					\
+    } STMT_END
+#else	/* !USE_RTL_THREAD_API || _MSC_VER */
+#define JOIN(t, avp)							\
+    STMT_START {							\
+	if ((WaitForSingleObject((t)->self,INFINITE) == WAIT_FAILED)	\
+	     || (GetExitCodeThread((t)->self,(LPDWORD)(avp)) == 0)	\
+	     || (CloseHandle((t)->self) == 0))				\
+	    croak("panic: JOIN");					\
+    } STMT_END
+#endif	/* !USE_RTL_THREAD_API || _MSC_VER */
+
+#define YIELD			Sleep(0)
+
+#endif /* _WIN32THREAD_H */
+