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