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