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