win32/GenCAPI.pl

   1
   2 # creates a C API file from proto.h
   3 # takes one argument, the path to lib/CORE directory.
   4 # creates 2 files: "PerlCAPI.cpp" and "PerlCAPI.h".
   5
   6 my $hdrfile = "$ARGV[0]\\PerlCAPI.h";
   7 my $infile = '..\\proto.h';
   8 my $embedfile = '..\\embed.h';
   9 my $separateObj = 0;
  10
  11 my %skip_list;
  12 my %embed;
  13
  14 sub readembed(\%$) {
  15     my ($syms, $file) = @_;
  16     my ($line, @words);
  17     %$syms = ();
  18     local (*FILE, $_);
  19     open(FILE, "< $file")
  20         or die "$0: Can't open $file: $!\n";
  21     while ($line = <FILE>) {
  22         chop($line);
  23         if ($line =~ /^#define\s+\w+/) {
  24             $line =~ s/^#define\s+//;
  25             @words = split ' ', $line;
  26 #           print "$words[0]\t$words[1]\n";
  27             $$syms{$words[0]} = $words[1];
  28         }
  29     }
  30     close(FILE);
  31 }
  32
  33 readembed %embed, $embedfile;
  34
  35 sub skip_these {
  36     my $list = shift;
  37     foreach my $symbol (@$list) {
  38         $skip_list{$symbol} = 1;
  39     }
  40 }
  41
  42 skip_these [qw(
  43 cando
  44 cast_ulong
  45 my_chsize
  46 condpair_magic
  47 deb
  48 deb_growlevel
  49 debprofdump
  50 debop
  51 debstack
  52 debstackptrs
  53 dump_fds
  54 dump_mstats
  55 fprintf
  56 find_threadsv
  57 magic_mutexfree
  58 my_memcmp
  59 my_memset
  60 my_pclose
  61 my_popen
  62 my_swap
  63 my_htonl
  64 my_ntohl
  65 new_struct_thread
  66 same_dirent
  67 unlnk
  68 unlock_condpair
  69 safexmalloc
  70 safexcalloc
  71 safexrealloc
  72 safexfree
  73 Perl_GetVars
  74 )];
  75
  76
  77
  78 if (!open(INFILE, "<$infile")) {
  79     print "open of $infile failed: $!\n";
  80     return 1;
  81 }
  82
  83 if (!open(OUTFILE, ">PerlCAPI.cpp")) {
  84     print "open of PerlCAPI.cpp failed: $!\n";
  85     return 1;
  86 }
  87
  88 print OUTFILE <<ENDCODE;
  89 #include "EXTERN.h"
  90 #include "perl.h"
  91 #include "XSUB.h"
  92
  93 #define DESTRUCTORFUNC (void (*)(void*))
  94
  95 ENDCODE
  96
  97 print OUTFILE "#ifdef SetCPerlObj_defined\n" unless ($separateObj == 0);
  98
  99 print OUTFILE <<ENDCODE;
 100 extern "C" void SetCPerlObj(CPerlObj* pP)
 101 {
 102     pPerl = pP;
 103 }
 104
 105 ENDCODE
 106
 107 print OUTFILE "#endif\n" unless ($separateObj == 0);
 108
 109 while () {
 110     last unless defined ($_ = <INFILE>);
 111     if (/^VIRTUAL\s/) {
 112         while (!/;$/) {
 113             chomp;
 114             $_ .= <INFILE>;
 115         }
 116         $_ =~ s/^VIRTUAL\s*//;
 117         $_ =~ s/\s*__attribute__.*$/;/;
 118         if ( /(.*)\s([A-z_]*[0-9A-z_]+\s)_\(\((.*)\)\);/ ||
 119              /(.*)\*([A-z_]*[0-9A-z_]+\s)_\(\((.*)\)\);/ ) {
 120             $type = $1;
 121             $name = $2;
 122             $args = $3;
 123
 124             $name =~ s/\s*$//;
 125             $type =~ s/\s*$//;
 126             next if (defined $skip_list{$name});
 127
 128             if($args eq "ARGSproto") {
 129                 $args = "void";
 130             }
 131
 132             $return = ($type eq "void" or $type eq "Free_t") ? "\t" : "\treturn";
 133
 134             if(defined $embed{$name}) {
 135                 $funcName = $embed{$name};
 136             } else {
 137                 $funcName = $name;
 138             }
 139
 140             @args = split(',', $args);
 141             if ($args[$#args] =~ /\s*\.\.\.\s*/) {
 142                 if(($name eq "croak") or ($name eq "deb") or ($name eq "die")
 143                         or ($name eq "form") or ($name eq "warn")) {
 144                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
 145                     $args[0] =~ /(\w+)\W*$/;
 146                     $arg = $1;
 147                     print OUTFILE <<ENDCODE;
 148
 149 #undef $name
 150 extern "C" $type $funcName ($args)
 151 {
 152     char *pstr;
 153     char *pmsg;
 154     va_list args;
 155     va_start(args, $arg);
 156     pmsg = pPerl->Perl_mess($arg, &args);
 157     New(0, pstr, strlen(pmsg)+1, char);
 158     strcpy(pstr, pmsg);
 159 $return pPerl->Perl_$name(pstr);
 160     va_end(args);
 161 }
 162 ENDCODE
 163                     print OUTFILE "#endif\n" unless ($separateObj == 0);
 164                 }
 165                 elsif($name eq "newSVpvf") {
 166                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
 167                     $args[0] =~ /(\w+)\W*$/;
 168                     $arg = $1;
 169                     print OUTFILE <<ENDCODE;
 170
 171 #undef $name
 172 extern "C" $type $funcName ($args)
 173 {
 174     SV *sv;
 175     va_list args;
 176     va_start(args, $arg);
 177     sv = pPerl->Perl_newSV(0);
 178     pPerl->Perl_sv_vcatpvfn(sv, $arg, strlen($arg), &args, NULL, 0, NULL);
 179     va_end(args);
 180     return sv;
 181 }
 182 ENDCODE
 183                     print OUTFILE "#endif\n" unless ($separateObj == 0);
 184                 }
 185                 elsif($name eq "sv_catpvf") {
 186                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
 187                     $args[0] =~ /(\w+)\W*$/;
 188                     $arg0 = $1;
 189                     $args[1] =~ /(\w+)\W*$/;
 190                     $arg1 = $1;
 191                     print OUTFILE <<ENDCODE;
 192
 193 #undef $name
 194 extern "C" $type $funcName ($args)
 195 {
 196     va_list args;
 197     va_start(args, $arg1);
 198     pPerl->Perl_sv_vcatpvfn($arg0, $arg1, strlen($arg1), &args, NULL, 0, NULL);
 199     va_end(args);
 200 }
 201 ENDCODE
 202                     print OUTFILE "#endif\n" unless ($separateObj == 0);
 203                 }
 204                 elsif($name eq "sv_setpvf") {
 205                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
 206                     $args[0] =~ /(\w+)\W*$/;
 207                     $arg0 = $1;
 208                     $args[1] =~ /(\w+)\W*$/;
 209                     $arg1 = $1;
 210                     print OUTFILE <<ENDCODE;
 211
 212 #undef $name
 213 extern "C" $type $funcName ($args)
 214 {
 215     va_list args;
 216     va_start(args, $arg1);
 217     pPerl->Perl_sv_vsetpvfn($arg0, $arg1, strlen($arg1), &args, NULL, 0, NULL);
 218     va_end(args);
 219 }
 220 ENDCODE
 221                     print OUTFILE "#endif\n" unless ($separateObj == 0);
 222                 }
 223                 elsif($name eq "fprintf") {
 224                     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
 225                     $args[0] =~ /(\w+)\W*$/;
 226                     $arg0 = $1;
 227                     $args[1] =~ /(\w+)\W*$/;
 228                     $arg1 = $1;
 229                     print OUTFILE <<ENDCODE;
 230
 231 #undef $name
 232 extern "C" $type $name ($args)
 233 {
 234     int nRet;
 235     va_list args;
 236     va_start(args, $arg1);
 237     nRet = PerlIO_vprintf($arg0, $arg1, args);
 238     va_end(args);
 239     return nRet;
 240 }
 241 ENDCODE
 242                     print OUTFILE "#endif\n" unless ($separateObj == 0);
 243                 } else {
 244                     print "Warning: can't handle varargs function '$name'\n";
 245                 }
 246                 next;
 247             }
 248
 249             # newXS special case
 250             if ($name eq "newXS") {
 251                 next;
 252             }
 253
 254             print OUTFILE "\n#ifdef $name" . "defined" unless ($separateObj == 0);
 255
 256             # handle specical case for save_destructor
 257             if ($name eq "save_destructor") {
 258                 next;
 259             }
 260             # handle specical case for sighandler
 261             if ($name eq "sighandler") {
 262                 next;
 263             }
 264             # handle special case for sv_grow
 265             if ($name eq "sv_grow" and $args eq "SV* sv, unsigned long newlen") {
 266                 next;
 267             }
 268             # handle special case for newSV
 269             if ($name eq "newSV" and $args eq "I32 x, STRLEN len") {
 270                 next;
 271             }
 272             # handle special case for perl_parse
 273             if ($name eq "perl_parse") {
 274                 print OUTFILE <<ENDCODE;
 275
 276 #undef $name
 277 extern "C" $type $name ($args)
 278 {
 279     return pPerl->perl_parse(xsinit, argc, argv, env);
 280 }
 281 ENDCODE
 282                 print OUTFILE "#endif\n" unless ($separateObj == 0);
 283                 next;
 284             }
 285             # handle special case for perl_atexit
 286             if ($name eq "perl_atexit") {
 287                 print OUTFILE <<ENDCODE;
 288
 289 #undef $name
 290 extern "C" $type $name ($args)
 291 {
 292     pPerl->perl_atexit(fn, ptr);
 293 }
 294 ENDCODE
 295                 print OUTFILE "#endif\n" unless ($separateObj == 0);
 296                 next;
 297             }
 298
 299
 300             if($name eq "byterun" and $args eq "struct bytestream bs") {
 301                 next;
 302             }
 303
 304             # foo(void);
 305             if ($args eq "void") {
 306                 print OUTFILE <<ENDCODE;
 307
 308 #undef $name
 309 extern "C" $type $funcName ()
 310 {
 311 $return pPerl->$funcName();
 312 }
 313
 314 ENDCODE
 315                 print OUTFILE "#endif\n" unless ($separateObj == 0);
 316                 next;
 317             }
 318
 319             # foo(char *s, const int bar);
 320             print OUTFILE <<ENDCODE;
 321
 322 #undef $name
 323 extern "C" $type $funcName ($args)
 324 {
 325 ENDCODE
 326             print OUTFILE "$return pPerl->$funcName";
 327             $doneone = 0;
 328             foreach $arg (@args) {
 329                 if ($arg =~ /(\w+)\W*$/) {
 330                     if ($doneone) {
 331                         print OUTFILE ", $1";
 332                     }
 333                     else {
 334                         print OUTFILE "($1";
 335                         $doneone++;
 336                     }
 337                 }
 338             }
 339             print OUTFILE ");\n}\n";
 340             print OUTFILE "#endif\n" unless ($separateObj == 0);
 341         }
 342         else {
 343             print "failed to match $_";
 344         }
 345     }
 346 }
 347
 348 close INFILE;
 349
 350 %skip_list = ();
 351
 352 skip_these [qw(
 353 strchop
 354 filemode
 355 lastfd
 356 oldname
 357 curinterp
 358 Argv
 359 Cmd
 360 sortcop
 361 sortstash
 362 firstgv
 363 secondgv
 364 sortstack
 365 signalstack
 366 mystrk
 367 dumplvl
 368 oldlastpm
 369 gensym
 370 preambled
 371 preambleav
 372 Ilaststatval
 373 Ilaststype
 374 mess_sv
 375 ors
 376 opsave
 377 eval_mutex
 378 orslen
 379 ofmt
 380 modcount
 381 generation
 382 DBcv
 383 archpat_auto
 384 sortcxix
 385 lastgotoprobe
 386 regdummy
 387 regcomp_parse
 388 regxend
 389 regcode
 390 regnaughty
 391 regsawback
 392 regprecomp
 393 regnpar
 394 regsize
 395 regflags
 396 regseen
 397 seen_zerolen
 398 regcomp_rx
 399 extralen
 400 colorset
 401 colors
 402 reginput
 403 regbol
 404 regeol
 405 regstartp
 406 regendp
 407 reglastparen
 408 regtill
 409 regprev
 410 reg_start_tmp
 411 reg_start_tmpl
 412 regdata
 413 bostr
 414 reg_flags
 415 reg_eval_set
 416 regnarrate
 417 regprogram
 418 regindent
 419 regcc
 420 in_clean_objs
 421 in_clean_all
 422 linestart
 423 pending_ident
 424 statusvalue_vms
 425 sublex_info
 426 thrsv
 427 threadnum
 428 piMem
 429 piENV
 430 piStdIO
 431 piLIO
 432 piDir
 433 piSock
 434 piProc
 435 cshname
 436 threadsv_names
 437 thread
 438 nthreads
 439 thr_key
 440 threads_mutex
 441 malloc_mutex
 442 svref_mutex
 443 sv_mutex
 444 nthreads_cond
 445 eval_cond
 446 cryptseen
 447 cshlen
 448 )];
 449
 450 sub readvars(\%$$) {
 451     my ($syms, $file, $pre) = @_;
 452     %$syms = ();
 453     local (*FILE, $_);
 454     open(FILE, "< $file")
 455         or die "$0: Can't open $file: $!\n";
 456     while (<FILE>) {
 457         s/[ \t]*#.*//;          # Delete comments.
 458         if (/PERLVARI?C?\($pre(\w+),\s*([^,)]+)/) {
 459             $$syms{$1} = $2;
 460         }
 461     }
 462     close(FILE);
 463 }
 464
 465 my %intrp;
 466 my %thread;
 467 my %globvar;
 468
 469 readvars %intrp,  '..\intrpvar.h','I';
 470 readvars %thread, '..\thrdvar.h','T';
 471 readvars %globvar, '..\perlvars.h','G';
 472
 473 open(HDRFILE, ">$hdrfile") or die "$0: Can't open $hdrfile: $!\n";
 474 print HDRFILE <<ENDCODE;
 475 void SetCPerlObj(void* pP);
 476 CV* Perl_newXS(char* name, void (*subaddr)(CV* cv), char* filename);
 477
 478 ENDCODE
 479
 480 sub DoVariable($$) {
 481     my $name = shift;
 482     my $type = shift;
 483
 484     return if (defined $skip_list{$name});
 485     return if ($type eq 'struct perl_thread *');
 486
 487     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
 488     print OUTFILE <<ENDCODE;
 489 extern "C" $type * _Perl_$name ()
 490 {
 491     return (($type *)&pPerl->Perl_$name);
 492 }
 493
 494 ENDCODE
 495
 496     print OUTFILE "#endif\n" unless ($separateObj == 0);
 497
 498     print HDRFILE <<ENDCODE;
 499
 500 #undef Perl_$name
 501 $type * _Perl_$name ();
 502 #define Perl_$name (*_Perl_$name())
 503
 504 ENDCODE
 505
 506 }
 507
 508 foreach $key (keys %intrp) {
 509     DoVariable ($key, $intrp{$key});
 510 }
 511
 512 foreach $key (keys %thread) {
 513     DoVariable ($key, $thread{$key});
 514 }
 515
 516 foreach $key (keys %globvar) {
 517     DoVariable ($key, $globvar{$key});
 518 }
 519
 520 print OUTFILE <<EOCODE;
 521
 522
 523 extern "C" {
 524
 525
 526 char ** _Perl_op_desc(void)
 527 {
 528     return pPerl->Perl_get_op_descs();
 529 }
 530
 531 char ** _Perl_op_name(void)
 532 {
 533     return pPerl->Perl_get_op_names();
 534 }
 535
 536 char *  _Perl_no_modify(void)
 537 {
 538     return pPerl->Perl_get_no_modify();
 539 }
 540
 541 U32 *   _Perl_opargs(void)
 542 {
 543     return pPerl->Perl_get_opargs();
 544 }
 545
 546 void xs_handler(CV* cv, CPerlObj* p)
 547 {
 548     void(*func)(CV*);
 549     SV* sv;
 550     MAGIC* m = pPerl->Perl_mg_find((SV*)cv, '~');
 551     if(m != NULL)
 552     {
 553         sv = m->mg_obj;
 554         if(SvIOK(sv))
 555         {
 556             func = (void(*)(CV*))SvIVX(sv);
 557         }
 558         else
 559         {
 560             func = (void(*)(CV*))pPerl->Perl_sv_2iv(sv);
 561         }
 562         func(cv);
 563     }
 564 }
 565
 566 CV* Perl_newXS(char* name, void (*subaddr)(CV* cv), char* filename)
 567 {
 568     CV* cv = pPerl->Perl_newXS(name, xs_handler, filename);
 569     pPerl->Perl_sv_magic((SV*)cv, pPerl->Perl_sv_2mortal(pPerl->Perl_newSViv((IV)subaddr)), '~', "CAPI", 4);
 570     return cv;
 571 }
 572
 573
 574 void Perl_deb(const char pat, ...)
 575 {
 576 }
 577
 578 #undef piMem
 579 #undef piENV
 580 #undef piStdIO
 581 #undef piLIO
 582 #undef piDir
 583 #undef piSock
 584 #undef piProc
 585
 586 int *        _win32_errno(void)
 587 {
 588     return &pPerl->ErrorNo();
 589 }
 590
 591 FILE*        _win32_stdin(void)
 592 {
 593     return (FILE*)pPerl->piStdIO->Stdin();
 594 }
 595
 596 FILE*        _win32_stdout(void)
 597 {
 598     return (FILE*)pPerl->piStdIO->Stdout();
 599 }
 600
 601 FILE*        _win32_stderr(void)
 602 {
 603     return (FILE*)pPerl->piStdIO->Stderr();
 604 }
 605
 606 int          _win32_ferror(FILE *fp)
 607 {
 608     return pPerl->piStdIO->Error((PerlIO*)fp, ErrorNo());
 609 }
 610
 611 int          _win32_feof(FILE *fp)
 612 {
 613     return pPerl->piStdIO->Eof((PerlIO*)fp, ErrorNo());
 614 }
 615
 616 char*        _win32_strerror(int e)
 617 {
 618     return strerror(e);
 619 }
 620
 621 void         _win32_perror(const char *str)
 622 {
 623     perror(str);
 624 }
 625
 626 int          _win32_vfprintf(FILE *pf, const char *format, va_list arg)
 627 {
 628     return pPerl->piStdIO->Vprintf((PerlIO*)pf, ErrorNo(), format, arg);
 629 }
 630
 631 int          _win32_vprintf(const char *format, va_list arg)
 632 {
 633     return pPerl->piStdIO->Vprintf(pPerl->piStdIO->Stdout(), ErrorNo(), format, arg);
 634 }
 635
 636 int          _win32_fprintf(FILE *pf, const char *format, ...)
 637 {
 638     int ret;
 639     va_list args;
 640     va_start(args, format);
 641     ret = _win32_vfprintf(pf, format, args);
 642     va_end(args);
 643     return ret;
 644 }
 645
 646 int          _win32_printf(const char *format, ...)
 647 {
 648     int ret;
 649     va_list args;
 650     va_start(args, format);
 651     ret = _win32_vprintf(format, args);
 652     va_end(args);
 653     return ret;
 654 }
 655
 656 size_t       _win32_fread(void *buf, size_t size, size_t count, FILE *pf)
 657 {
 658     return pPerl->piStdIO->Read((PerlIO*)pf, buf, (size*count), ErrorNo());
 659 }
 660
 661 size_t       _win32_fwrite(const void *buf, size_t size, size_t count, FILE *pf)
 662 {
 663     return pPerl->piStdIO->Write((PerlIO*)pf, buf, (size*count), ErrorNo());
 664 }
 665
 666 FILE*        _win32_fopen(const char *path, const char *mode)
 667 {
 668     return (FILE*)pPerl->piStdIO->Open(path, mode, ErrorNo());
 669 }
 670
 671 FILE*        _win32_fdopen(int fh, const char *mode)
 672 {
 673     return (FILE*)pPerl->piStdIO->Fdopen(fh, mode, ErrorNo());
 674 }
 675
 676 FILE*        _win32_freopen(const char *path, const char *mode, FILE *pf)
 677 {
 678     return (FILE*)pPerl->piStdIO->Reopen(path, mode, (PerlIO*)pf, ErrorNo());
 679 }
 680
 681 int          _win32_fclose(FILE *pf)
 682 {
 683     return pPerl->piStdIO->Close((PerlIO*)pf, ErrorNo());
 684 }
 685
 686 int          _win32_fputs(const char *s,FILE *pf)
 687 {
 688     return pPerl->piStdIO->Puts((PerlIO*)pf, s, ErrorNo());
 689 }
 690
 691 int          _win32_fputc(int c,FILE *pf)
 692 {
 693     return pPerl->piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
 694 }
 695
 696 int          _win32_ungetc(int c,FILE *pf)
 697 {
 698     return pPerl->piStdIO->Ungetc((PerlIO*)pf, c, ErrorNo());
 699 }
 700
 701 int          _win32_getc(FILE *pf)
 702 {
 703     return pPerl->piStdIO->Getc((PerlIO*)pf, ErrorNo());
 704 }
 705
 706 int          _win32_fileno(FILE *pf)
 707 {
 708     return pPerl->piStdIO->Fileno((PerlIO*)pf, ErrorNo());
 709 }
 710
 711 void         _win32_clearerr(FILE *pf)
 712 {
 713     pPerl->piStdIO->Clearerr((PerlIO*)pf, ErrorNo());
 714 }
 715
 716 int          _win32_fflush(FILE *pf)
 717 {
 718     return pPerl->piStdIO->Flush((PerlIO*)pf, ErrorNo());
 719 }
 720
 721 long         _win32_ftell(FILE *pf)
 722 {
 723     return pPerl->piStdIO->Tell((PerlIO*)pf, ErrorNo());
 724 }
 725
 726 int          _win32_fseek(FILE *pf,long offset,int origin)
 727 {
 728     return pPerl->piStdIO->Seek((PerlIO*)pf, offset, origin, ErrorNo());
 729 }
 730
 731 int          _win32_fgetpos(FILE *pf,fpos_t *p)
 732 {
 733     return pPerl->piStdIO->Getpos((PerlIO*)pf, p, ErrorNo());
 734 }
 735
 736 int          _win32_fsetpos(FILE *pf,const fpos_t *p)
 737 {
 738     return pPerl->piStdIO->Setpos((PerlIO*)pf, p, ErrorNo());
 739 }
 740
 741 void         _win32_rewind(FILE *pf)
 742 {
 743     pPerl->piStdIO->Rewind((PerlIO*)pf, ErrorNo());
 744 }
 745
 746 FILE*        _win32_tmpfile(void)
 747 {
 748     return (FILE*)pPerl->piStdIO->Tmpfile(ErrorNo());
 749 }
 750
 751 void         _win32_setbuf(FILE *pf, char *buf)
 752 {
 753     pPerl->piStdIO->SetBuf((PerlIO*)pf, buf, ErrorNo());
 754 }
 755
 756 int          _win32_setvbuf(FILE *pf, char *buf, int type, size_t size)
 757 {
 758     return pPerl->piStdIO->SetVBuf((PerlIO*)pf, buf, type, size, ErrorNo());
 759 }
 760
 761 char*           _win32_fgets(char *s, int n, FILE *pf)
 762 {
 763     return pPerl->piStdIO->Gets((PerlIO*)pf, s, n, ErrorNo());
 764 }
 765
 766 char*           _win32_gets(char *s)
 767 {
 768     return _win32_fgets(s, 80, (FILE*)pPerl->piStdIO->Stdin());
 769 }
 770
 771 int          _win32_fgetc(FILE *pf)
 772 {
 773     return pPerl->piStdIO->Getc((PerlIO*)pf, ErrorNo());
 774 }
 775
 776 int          _win32_putc(int c, FILE *pf)
 777 {
 778     return pPerl->piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
 779 }
 780
 781 int          _win32_puts(const char *s)
 782 {
 783     return pPerl->piStdIO->Puts(pPerl->piStdIO->Stdout(), s, ErrorNo());
 784 }
 785
 786 int          _win32_getchar(void)
 787 {
 788     return pPerl->piStdIO->Getc(pPerl->piStdIO->Stdin(), ErrorNo());
 789 }
 790
 791 int          _win32_putchar(int c)
 792 {
 793     return pPerl->piStdIO->Putc(pPerl->piStdIO->Stdout(), c, ErrorNo());
 794 }
 795
 796 void*        _win32_malloc(size_t size)
 797 {
 798     return pPerl->piMem->Malloc(size);
 799 }
 800
 801 void*        _win32_calloc(size_t numitems, size_t size)
 802 {
 803     return pPerl->piMem->Malloc(numitems*size);
 804 }
 805
 806 void*        _win32_realloc(void *block, size_t size)
 807 {
 808     return pPerl->piMem->Realloc(block, size);
 809 }
 810
 811 void         _win32_free(void *block)
 812 {
 813     pPerl->piMem->Free(block);
 814 }
 815
 816 void         _win32_abort(void)
 817 {
 818     pPerl->piProc->Abort();
 819 }
 820
 821 int          _win32_pipe(int *phandles, unsigned int psize, int textmode)
 822 {
 823     return pPerl->piProc->Pipe(phandles);
 824 }
 825
 826 FILE*        _win32_popen(const char *command, const char *mode)
 827 {
 828     return (FILE*)pPerl->piProc->Popen(command, mode);
 829 }
 830
 831 int          _win32_pclose(FILE *pf)
 832 {
 833     return pPerl->piProc->Pclose((PerlIO*)pf);
 834 }
 835
 836 unsigned     _win32_sleep(unsigned int t)
 837 {
 838     return pPerl->piProc->Sleep(t);
 839 }
 840
 841 int     _win32_spawnvp(int mode, const char *cmdname, const char *const *argv)
 842 {
 843     return pPerl->piProc->Spawnvp(mode, cmdname, argv);
 844 }
 845
 846 int          _win32_mkdir(const char *dir, int mode)
 847 {
 848     return pPerl->piDir->Makedir(dir, mode, ErrorNo());
 849 }
 850
 851 int          _win32_rmdir(const char *dir)
 852 {
 853     return pPerl->piDir->Rmdir(dir, ErrorNo());
 854 }
 855
 856 int          _win32_chdir(const char *dir)
 857 {
 858     return pPerl->piDir->Chdir(dir, ErrorNo());
 859 }
 860
 861 #undef stat
 862 int          _win32_fstat(int fd,struct stat *sbufptr)
 863 {
 864     return pPerl->piLIO->FileStat(fd, sbufptr, ErrorNo());
 865 }
 866
 867 int          _win32_stat(const char *name,struct stat *sbufptr)
 868 {
 869     return pPerl->piLIO->NameStat(name, sbufptr, ErrorNo());
 870 }
 871
 872 int          _win32_setmode(int fd, int mode)
 873 {
 874     return pPerl->piLIO->Setmode(fd, mode, ErrorNo());
 875 }
 876
 877 long         _win32_lseek(int fd, long offset, int origin)
 878 {
 879     return pPerl->piLIO->Lseek(fd, offset, origin, ErrorNo());
 880 }
 881
 882 long         _win32_tell(int fd)
 883 {
 884     return pPerl->piStdIO->Tell((PerlIO*)fd, ErrorNo());
 885 }
 886
 887 int          _win32_dup(int fd)
 888 {
 889     return pPerl->piLIO->Dup(fd, ErrorNo());
 890 }
 891
 892 int          _win32_dup2(int h1, int h2)
 893 {
 894     return pPerl->piLIO->Dup2(h1, h2, ErrorNo());
 895 }
 896
 897 int          _win32_open(const char *path, int oflag,...)
 898 {
 899     return pPerl->piLIO->Open(path, oflag, ErrorNo());
 900 }
 901
 902 int          _win32_close(int fd)
 903 {
 904     return pPerl->piLIO->Close(fd, ErrorNo());
 905 }
 906
 907 int          _win32_read(int fd, void *buf, unsigned int cnt)
 908 {
 909     return pPerl->piLIO->Read(fd, buf, cnt, ErrorNo());
 910 }
 911
 912 int          _win32_write(int fd, const void *buf, unsigned int cnt)
 913 {
 914     return pPerl->piLIO->Write(fd, buf, cnt, ErrorNo());
 915 }
 916
 917 int          _win32_times(struct tms *timebuf)
 918 {
 919     return pPerl->piProc->Times(timebuf);
 920 }
 921
 922 int          _win32_ioctl(int i, unsigned int u, char *data)
 923 {
 924     return pPerl->piLIO->IOCtl(i, u, data, ErrorNo());
 925 }
 926
 927 int          _win32_utime(const char *f, struct utimbuf *t)
 928 {
 929     return pPerl->piLIO->Utime((char*)f, t, ErrorNo());
 930 }
 931
 932 char*   _win32_getenv(const char *name)
 933 {
 934     return pPerl->piENV->Getenv(name, ErrorNo());
 935 }
 936
 937 int          _win32_open_osfhandle(long handle, int flags)
 938 {
 939     return pPerl->piStdIO->OpenOSfhandle(handle, flags);
 940 }
 941
 942 long         _win32_get_osfhandle(int fd)
 943 {
 944     return pPerl->piStdIO->GetOSfhandle(fd);
 945 }
 946
 947 u_long _win32_htonl (u_long hostlong)
 948 {
 949     return pPerl->piSock->Htonl(hostlong);
 950 }
 951
 952 u_short _win32_htons (u_short hostshort)
 953 {
 954     return pPerl->piSock->Htons(hostshort);
 955 }
 956
 957 u_long _win32_ntohl (u_long netlong)
 958 {
 959     return pPerl->piSock->Ntohl(netlong);
 960 }
 961
 962 u_short _win32_ntohs (u_short netshort)
 963 {
 964     return pPerl->piSock->Ntohs(netshort);
 965 }
 966
 967 unsigned long _win32_inet_addr (const char * cp)
 968 {
 969     return pPerl->piSock->InetAddr(cp, ErrorNo());
 970 }
 971
 972 char * _win32_inet_ntoa (struct in_addr in)
 973 {
 974     return pPerl->piSock->InetNtoa(in, ErrorNo());
 975 }
 976
 977 SOCKET _win32_socket (int af, int type, int protocol)
 978 {
 979     return pPerl->piSock->Socket(af, type, protocol, ErrorNo());
 980 }
 981
 982 int _win32_bind (SOCKET s, const struct sockaddr *addr, int namelen)
 983 {
 984     return pPerl->piSock->Bind(s, addr, namelen, ErrorNo());
 985 }
 986
 987 int _win32_listen (SOCKET s, int backlog)
 988 {
 989     return pPerl->piSock->Listen(s, backlog, ErrorNo());
 990 }
 991
 992 SOCKET _win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen)
 993 {
 994     return pPerl->piSock->Accept(s, addr, addrlen, ErrorNo());
 995 }
 996
 997 int _win32_connect (SOCKET s, const struct sockaddr *name, int namelen)
 998 {
 999     return pPerl->piSock->Connect(s, name, namelen, ErrorNo());
1000 }
1001
1002 int _win32_send (SOCKET s, const char * buf, int len, int flags)
1003 {
1004     return pPerl->piSock->Send(s, buf, len, flags, ErrorNo());
1005 }
1006
1007 int _win32_sendto (SOCKET s, const char * buf, int len, int flags,
1008                        const struct sockaddr *to, int tolen)
1009 {
1010     return pPerl->piSock->Sendto(s, buf, len, flags, to, tolen, ErrorNo());
1011 }
1012
1013 int _win32_recv (SOCKET s, char * buf, int len, int flags)
1014 {
1015     return pPerl->piSock->Recv(s, buf, len, flags, ErrorNo());
1016 }
1017
1018 int _win32_recvfrom (SOCKET s, char * buf, int len, int flags,
1019                          struct sockaddr *from, int * fromlen)
1020 {
1021     return pPerl->piSock->Recvfrom(s, buf, len, flags, from, fromlen, ErrorNo());
1022 }
1023
1024 int _win32_shutdown (SOCKET s, int how)
1025 {
1026     return pPerl->piSock->Shutdown(s, how, ErrorNo());
1027 }
1028
1029 int _win32_closesocket (SOCKET s)
1030 {
1031     return pPerl->piSock->Closesocket(s, ErrorNo());
1032 }
1033
1034 int _win32_ioctlsocket (SOCKET s, long cmd, u_long *argp)
1035 {
1036     return pPerl->piSock->Ioctlsocket(s, cmd, argp, ErrorNo());
1037 }
1038
1039 int _win32_setsockopt (SOCKET s, int level, int optname,
1040                            const char * optval, int optlen)
1041 {
1042     return pPerl->piSock->Setsockopt(s, level, optname, optval, optlen, ErrorNo());
1043 }
1044
1045 int _win32_getsockopt (SOCKET s, int level, int optname, char * optval, int *optlen)
1046 {
1047     return pPerl->piSock->Getsockopt(s, level, optname, optval, optlen, ErrorNo());
1048 }
1049
1050 int _win32_getpeername (SOCKET s, struct sockaddr *name, int * namelen)
1051 {
1052     return pPerl->piSock->Getpeername(s, name, namelen, ErrorNo());
1053 }
1054
1055 int _win32_getsockname (SOCKET s, struct sockaddr *name, int * namelen)
1056 {
1057     return pPerl->piSock->Getsockname(s, name, namelen, ErrorNo());
1058 }
1059
1060 int _win32_gethostname (char * name, int namelen)
1061 {
1062     return pPerl->piSock->Gethostname(name, namelen, ErrorNo());
1063 }
1064
1065 struct hostent * _win32_gethostbyname(const char * name)
1066 {
1067     return pPerl->piSock->Gethostbyname(name, ErrorNo());
1068 }
1069
1070 struct hostent * _win32_gethostbyaddr(const char * addr, int len, int type)
1071 {
1072     return pPerl->piSock->Gethostbyaddr(addr, len, type, ErrorNo());
1073 }
1074
1075 struct protoent * _win32_getprotobyname(const char * name)
1076 {
1077     return pPerl->piSock->Getprotobyname(name, ErrorNo());
1078 }
1079
1080 struct protoent * _win32_getprotobynumber(int proto)
1081 {
1082     return pPerl->piSock->Getprotobynumber(proto, ErrorNo());
1083 }
1084
1085 struct servent * _win32_getservbyname(const char * name, const char * proto)
1086 {
1087     return pPerl->piSock->Getservbyname(name, proto, ErrorNo());
1088 }
1089
1090 struct servent * _win32_getservbyport(int port, const char * proto)
1091 {
1092     return pPerl->piSock->Getservbyport(port, proto, ErrorNo());
1093 }
1094
1095 int _win32_select (int nfds, Perl_fd_set *rfds, Perl_fd_set *wfds, Perl_fd_set *xfds,
1096                   const struct timeval *timeout)
1097 {
1098     return pPerl->piSock->Select(nfds, (char*)rfds, (char*)wfds, (char*)xfds, timeout, ErrorNo());
1099 }
1100
1101 void _win32_endnetent(void)
1102 {
1103     pPerl->piSock->Endnetent(ErrorNo());
1104 }
1105
1106 void _win32_endhostent(void)
1107 {
1108     pPerl->piSock->Endhostent(ErrorNo());
1109 }
1110
1111 void _win32_endprotoent(void)
1112 {
1113     pPerl->piSock->Endprotoent(ErrorNo());
1114 }
1115
1116 void _win32_endservent(void)
1117 {
1118     pPerl->piSock->Endservent(ErrorNo());
1119 }
1120
1121 struct netent * _win32_getnetent(void)
1122 {
1123     return pPerl->piSock->Getnetent(ErrorNo());
1124 }
1125
1126 struct netent * _win32_getnetbyname(char *name)
1127 {
1128     return pPerl->piSock->Getnetbyname(name, ErrorNo());
1129 }
1130
1131 struct netent * _win32_getnetbyaddr(long net, int type)
1132 {
1133     return pPerl->piSock->Getnetbyaddr(net, type, ErrorNo());
1134 }
1135
1136 struct protoent *_win32_getprotoent(void)
1137 {
1138     return pPerl->piSock->Getprotoent(ErrorNo());
1139 }
1140
1141 struct servent *_win32_getservent(void)
1142 {
1143     return pPerl->piSock->Getservent(ErrorNo());
1144 }
1145
1146 void _win32_sethostent(int stayopen)
1147 {
1148     pPerl->piSock->Sethostent(stayopen, ErrorNo());
1149 }
1150
1151 void _win32_setnetent(int stayopen)
1152 {
1153     pPerl->piSock->Setnetent(stayopen, ErrorNo());
1154 }
1155
1156 void _win32_setprotoent(int stayopen)
1157 {
1158     pPerl->piSock->Setprotoent(stayopen, ErrorNo());
1159 }
1160
1161 void _win32_setservent(int stayopen)
1162 {
1163     pPerl->piSock->Setservent(stayopen, ErrorNo());
1164 }
1165 } /* extern "C" */
1166 EOCODE
1167
1168
1169 print HDRFILE <<EOCODE;
1170 #undef Perl_op_desc
1171 char ** _Perl_op_desc ();
1172 #define Perl_op_desc (_Perl_op_desc())
1173
1174 #undef Perl_op_name
1175 char ** _Perl_op_name ();
1176 #define Perl_op_name (_Perl_op_name())
1177
1178 #undef Perl_no_modify
1179 char * _Perl_no_modify ();
1180 #define Perl_no_modify (_Perl_no_modify())
1181
1182 #undef Perl_opargs
1183 U32 * _Perl_opargs ();
1184 #define Perl_opargs (_Perl_opargs())
1185
1186
1187 #undef win32_errno
1188 #undef win32_stdin
1189 #undef win32_stdout
1190 #undef win32_stderr
1191 #undef win32_ferror
1192 #undef win32_feof
1193 #undef win32_fprintf
1194 #undef win32_printf
1195 #undef win32_vfprintf
1196 #undef win32_vprintf
1197 #undef win32_fread
1198 #undef win32_fwrite
1199 #undef win32_fopen
1200 #undef win32_fdopen
1201 #undef win32_freopen
1202 #undef win32_fclose
1203 #undef win32_fputs
1204 #undef win32_fputc
1205 #undef win32_ungetc
1206 #undef win32_getc
1207 #undef win32_fileno
1208 #undef win32_clearerr
1209 #undef win32_fflush
1210 #undef win32_ftell
1211 #undef win32_fseek
1212 #undef win32_fgetpos
1213 #undef win32_fsetpos
1214 #undef win32_rewind
1215 #undef win32_tmpfile
1216 #undef win32_abort
1217 #undef win32_fstat
1218 #undef win32_stat
1219 #undef win32_pipe
1220 #undef win32_popen
1221 #undef win32_pclose
1222 #undef win32_setmode
1223 #undef win32_lseek
1224 #undef win32_tell
1225 #undef win32_dup
1226 #undef win32_dup2
1227 #undef win32_open
1228 #undef win32_close
1229 #undef win32_eof
1230 #undef win32_read
1231 #undef win32_write
1232 #undef win32_mkdir
1233 #undef win32_rmdir
1234 #undef win32_chdir
1235 #undef win32_setbuf
1236 #undef win32_setvbuf
1237 #undef win32_fgetc
1238 #undef win32_fgets
1239 #undef win32_gets
1240 #undef win32_putc
1241 #undef win32_puts
1242 #undef win32_getchar
1243 #undef win32_putchar
1244 #undef win32_malloc
1245 #undef win32_calloc
1246 #undef win32_realloc
1247 #undef win32_free
1248 #undef win32_sleep
1249 #undef win32_times
1250 #undef win32_stat
1251 #undef win32_ioctl
1252 #undef win32_utime
1253 #undef win32_getenv
1254
1255 #undef win32_htonl
1256 #undef win32_htons
1257 #undef win32_ntohl
1258 #undef win32_ntohs
1259 #undef win32_inet_addr
1260 #undef win32_inet_ntoa
1261
1262 #undef win32_socket
1263 #undef win32_bind
1264 #undef win32_listen
1265 #undef win32_accept
1266 #undef win32_connect
1267 #undef win32_send
1268 #undef win32_sendto
1269 #undef win32_recv
1270 #undef win32_recvfrom
1271 #undef win32_shutdown
1272 #undef win32_closesocket
1273 #undef win32_ioctlsocket
1274 #undef win32_setsockopt
1275 #undef win32_getsockopt
1276 #undef win32_getpeername
1277 #undef win32_getsockname
1278 #undef win32_gethostname
1279 #undef win32_gethostbyname
1280 #undef win32_gethostbyaddr
1281 #undef win32_getprotobyname
1282 #undef win32_getprotobynumber
1283 #undef win32_getservbyname
1284 #undef win32_getservbyport
1285 #undef win32_select
1286 #undef win32_endhostent
1287 #undef win32_endnetent
1288 #undef win32_endprotoent
1289 #undef win32_endservent
1290 #undef win32_getnetent
1291 #undef win32_getnetbyname
1292 #undef win32_getnetbyaddr
1293 #undef win32_getprotoent
1294 #undef win32_getservent
1295 #undef win32_sethostent
1296 #undef win32_setnetent
1297 #undef win32_setprotoent
1298 #undef win32_setservent
1299
1300 #define win32_errno    _win32_errno
1301 #define win32_stdin    _win32_stdin
1302 #define win32_stdout   _win32_stdout
1303 #define win32_stderr   _win32_stderr
1304 #define win32_ferror   _win32_ferror
1305 #define win32_feof     _win32_feof
1306 #define win32_strerror _win32_strerror
1307 #define win32_perror   _win32_perror
1308 #define win32_fprintf  _win32_fprintf
1309 #define win32_printf   _win32_printf
1310 #define win32_vfprintf _win32_vfprintf
1311 #define win32_vprintf  _win32_vprintf
1312 #define win32_fread    _win32_fread
1313 #define win32_fwrite   _win32_fwrite
1314 #define win32_fopen    _win32_fopen
1315 #define win32_fdopen   _win32_fdopen
1316 #define win32_freopen  _win32_freopen
1317 #define win32_fclose   _win32_fclose
1318 #define win32_fputs    _win32_fputs
1319 #define win32_fputc    _win32_fputc
1320 #define win32_ungetc   _win32_ungetc
1321 #define win32_getc     _win32_getc
1322 #define win32_fileno   _win32_fileno
1323 #define win32_clearerr _win32_clearerr
1324 #define win32_fflush   _win32_fflush
1325 #define win32_ftell    _win32_ftell
1326 #define win32_fseek    _win32_fseek
1327 #define win32_fgetpos  _win32_fgetpos
1328 #define win32_fsetpos  _win32_fsetpos
1329 #define win32_rewind   _win32_rewind
1330 #define win32_tmpfile  _win32_tmpfile
1331 #define win32_abort    _win32_abort
1332 #define win32_fstat    _win32_fstat
1333 #define win32_stat     _win32_stat
1334 #define win32_pipe     _win32_pipe
1335 #define win32_popen    _win32_popen
1336 #define win32_pclose   _win32_pclose
1337 #define win32_setmode  _win32_setmode
1338 #define win32_lseek    _win32_lseek
1339 #define win32_tell     _win32_tell
1340 #define win32_dup      _win32_dup
1341 #define win32_dup2     _win32_dup2
1342 #define win32_open     _win32_open
1343 #define win32_close    _win32_close
1344 #define win32_eof      _win32_eof
1345 #define win32_read     _win32_read
1346 #define win32_write    _win32_write
1347 #define win32_mkdir    _win32_mkdir
1348 #define win32_rmdir    _win32_rmdir
1349 #define win32_chdir    _win32_chdir
1350 #define win32_setbuf   _win32_setbuf
1351 #define win32_setvbuf  _win32_setvbuf
1352 #define win32_fgetc    _win32_fgetc
1353 #define win32_fgets    _win32_fgets
1354 #define win32_gets     _win32_gets
1355 #define win32_putc     _win32_putc
1356 #define win32_puts     _win32_puts
1357 #define win32_getchar  _win32_getchar
1358 #define win32_putchar  _win32_putchar
1359 #define win32_malloc   _win32_malloc
1360 #define win32_calloc   _win32_calloc
1361 #define win32_realloc  _win32_realloc
1362 #define win32_free     _win32_free
1363 #define win32_sleep    _win32_sleep
1364 #define win32_spawnvp  _win32_spawnvp
1365 #define win32_times    _win32_times
1366 #define win32_stat     _win32_stat
1367 #define win32_ioctl    _win32_ioctl
1368 #define win32_utime    _win32_utime
1369 #define win32_getenv   _win32_getenv
1370 #define win32_open_osfhandle _win32_open_osfhandle
1371 #define win32_get_osfhandle  _win32_get_osfhandle
1372
1373 #define win32_htonl              _win32_htonl
1374 #define win32_htons              _win32_htons
1375 #define win32_ntohl              _win32_ntohl
1376 #define win32_ntohs              _win32_ntohs
1377 #define win32_inet_addr          _win32_inet_addr
1378 #define win32_inet_ntoa          _win32_inet_ntoa
1379
1380 #define win32_socket             _win32_socket
1381 #define win32_bind               _win32_bind
1382 #define win32_listen             _win32_listen
1383 #define win32_accept             _win32_accept
1384 #define win32_connect            _win32_connect
1385 #define win32_send               _win32_send
1386 #define win32_sendto             _win32_sendto
1387 #define win32_recv               _win32_recv
1388 #define win32_recvfrom           _win32_recvfrom
1389 #define win32_shutdown           _win32_shutdown
1390 #define win32_closesocket        _win32_closesocket
1391 #define win32_ioctlsocket        _win32_ioctlsocket
1392 #define win32_setsockopt         _win32_setsockopt
1393 #define win32_getsockopt         _win32_getsockopt
1394 #define win32_getpeername        _win32_getpeername
1395 #define win32_getsockname        _win32_getsockname
1396 #define win32_gethostname        _win32_gethostname
1397 #define win32_gethostbyname      _win32_gethostbyname
1398 #define win32_gethostbyaddr      _win32_gethostbyaddr
1399 #define win32_getprotobyname     _win32_getprotobyname
1400 #define win32_getprotobynumber   _win32_getprotobynumber
1401 #define win32_getservbyname      _win32_getservbyname
1402 #define win32_getservbyport      _win32_getservbyport
1403 #define win32_select             _win32_select
1404 #define win32_endhostent         _win32_endhostent
1405 #define win32_endnetent          _win32_endnetent
1406 #define win32_endprotoent        _win32_endprotoent
1407 #define win32_endservent         _win32_endservent
1408 #define win32_getnetent          _win32_getnetent
1409 #define win32_getnetbyname       _win32_getnetbyname
1410 #define win32_getnetbyaddr       _win32_getnetbyaddr
1411 #define win32_getprotoent        _win32_getprotoent
1412 #define win32_getservent         _win32_getservent
1413 #define win32_sethostent         _win32_sethostent
1414 #define win32_setnetent          _win32_setnetent
1415 #define win32_setprotoent        _win32_setprotoent
1416 #define win32_setservent         _win32_setservent
1417
1418 int *   _win32_errno(void);
1419 FILE*   _win32_stdin(void);
1420 FILE*   _win32_stdout(void);
1421 FILE*   _win32_stderr(void);
1422 int     _win32_ferror(FILE *fp);
1423 int     _win32_feof(FILE *fp);
1424 char*   _win32_strerror(int e);
1425 void    _win32_perror(const char *str);
1426 int     _win32_fprintf(FILE *pf, const char *format, ...);
1427 int     _win32_printf(const char *format, ...);
1428 int     _win32_vfprintf(FILE *pf, const char *format, va_list arg);
1429 int     _win32_vprintf(const char *format, va_list arg);
1430 size_t  _win32_fread(void *buf, size_t size, size_t count, FILE *pf);
1431 size_t  _win32_fwrite(const void *buf, size_t size, size_t count, FILE *pf);
1432 FILE*   _win32_fopen(const char *path, const char *mode);
1433 FILE*   _win32_fdopen(int fh, const char *mode);
1434 FILE*   _win32_freopen(const char *path, const char *mode, FILE *pf);
1435 int     _win32_fclose(FILE *pf);
1436 int     _win32_fputs(const char *s,FILE *pf);
1437 int     _win32_fputc(int c,FILE *pf);
1438 int     _win32_ungetc(int c,FILE *pf);
1439 int     _win32_getc(FILE *pf);
1440 int     _win32_fileno(FILE *pf);
1441 void    _win32_clearerr(FILE *pf);
1442 int     _win32_fflush(FILE *pf);
1443 long    _win32_ftell(FILE *pf);
1444 int     _win32_fseek(FILE *pf,long offset,int origin);
1445 int     _win32_fgetpos(FILE *pf,fpos_t *p);
1446 int     _win32_fsetpos(FILE *pf,const fpos_t *p);
1447 void    _win32_rewind(FILE *pf);
1448 FILE*   _win32_tmpfile(void);
1449 void    _win32_abort(void);
1450 int     _win32_fstat(int fd,struct stat *sbufptr);
1451 int     _win32_stat(const char *name,struct stat *sbufptr);
1452 int     _win32_pipe( int *phandles, unsigned int psize, int textmode );
1453 FILE*   _win32_popen( const char *command, const char *mode );
1454 int     _win32_pclose( FILE *pf);
1455 int     _win32_setmode( int fd, int mode);
1456 long    _win32_lseek( int fd, long offset, int origin);
1457 long    _win32_tell( int fd);
1458 int     _win32_dup( int fd);
1459 int     _win32_dup2(int h1, int h2);
1460 int     _win32_open(const char *path, int oflag,...);
1461 int     _win32_close(int fd);
1462 int     _win32_eof(int fd);
1463 int     _win32_read(int fd, void *buf, unsigned int cnt);
1464 int     _win32_write(int fd, const void *buf, unsigned int cnt);
1465 int     _win32_mkdir(const char *dir, int mode);
1466 int     _win32_rmdir(const char *dir);
1467 int     _win32_chdir(const char *dir);
1468 void    _win32_setbuf(FILE *pf, char *buf);
1469 int     _win32_setvbuf(FILE *pf, char *buf, int type, size_t size);
1470 char*   _win32_fgets(char *s, int n, FILE *pf);
1471 char*   _win32_gets(char *s);
1472 int     _win32_fgetc(FILE *pf);
1473 int     _win32_putc(int c, FILE *pf);
1474 int     _win32_puts(const char *s);
1475 int     _win32_getchar(void);
1476 int     _win32_putchar(int c);
1477 void*   _win32_malloc(size_t size);
1478 void*   _win32_calloc(size_t numitems, size_t size);
1479 void*   _win32_realloc(void *block, size_t size);
1480 void    _win32_free(void *block);
1481 unsigned _win32_sleep(unsigned int);
1482 int     _win32_spawnvp(int mode, const char *cmdname, const char *const *argv);
1483 int     _win32_times(struct tms *timebuf);
1484 int     _win32_stat(const char *path, struct stat *buf);
1485 int     _win32_ioctl(int i, unsigned int u, char *data);
1486 int     _win32_utime(const char *f, struct utimbuf *t);
1487 char*   _win32_getenv(const char *name);
1488 int     _win32_open_osfhandle(long handle, int flags);
1489 long    _win32_get_osfhandle(int fd);
1490
1491 u_long _win32_htonl (u_long hostlong);
1492 u_short _win32_htons (u_short hostshort);
1493 u_long _win32_ntohl (u_long netlong);
1494 u_short _win32_ntohs (u_short netshort);
1495 unsigned long _win32_inet_addr (const char * cp);
1496 char * _win32_inet_ntoa (struct in_addr in);
1497
1498 SOCKET _win32_socket (int af, int type, int protocol);
1499 int _win32_bind (SOCKET s, const struct sockaddr *addr, int namelen);
1500 int _win32_listen (SOCKET s, int backlog);
1501 SOCKET _win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen);
1502 int _win32_connect (SOCKET s, const struct sockaddr *name, int namelen);
1503 int _win32_send (SOCKET s, const char * buf, int len, int flags);
1504 int _win32_sendto (SOCKET s, const char * buf, int len, int flags,
1505                        const struct sockaddr *to, int tolen);
1506 int _win32_recv (SOCKET s, char * buf, int len, int flags);
1507 int _win32_recvfrom (SOCKET s, char * buf, int len, int flags,
1508                          struct sockaddr *from, int * fromlen);
1509 int _win32_shutdown (SOCKET s, int how);
1510 int _win32_closesocket (SOCKET s);
1511 int _win32_ioctlsocket (SOCKET s, long cmd, u_long *argp);
1512 int _win32_setsockopt (SOCKET s, int level, int optname,
1513                            const char * optval, int optlen);
1514 int _win32_getsockopt (SOCKET s, int level, int optname, char * optval, int *optlen);
1515 int _win32_getpeername (SOCKET s, struct sockaddr *name, int * namelen);
1516 int _win32_getsockname (SOCKET s, struct sockaddr *name, int * namelen);
1517 int _win32_gethostname (char * name, int namelen);
1518 struct hostent * _win32_gethostbyname(const char * name);
1519 struct hostent * _win32_gethostbyaddr(const char * addr, int len, int type);
1520 struct protoent * _win32_getprotobyname(const char * name);
1521 struct protoent * _win32_getprotobynumber(int proto);
1522 struct servent * _win32_getservbyname(const char * name, const char * proto);
1523 struct servent * _win32_getservbyport(int port, const char * proto);
1524 int _win32_select (int nfds, Perl_fd_set *rfds, Perl_fd_set *wfds, Perl_fd_set *xfds,
1525                   const struct timeval *timeout);
1526 void _win32_endnetent(void);
1527 void _win32_endhostent(void);
1528 void _win32_endprotoent(void);
1529 void _win32_endservent(void);
1530 struct netent * _win32_getnetent(void);
1531 struct netent * _win32_getnetbyname(char *name);
1532 struct netent * _win32_getnetbyaddr(long net, int type);
1533 struct protoent *_win32_getprotoent(void);
1534 struct servent *_win32_getservent(void);
1535 void _win32_sethostent(int stayopen);
1536 void _win32_setnetent(int stayopen);
1537 void _win32_setprotoent(int stayopen);
1538 void _win32_setservent(int stayopen);
1539
1540 #pragma warning(once : 4113)
1541 EOCODE
1542
1543
1544 close HDRFILE;
1545 close OUTFILE;