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