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 dumplvl
 420 oldlastpm
 421 gensym
 422 preambled
 423 preambleav
 424 Ilaststatval
 425 Ilaststype
 426 mess_sv
 427 ors
 428 opsave
 429 eval_mutex
 430 strtab_mutex
 431 orslen
 432 ofmt
 433 modcount
 434 generation
 435 DBcv
 436 archpat_auto
 437 sortcxix
 438 lastgotoprobe
 439 regdummy
 440 regcomp_parse
 441 regxend
 442 regcode
 443 regnaughty
 444 regsawback
 445 regprecomp
 446 regnpar
 447 regsize
 448 regflags
 449 regseen
 450 seen_zerolen
 451 regcomp_rx
 452 extralen
 453 colorset
 454 colors
 455 reginput
 456 regbol
 457 regeol
 458 regstartp
 459 regendp
 460 reglastparen
 461 regtill
 462 regprev
 463 reg_start_tmp
 464 reg_start_tmpl
 465 regdata
 466 bostr
 467 reg_flags
 468 reg_eval_set
 469 regnarrate
 470 regprogram
 471 regindent
 472 regcc
 473 in_clean_objs
 474 in_clean_all
 475 linestart
 476 pending_ident
 477 statusvalue_vms
 478 sublex_info
 479 thrsv
 480 threadnum
 481 PL_piMem
 482 PL_piENV
 483 PL_piStdIO
 484 PL_piLIO
 485 PL_piDir
 486 PL_piSock
 487 PL_piProc
 488 cshname
 489 threadsv_names
 490 thread
 491 nthreads
 492 thr_key
 493 threads_mutex
 494 malloc_mutex
 495 svref_mutex
 496 sv_mutex
 497 cred_mutex
 498 nthreads_cond
 499 eval_cond
 500 cryptseen
 501 cshlen
 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 CV* Perl_newXS(char* name, void (*subaddr)(CV* cv), char* filename);
 531
 532 ENDCODE
 533
 534 sub DoVariable($$) {
 535     my $name = shift;
 536     my $type = shift;
 537
 538     return if (defined $skip_list{$name});
 539     return if ($type eq 'struct perl_thread *');
 540
 541     print OUTFILE "\n#ifdef $name" . "_defined" unless ($separateObj == 0);
 542     print OUTFILE <<ENDCODE;
 543 #undef PL_$name
 544 extern "C" $type * _PL_$name ()
 545 {
 546     return (($type *)&pPerl->PL_$name);
 547 }
 548
 549 ENDCODE
 550
 551     print OUTFILE "#endif\n" unless ($separateObj == 0);
 552
 553     print HDRFILE <<ENDCODE;
 554
 555 #undef PL_$name
 556 $type * _PL_$name ();
 557 #define PL_$name (*_PL_$name())
 558
 559 ENDCODE
 560
 561 }
 562
 563 foreach $key (keys %intrp) {
 564     DoVariable ($key, $intrp{$key});
 565 }
 566
 567 foreach $key (keys %thread) {
 568     DoVariable ($key, $thread{$key});
 569 }
 570
 571 foreach $key (keys %globvar) {
 572     DoVariable ($key, $globvar{$key});
 573 }
 574
 575 print OUTFILE <<EOCODE;
 576
 577
 578 extern "C" {
 579
 580
 581 char ** _Perl_op_desc(void)
 582 {
 583     return pPerl->Perl_get_op_descs();
 584 }
 585
 586 char ** _Perl_op_name(void)
 587 {
 588     return pPerl->Perl_get_op_names();
 589 }
 590
 591 char *  _Perl_no_modify(void)
 592 {
 593     return pPerl->Perl_get_no_modify();
 594 }
 595
 596 U32 *   _Perl_opargs(void)
 597 {
 598     return pPerl->Perl_get_opargs();
 599 }
 600
 601 void xs_handler(CV* cv, CPerlObj* p)
 602 {
 603     void(*func)(CV*);
 604     SV* sv;
 605     MAGIC* m = pPerl->Perl_mg_find((SV*)cv, '~');
 606     if(m != NULL)
 607     {
 608         sv = m->mg_obj;
 609         if(SvIOK(sv))
 610         {
 611             func = (void(*)(CV*))SvIVX(sv);
 612         }
 613         else
 614         {
 615             func = (void(*)(CV*))pPerl->Perl_sv_2iv(sv);
 616         }
 617         func(cv);
 618     }
 619 }
 620
 621 CV* Perl_newXS(char* name, void (*subaddr)(CV* cv), char* filename)
 622 {
 623     CV* cv = pPerl->Perl_newXS(name, xs_handler, filename);
 624     pPerl->Perl_sv_magic((SV*)cv, pPerl->Perl_sv_2mortal(pPerl->Perl_newSViv((IV)subaddr)), '~', "CAPI", 4);
 625     return cv;
 626 }
 627
 628
 629 void Perl_deb(const char pat, ...)
 630 {
 631 }
 632
 633 #undef PL_piMem
 634 #undef PL_piENV
 635 #undef PL_piStdIO
 636 #undef PL_piLIO
 637 #undef PL_piDir
 638 #undef PL_piSock
 639 #undef PL_piProc
 640
 641 int *        _win32_errno(void)
 642 {
 643     return &pPerl->ErrorNo();
 644 }
 645
 646 FILE*        _win32_stdin(void)
 647 {
 648     return (FILE*)pPerl->PL_piStdIO->Stdin();
 649 }
 650
 651 FILE*        _win32_stdout(void)
 652 {
 653     return (FILE*)pPerl->PL_piStdIO->Stdout();
 654 }
 655
 656 FILE*        _win32_stderr(void)
 657 {
 658     return (FILE*)pPerl->PL_piStdIO->Stderr();
 659 }
 660
 661 int          _win32_ferror(FILE *fp)
 662 {
 663     return pPerl->PL_piStdIO->Error((PerlIO*)fp, ErrorNo());
 664 }
 665
 666 int          _win32_feof(FILE *fp)
 667 {
 668     return pPerl->PL_piStdIO->Eof((PerlIO*)fp, ErrorNo());
 669 }
 670
 671 char*        _win32_strerror(int e)
 672 {
 673     return strerror(e);
 674 }
 675
 676 void         _win32_perror(const char *str)
 677 {
 678     perror(str);
 679 }
 680
 681 int          _win32_vfprintf(FILE *pf, const char *format, va_list arg)
 682 {
 683     return pPerl->PL_piStdIO->Vprintf((PerlIO*)pf, ErrorNo(), format, arg);
 684 }
 685
 686 int          _win32_vprintf(const char *format, va_list arg)
 687 {
 688     return pPerl->PL_piStdIO->Vprintf(pPerl->PL_piStdIO->Stdout(), ErrorNo(), format, arg);
 689 }
 690
 691 int          _win32_fprintf(FILE *pf, const char *format, ...)
 692 {
 693     int ret;
 694     va_list args;
 695     va_start(args, format);
 696     ret = _win32_vfprintf(pf, format, args);
 697     va_end(args);
 698     return ret;
 699 }
 700
 701 int          _win32_printf(const char *format, ...)
 702 {
 703     int ret;
 704     va_list args;
 705     va_start(args, format);
 706     ret = _win32_vprintf(format, args);
 707     va_end(args);
 708     return ret;
 709 }
 710
 711 size_t       _win32_fread(void *buf, size_t size, size_t count, FILE *pf)
 712 {
 713     return pPerl->PL_piStdIO->Read((PerlIO*)pf, buf, (size*count), ErrorNo());
 714 }
 715
 716 size_t       _win32_fwrite(const void *buf, size_t size, size_t count, FILE *pf)
 717 {
 718     return pPerl->PL_piStdIO->Write((PerlIO*)pf, buf, (size*count), ErrorNo());
 719 }
 720
 721 FILE*        _win32_fopen(const char *path, const char *mode)
 722 {
 723     return (FILE*)pPerl->PL_piStdIO->Open(path, mode, ErrorNo());
 724 }
 725
 726 FILE*        _win32_fdopen(int fh, const char *mode)
 727 {
 728     return (FILE*)pPerl->PL_piStdIO->Fdopen(fh, mode, ErrorNo());
 729 }
 730
 731 FILE*        _win32_freopen(const char *path, const char *mode, FILE *pf)
 732 {
 733     return (FILE*)pPerl->PL_piStdIO->Reopen(path, mode, (PerlIO*)pf, ErrorNo());
 734 }
 735
 736 int          _win32_fclose(FILE *pf)
 737 {
 738     return pPerl->PL_piStdIO->Close((PerlIO*)pf, ErrorNo());
 739 }
 740
 741 int          _win32_fputs(const char *s,FILE *pf)
 742 {
 743     return pPerl->PL_piStdIO->Puts((PerlIO*)pf, s, ErrorNo());
 744 }
 745
 746 int          _win32_fputc(int c,FILE *pf)
 747 {
 748     return pPerl->PL_piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
 749 }
 750
 751 int          _win32_ungetc(int c,FILE *pf)
 752 {
 753     return pPerl->PL_piStdIO->Ungetc((PerlIO*)pf, c, ErrorNo());
 754 }
 755
 756 int          _win32_getc(FILE *pf)
 757 {
 758     return pPerl->PL_piStdIO->Getc((PerlIO*)pf, ErrorNo());
 759 }
 760
 761 int          _win32_fileno(FILE *pf)
 762 {
 763     return pPerl->PL_piStdIO->Fileno((PerlIO*)pf, ErrorNo());
 764 }
 765
 766 void         _win32_clearerr(FILE *pf)
 767 {
 768     pPerl->PL_piStdIO->Clearerr((PerlIO*)pf, ErrorNo());
 769 }
 770
 771 int          _win32_fflush(FILE *pf)
 772 {
 773     return pPerl->PL_piStdIO->Flush((PerlIO*)pf, ErrorNo());
 774 }
 775
 776 long         _win32_ftell(FILE *pf)
 777 {
 778     return pPerl->PL_piStdIO->Tell((PerlIO*)pf, ErrorNo());
 779 }
 780
 781 int          _win32_fseek(FILE *pf,long offset,int origin)
 782 {
 783     return pPerl->PL_piStdIO->Seek((PerlIO*)pf, offset, origin, ErrorNo());
 784 }
 785
 786 int          _win32_fgetpos(FILE *pf,fpos_t *p)
 787 {
 788     return pPerl->PL_piStdIO->Getpos((PerlIO*)pf, p, ErrorNo());
 789 }
 790
 791 int          _win32_fsetpos(FILE *pf,const fpos_t *p)
 792 {
 793     return pPerl->PL_piStdIO->Setpos((PerlIO*)pf, p, ErrorNo());
 794 }
 795
 796 void         _win32_rewind(FILE *pf)
 797 {
 798     pPerl->PL_piStdIO->Rewind((PerlIO*)pf, ErrorNo());
 799 }
 800
 801 FILE*        _win32_tmpfile(void)
 802 {
 803     return (FILE*)pPerl->PL_piStdIO->Tmpfile(ErrorNo());
 804 }
 805
 806 void         _win32_setbuf(FILE *pf, char *buf)
 807 {
 808     pPerl->PL_piStdIO->SetBuf((PerlIO*)pf, buf, ErrorNo());
 809 }
 810
 811 int          _win32_setvbuf(FILE *pf, char *buf, int type, size_t size)
 812 {
 813     return pPerl->PL_piStdIO->SetVBuf((PerlIO*)pf, buf, type, size, ErrorNo());
 814 }
 815
 816 char*           _win32_fgets(char *s, int n, FILE *pf)
 817 {
 818     return pPerl->PL_piStdIO->Gets((PerlIO*)pf, s, n, ErrorNo());
 819 }
 820
 821 char*           _win32_gets(char *s)
 822 {
 823     return _win32_fgets(s, 80, (FILE*)pPerl->PL_piStdIO->Stdin());
 824 }
 825
 826 int          _win32_fgetc(FILE *pf)
 827 {
 828     return pPerl->PL_piStdIO->Getc((PerlIO*)pf, ErrorNo());
 829 }
 830
 831 int          _win32_putc(int c, FILE *pf)
 832 {
 833     return pPerl->PL_piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
 834 }
 835
 836 int          _win32_puts(const char *s)
 837 {
 838     return pPerl->PL_piStdIO->Puts(pPerl->PL_piStdIO->Stdout(), s, ErrorNo());
 839 }
 840
 841 int          _win32_getchar(void)
 842 {
 843     return pPerl->PL_piStdIO->Getc(pPerl->PL_piStdIO->Stdin(), ErrorNo());
 844 }
 845
 846 int          _win32_putchar(int c)
 847 {
 848     return pPerl->PL_piStdIO->Putc(pPerl->PL_piStdIO->Stdout(), c, ErrorNo());
 849 }
 850
 851 void*        _win32_malloc(size_t size)
 852 {
 853     return pPerl->PL_piMem->Malloc(size);
 854 }
 855
 856 void*        _win32_calloc(size_t numitems, size_t size)
 857 {
 858     return pPerl->PL_piMem->Malloc(numitems*size);
 859 }
 860
 861 void*        _win32_realloc(void *block, size_t size)
 862 {
 863     return pPerl->PL_piMem->Realloc(block, size);
 864 }
 865
 866 void         _win32_free(void *block)
 867 {
 868     pPerl->PL_piMem->Free(block);
 869 }
 870
 871 void         _win32_abort(void)
 872 {
 873     pPerl->PL_piProc->Abort();
 874 }
 875
 876 int          _win32_pipe(int *phandles, unsigned int psize, int textmode)
 877 {
 878     return pPerl->PL_piProc->Pipe(phandles);
 879 }
 880
 881 FILE*        _win32_popen(const char *command, const char *mode)
 882 {
 883     return (FILE*)pPerl->PL_piProc->Popen(command, mode);
 884 }
 885
 886 int          _win32_pclose(FILE *pf)
 887 {
 888     return pPerl->PL_piProc->Pclose((PerlIO*)pf);
 889 }
 890
 891 unsigned     _win32_sleep(unsigned int t)
 892 {
 893     return pPerl->PL_piProc->Sleep(t);
 894 }
 895
 896 int     _win32_spawnvp(int mode, const char *cmdname, const char *const *argv)
 897 {
 898     return pPerl->PL_piProc->Spawnvp(mode, cmdname, argv);
 899 }
 900
 901 int          _win32_mkdir(const char *dir, int mode)
 902 {
 903     return pPerl->PL_piDir->Makedir(dir, mode, ErrorNo());
 904 }
 905
 906 int          _win32_rmdir(const char *dir)
 907 {
 908     return pPerl->PL_piDir->Rmdir(dir, ErrorNo());
 909 }
 910
 911 int          _win32_chdir(const char *dir)
 912 {
 913     return pPerl->PL_piDir->Chdir(dir, ErrorNo());
 914 }
 915
 916 #undef stat
 917 int          _win32_fstat(int fd,struct stat *sbufptr)
 918 {
 919     return pPerl->PL_piLIO->FileStat(fd, sbufptr, ErrorNo());
 920 }
 921
 922 int          _win32_stat(const char *name,struct stat *sbufptr)
 923 {
 924     return pPerl->PL_piLIO->NameStat(name, sbufptr, ErrorNo());
 925 }
 926
 927 int          _win32_rename(const char *oname, const char *newname)
 928 {
 929     return pPerl->PL_piLIO->Rename(oname, newname, ErrorNo());
 930 }
 931
 932 int          _win32_setmode(int fd, int mode)
 933 {
 934     return pPerl->PL_piLIO->Setmode(fd, mode, ErrorNo());
 935 }
 936
 937 long         _win32_lseek(int fd, long offset, int origin)
 938 {
 939     return pPerl->PL_piLIO->Lseek(fd, offset, origin, ErrorNo());
 940 }
 941
 942 long         _win32_tell(int fd)
 943 {
 944     return pPerl->PL_piStdIO->Tell((PerlIO*)fd, ErrorNo());
 945 }
 946
 947 int          _win32_dup(int fd)
 948 {
 949     return pPerl->PL_piLIO->Dup(fd, ErrorNo());
 950 }
 951
 952 int          _win32_dup2(int h1, int h2)
 953 {
 954     return pPerl->PL_piLIO->Dup2(h1, h2, ErrorNo());
 955 }
 956
 957 int          _win32_open(const char *path, int oflag,...)
 958 {
 959     return pPerl->PL_piLIO->Open(path, oflag, ErrorNo());
 960 }
 961
 962 int          _win32_close(int fd)
 963 {
 964     return pPerl->PL_piLIO->Close(fd, ErrorNo());
 965 }
 966
 967 int          _win32_read(int fd, void *buf, unsigned int cnt)
 968 {
 969     return pPerl->PL_piLIO->Read(fd, buf, cnt, ErrorNo());
 970 }
 971
 972 int          _win32_write(int fd, const void *buf, unsigned int cnt)
 973 {
 974     return pPerl->PL_piLIO->Write(fd, buf, cnt, ErrorNo());
 975 }
 976
 977 int          _win32_times(struct tms *timebuf)
 978 {
 979     return pPerl->PL_piProc->Times(timebuf);
 980 }
 981
 982 int          _win32_ioctl(int i, unsigned int u, char *data)
 983 {
 984     return pPerl->PL_piLIO->IOCtl(i, u, data, ErrorNo());
 985 }
 986
 987 int          _win32_utime(const char *f, struct utimbuf *t)
 988 {
 989     return pPerl->PL_piLIO->Utime((char*)f, t, ErrorNo());
 990 }
 991
 992 char*   _win32_getenv(const char *name)
 993 {
 994     return pPerl->PL_piENV->Getenv(name, ErrorNo());
 995 }
 996
 997 int          _win32_open_osfhandle(long handle, int flags)
 998 {
 999     return pPerl->PL_piStdIO->OpenOSfhandle(handle, flags);
1000 }
1001
1002 long         _win32_get_osfhandle(int fd)
1003 {
1004     return pPerl->PL_piStdIO->GetOSfhandle(fd);
1005 }
1006
1007 u_long _win32_htonl (u_long hostlong)
1008 {
1009     return pPerl->PL_piSock->Htonl(hostlong);
1010 }
1011
1012 u_short _win32_htons (u_short hostshort)
1013 {
1014     return pPerl->PL_piSock->Htons(hostshort);
1015 }
1016
1017 u_long _win32_ntohl (u_long netlong)
1018 {
1019     return pPerl->PL_piSock->Ntohl(netlong);
1020 }
1021
1022 u_short _win32_ntohs (u_short netshort)
1023 {
1024     return pPerl->PL_piSock->Ntohs(netshort);
1025 }
1026
1027 unsigned long _win32_inet_addr (const char * cp)
1028 {
1029     return pPerl->PL_piSock->InetAddr(cp, ErrorNo());
1030 }
1031
1032 char * _win32_inet_ntoa (struct in_addr in)
1033 {
1034     return pPerl->PL_piSock->InetNtoa(in, ErrorNo());
1035 }
1036
1037 SOCKET _win32_socket (int af, int type, int protocol)
1038 {
1039     return pPerl->PL_piSock->Socket(af, type, protocol, ErrorNo());
1040 }
1041
1042 int _win32_bind (SOCKET s, const struct sockaddr *addr, int namelen)
1043 {
1044     return pPerl->PL_piSock->Bind(s, addr, namelen, ErrorNo());
1045 }
1046
1047 int _win32_listen (SOCKET s, int backlog)
1048 {
1049     return pPerl->PL_piSock->Listen(s, backlog, ErrorNo());
1050 }
1051
1052 SOCKET _win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen)
1053 {
1054     return pPerl->PL_piSock->Accept(s, addr, addrlen, ErrorNo());
1055 }
1056
1057 int _win32_connect (SOCKET s, const struct sockaddr *name, int namelen)
1058 {
1059     return pPerl->PL_piSock->Connect(s, name, namelen, ErrorNo());
1060 }
1061
1062 int _win32_send (SOCKET s, const char * buf, int len, int flags)
1063 {
1064     return pPerl->PL_piSock->Send(s, buf, len, flags, ErrorNo());
1065 }
1066
1067 int _win32_sendto (SOCKET s, const char * buf, int len, int flags,
1068                        const struct sockaddr *to, int tolen)
1069 {
1070     return pPerl->PL_piSock->Sendto(s, buf, len, flags, to, tolen, ErrorNo());
1071 }
1072
1073 int _win32_recv (SOCKET s, char * buf, int len, int flags)
1074 {
1075     return pPerl->PL_piSock->Recv(s, buf, len, flags, ErrorNo());
1076 }
1077
1078 int _win32_recvfrom (SOCKET s, char * buf, int len, int flags,
1079                          struct sockaddr *from, int * fromlen)
1080 {
1081     return pPerl->PL_piSock->Recvfrom(s, buf, len, flags, from, fromlen, ErrorNo());
1082 }
1083
1084 int _win32_shutdown (SOCKET s, int how)
1085 {
1086     return pPerl->PL_piSock->Shutdown(s, how, ErrorNo());
1087 }
1088
1089 int _win32_closesocket (SOCKET s)
1090 {
1091     return pPerl->PL_piSock->Closesocket(s, ErrorNo());
1092 }
1093
1094 int _win32_ioctlsocket (SOCKET s, long cmd, u_long *argp)
1095 {
1096     return pPerl->PL_piSock->Ioctlsocket(s, cmd, argp, ErrorNo());
1097 }
1098
1099 int _win32_setsockopt (SOCKET s, int level, int optname,
1100                            const char * optval, int optlen)
1101 {
1102     return pPerl->PL_piSock->Setsockopt(s, level, optname, optval, optlen, ErrorNo());
1103 }
1104
1105 int _win32_getsockopt (SOCKET s, int level, int optname, char * optval, int *optlen)
1106 {
1107     return pPerl->PL_piSock->Getsockopt(s, level, optname, optval, optlen, ErrorNo());
1108 }
1109
1110 int _win32_getpeername (SOCKET s, struct sockaddr *name, int * namelen)
1111 {
1112     return pPerl->PL_piSock->Getpeername(s, name, namelen, ErrorNo());
1113 }
1114
1115 int _win32_getsockname (SOCKET s, struct sockaddr *name, int * namelen)
1116 {
1117     return pPerl->PL_piSock->Getsockname(s, name, namelen, ErrorNo());
1118 }
1119
1120 int _win32_gethostname (char * name, int namelen)
1121 {
1122     return pPerl->PL_piSock->Gethostname(name, namelen, ErrorNo());
1123 }
1124
1125 struct hostent * _win32_gethostbyname(const char * name)
1126 {
1127     return pPerl->PL_piSock->Gethostbyname(name, ErrorNo());
1128 }
1129
1130 struct hostent * _win32_gethostbyaddr(const char * addr, int len, int type)
1131 {
1132     return pPerl->PL_piSock->Gethostbyaddr(addr, len, type, ErrorNo());
1133 }
1134
1135 struct protoent * _win32_getprotobyname(const char * name)
1136 {
1137     return pPerl->PL_piSock->Getprotobyname(name, ErrorNo());
1138 }
1139
1140 struct protoent * _win32_getprotobynumber(int proto)
1141 {
1142     return pPerl->PL_piSock->Getprotobynumber(proto, ErrorNo());
1143 }
1144
1145 struct servent * _win32_getservbyname(const char * name, const char * proto)
1146 {
1147     return pPerl->PL_piSock->Getservbyname(name, proto, ErrorNo());
1148 }
1149
1150 struct servent * _win32_getservbyport(int port, const char * proto)
1151 {
1152     return pPerl->PL_piSock->Getservbyport(port, proto, ErrorNo());
1153 }
1154
1155 int _win32_select (int nfds, Perl_fd_set *rfds, Perl_fd_set *wfds, Perl_fd_set *xfds,
1156                   const struct timeval *timeout)
1157 {
1158     return pPerl->PL_piSock->Select(nfds, (char*)rfds, (char*)wfds, (char*)xfds, timeout, ErrorNo());
1159 }
1160
1161 void _win32_endnetent(void)
1162 {
1163     pPerl->PL_piSock->Endnetent(ErrorNo());
1164 }
1165
1166 void _win32_endhostent(void)
1167 {
1168     pPerl->PL_piSock->Endhostent(ErrorNo());
1169 }
1170
1171 void _win32_endprotoent(void)
1172 {
1173     pPerl->PL_piSock->Endprotoent(ErrorNo());
1174 }
1175
1176 void _win32_endservent(void)
1177 {
1178     pPerl->PL_piSock->Endservent(ErrorNo());
1179 }
1180
1181 struct netent * _win32_getnetent(void)
1182 {
1183     return pPerl->PL_piSock->Getnetent(ErrorNo());
1184 }
1185
1186 struct netent * _win32_getnetbyname(char *name)
1187 {
1188     return pPerl->PL_piSock->Getnetbyname(name, ErrorNo());
1189 }
1190
1191 struct netent * _win32_getnetbyaddr(long net, int type)
1192 {
1193     return pPerl->PL_piSock->Getnetbyaddr(net, type, ErrorNo());
1194 }
1195
1196 struct protoent *_win32_getprotoent(void)
1197 {
1198     return pPerl->PL_piSock->Getprotoent(ErrorNo());
1199 }
1200
1201 struct servent *_win32_getservent(void)
1202 {
1203     return pPerl->PL_piSock->Getservent(ErrorNo());
1204 }
1205
1206 void _win32_sethostent(int stayopen)
1207 {
1208     pPerl->PL_piSock->Sethostent(stayopen, ErrorNo());
1209 }
1210
1211 void _win32_setnetent(int stayopen)
1212 {
1213     pPerl->PL_piSock->Setnetent(stayopen, ErrorNo());
1214 }
1215
1216 void _win32_setprotoent(int stayopen)
1217 {
1218     pPerl->PL_piSock->Setprotoent(stayopen, ErrorNo());
1219 }
1220
1221 void _win32_setservent(int stayopen)
1222 {
1223     pPerl->PL_piSock->Setservent(stayopen, ErrorNo());
1224 }
1225 } /* extern "C" */
1226 EOCODE
1227
1228
1229 print HDRFILE <<EOCODE;
1230 #undef Perl_op_desc
1231 char ** _Perl_op_desc ();
1232 #define Perl_op_desc (_Perl_op_desc())
1233
1234 #undef Perl_op_name
1235 char ** _Perl_op_name ();
1236 #define Perl_op_name (_Perl_op_name())
1237
1238 #undef Perl_no_modify
1239 char * _Perl_no_modify ();
1240 #define Perl_no_modify (_Perl_no_modify())
1241
1242 #undef Perl_opargs
1243 U32 * _Perl_opargs ();
1244 #define Perl_opargs (_Perl_opargs())
1245
1246
1247 #undef win32_errno
1248 #undef win32_stdin
1249 #undef win32_stdout
1250 #undef win32_stderr
1251 #undef win32_ferror
1252 #undef win32_feof
1253 #undef win32_fprintf
1254 #undef win32_printf
1255 #undef win32_vfprintf
1256 #undef win32_vprintf
1257 #undef win32_fread
1258 #undef win32_fwrite
1259 #undef win32_fopen
1260 #undef win32_fdopen
1261 #undef win32_freopen
1262 #undef win32_fclose
1263 #undef win32_fputs
1264 #undef win32_fputc
1265 #undef win32_ungetc
1266 #undef win32_getc
1267 #undef win32_fileno
1268 #undef win32_clearerr
1269 #undef win32_fflush
1270 #undef win32_ftell
1271 #undef win32_fseek
1272 #undef win32_fgetpos
1273 #undef win32_fsetpos
1274 #undef win32_rewind
1275 #undef win32_tmpfile
1276 #undef win32_abort
1277 #undef win32_fstat
1278 #undef win32_stat
1279 #undef win32_pipe
1280 #undef win32_popen
1281 #undef win32_pclose
1282 #undef win32_rename
1283 #undef win32_setmode
1284 #undef win32_lseek
1285 #undef win32_tell
1286 #undef win32_dup
1287 #undef win32_dup2
1288 #undef win32_open
1289 #undef win32_close
1290 #undef win32_eof
1291 #undef win32_read
1292 #undef win32_write
1293 #undef win32_mkdir
1294 #undef win32_rmdir
1295 #undef win32_chdir
1296 #undef win32_setbuf
1297 #undef win32_setvbuf
1298 #undef win32_fgetc
1299 #undef win32_fgets
1300 #undef win32_gets
1301 #undef win32_putc
1302 #undef win32_puts
1303 #undef win32_getchar
1304 #undef win32_putchar
1305 #undef win32_malloc
1306 #undef win32_calloc
1307 #undef win32_realloc
1308 #undef win32_free
1309 #undef win32_sleep
1310 #undef win32_times
1311 #undef win32_stat
1312 #undef win32_ioctl
1313 #undef win32_utime
1314 #undef win32_getenv
1315
1316 #undef win32_htonl
1317 #undef win32_htons
1318 #undef win32_ntohl
1319 #undef win32_ntohs
1320 #undef win32_inet_addr
1321 #undef win32_inet_ntoa
1322
1323 #undef win32_socket
1324 #undef win32_bind
1325 #undef win32_listen
1326 #undef win32_accept
1327 #undef win32_connect
1328 #undef win32_send
1329 #undef win32_sendto
1330 #undef win32_recv
1331 #undef win32_recvfrom
1332 #undef win32_shutdown
1333 #undef win32_closesocket
1334 #undef win32_ioctlsocket
1335 #undef win32_setsockopt
1336 #undef win32_getsockopt
1337 #undef win32_getpeername
1338 #undef win32_getsockname
1339 #undef win32_gethostname
1340 #undef win32_gethostbyname
1341 #undef win32_gethostbyaddr
1342 #undef win32_getprotobyname
1343 #undef win32_getprotobynumber
1344 #undef win32_getservbyname
1345 #undef win32_getservbyport
1346 #undef win32_select
1347 #undef win32_endhostent
1348 #undef win32_endnetent
1349 #undef win32_endprotoent
1350 #undef win32_endservent
1351 #undef win32_getnetent
1352 #undef win32_getnetbyname
1353 #undef win32_getnetbyaddr
1354 #undef win32_getprotoent
1355 #undef win32_getservent
1356 #undef win32_sethostent
1357 #undef win32_setnetent
1358 #undef win32_setprotoent
1359 #undef win32_setservent
1360
1361 #define win32_errno    _win32_errno
1362 #define win32_stdin    _win32_stdin
1363 #define win32_stdout   _win32_stdout
1364 #define win32_stderr   _win32_stderr
1365 #define win32_ferror   _win32_ferror
1366 #define win32_feof     _win32_feof
1367 #define win32_strerror _win32_strerror
1368 #define win32_perror   _win32_perror
1369 #define win32_fprintf  _win32_fprintf
1370 #define win32_printf   _win32_printf
1371 #define win32_vfprintf _win32_vfprintf
1372 #define win32_vprintf  _win32_vprintf
1373 #define win32_fread    _win32_fread
1374 #define win32_fwrite   _win32_fwrite
1375 #define win32_fopen    _win32_fopen
1376 #define win32_fdopen   _win32_fdopen
1377 #define win32_freopen  _win32_freopen
1378 #define win32_fclose   _win32_fclose
1379 #define win32_fputs    _win32_fputs
1380 #define win32_fputc    _win32_fputc
1381 #define win32_ungetc   _win32_ungetc
1382 #define win32_getc     _win32_getc
1383 #define win32_fileno   _win32_fileno
1384 #define win32_clearerr _win32_clearerr
1385 #define win32_fflush   _win32_fflush
1386 #define win32_ftell    _win32_ftell
1387 #define win32_fseek    _win32_fseek
1388 #define win32_fgetpos  _win32_fgetpos
1389 #define win32_fsetpos  _win32_fsetpos
1390 #define win32_rewind   _win32_rewind
1391 #define win32_tmpfile  _win32_tmpfile
1392 #define win32_abort    _win32_abort
1393 #define win32_fstat    _win32_fstat
1394 #define win32_stat     _win32_stat
1395 #define win32_pipe     _win32_pipe
1396 #define win32_popen    _win32_popen
1397 #define win32_pclose   _win32_pclose
1398 #define win32_rename   _win32_rename
1399 #define win32_setmode  _win32_setmode
1400 #define win32_lseek    _win32_lseek
1401 #define win32_tell     _win32_tell
1402 #define win32_dup      _win32_dup
1403 #define win32_dup2     _win32_dup2
1404 #define win32_open     _win32_open
1405 #define win32_close    _win32_close
1406 #define win32_eof      _win32_eof
1407 #define win32_read     _win32_read
1408 #define win32_write    _win32_write
1409 #define win32_mkdir    _win32_mkdir
1410 #define win32_rmdir    _win32_rmdir
1411 #define win32_chdir    _win32_chdir
1412 #define win32_setbuf   _win32_setbuf
1413 #define win32_setvbuf  _win32_setvbuf
1414 #define win32_fgetc    _win32_fgetc
1415 #define win32_fgets    _win32_fgets
1416 #define win32_gets     _win32_gets
1417 #define win32_putc     _win32_putc
1418 #define win32_puts     _win32_puts
1419 #define win32_getchar  _win32_getchar
1420 #define win32_putchar  _win32_putchar
1421 #define win32_malloc   _win32_malloc
1422 #define win32_calloc   _win32_calloc
1423 #define win32_realloc  _win32_realloc
1424 #define win32_free     _win32_free
1425 #define win32_sleep    _win32_sleep
1426 #define win32_spawnvp  _win32_spawnvp
1427 #define win32_times    _win32_times
1428 #define win32_stat     _win32_stat
1429 #define win32_ioctl    _win32_ioctl
1430 #define win32_utime    _win32_utime
1431 #define win32_getenv   _win32_getenv
1432 #define win32_open_osfhandle _win32_open_osfhandle
1433 #define win32_get_osfhandle  _win32_get_osfhandle
1434
1435 #define win32_htonl              _win32_htonl
1436 #define win32_htons              _win32_htons
1437 #define win32_ntohl              _win32_ntohl
1438 #define win32_ntohs              _win32_ntohs
1439 #define win32_inet_addr          _win32_inet_addr
1440 #define win32_inet_ntoa          _win32_inet_ntoa
1441
1442 #define win32_socket             _win32_socket
1443 #define win32_bind               _win32_bind
1444 #define win32_listen             _win32_listen
1445 #define win32_accept             _win32_accept
1446 #define win32_connect            _win32_connect
1447 #define win32_send               _win32_send
1448 #define win32_sendto             _win32_sendto
1449 #define win32_recv               _win32_recv
1450 #define win32_recvfrom           _win32_recvfrom
1451 #define win32_shutdown           _win32_shutdown
1452 #define win32_closesocket        _win32_closesocket
1453 #define win32_ioctlsocket        _win32_ioctlsocket
1454 #define win32_setsockopt         _win32_setsockopt
1455 #define win32_getsockopt         _win32_getsockopt
1456 #define win32_getpeername        _win32_getpeername
1457 #define win32_getsockname        _win32_getsockname
1458 #define win32_gethostname        _win32_gethostname
1459 #define win32_gethostbyname      _win32_gethostbyname
1460 #define win32_gethostbyaddr      _win32_gethostbyaddr
1461 #define win32_getprotobyname     _win32_getprotobyname
1462 #define win32_getprotobynumber   _win32_getprotobynumber
1463 #define win32_getservbyname      _win32_getservbyname
1464 #define win32_getservbyport      _win32_getservbyport
1465 #define win32_select             _win32_select
1466 #define win32_endhostent         _win32_endhostent
1467 #define win32_endnetent          _win32_endnetent
1468 #define win32_endprotoent        _win32_endprotoent
1469 #define win32_endservent         _win32_endservent
1470 #define win32_getnetent          _win32_getnetent
1471 #define win32_getnetbyname       _win32_getnetbyname
1472 #define win32_getnetbyaddr       _win32_getnetbyaddr
1473 #define win32_getprotoent        _win32_getprotoent
1474 #define win32_getservent         _win32_getservent
1475 #define win32_sethostent         _win32_sethostent
1476 #define win32_setnetent          _win32_setnetent
1477 #define win32_setprotoent        _win32_setprotoent
1478 #define win32_setservent         _win32_setservent
1479
1480 int *   _win32_errno(void);
1481 FILE*   _win32_stdin(void);
1482 FILE*   _win32_stdout(void);
1483 FILE*   _win32_stderr(void);
1484 int     _win32_ferror(FILE *fp);
1485 int     _win32_feof(FILE *fp);
1486 char*   _win32_strerror(int e);
1487 void    _win32_perror(const char *str);
1488 int     _win32_fprintf(FILE *pf, const char *format, ...);
1489 int     _win32_printf(const char *format, ...);
1490 int     _win32_vfprintf(FILE *pf, const char *format, va_list arg);
1491 int     _win32_vprintf(const char *format, va_list arg);
1492 size_t  _win32_fread(void *buf, size_t size, size_t count, FILE *pf);
1493 size_t  _win32_fwrite(const void *buf, size_t size, size_t count, FILE *pf);
1494 FILE*   _win32_fopen(const char *path, const char *mode);
1495 FILE*   _win32_fdopen(int fh, const char *mode);
1496 FILE*   _win32_freopen(const char *path, const char *mode, FILE *pf);
1497 int     _win32_fclose(FILE *pf);
1498 int     _win32_fputs(const char *s,FILE *pf);
1499 int     _win32_fputc(int c,FILE *pf);
1500 int     _win32_ungetc(int c,FILE *pf);
1501 int     _win32_getc(FILE *pf);
1502 int     _win32_fileno(FILE *pf);
1503 void    _win32_clearerr(FILE *pf);
1504 int     _win32_fflush(FILE *pf);
1505 long    _win32_ftell(FILE *pf);
1506 int     _win32_fseek(FILE *pf,long offset,int origin);
1507 int     _win32_fgetpos(FILE *pf,fpos_t *p);
1508 int     _win32_fsetpos(FILE *pf,const fpos_t *p);
1509 void    _win32_rewind(FILE *pf);
1510 FILE*   _win32_tmpfile(void);
1511 void    _win32_abort(void);
1512 int     _win32_fstat(int fd,struct stat *sbufptr);
1513 int     _win32_stat(const char *name,struct stat *sbufptr);
1514 int     _win32_pipe( int *phandles, unsigned int psize, int textmode );
1515 FILE*   _win32_popen( const char *command, const char *mode );
1516 int     _win32_pclose( FILE *pf);
1517 int     _win32_rename( const char *oldname, const char *newname);
1518 int     _win32_setmode( int fd, int mode);
1519 long    _win32_lseek( int fd, long offset, int origin);
1520 long    _win32_tell( int fd);
1521 int     _win32_dup( int fd);
1522 int     _win32_dup2(int h1, int h2);
1523 int     _win32_open(const char *path, int oflag,...);
1524 int     _win32_close(int fd);
1525 int     _win32_eof(int fd);
1526 int     _win32_read(int fd, void *buf, unsigned int cnt);
1527 int     _win32_write(int fd, const void *buf, unsigned int cnt);
1528 int     _win32_mkdir(const char *dir, int mode);
1529 int     _win32_rmdir(const char *dir);
1530 int     _win32_chdir(const char *dir);
1531 void    _win32_setbuf(FILE *pf, char *buf);
1532 int     _win32_setvbuf(FILE *pf, char *buf, int type, size_t size);
1533 char*   _win32_fgets(char *s, int n, FILE *pf);
1534 char*   _win32_gets(char *s);
1535 int     _win32_fgetc(FILE *pf);
1536 int     _win32_putc(int c, FILE *pf);
1537 int     _win32_puts(const char *s);
1538 int     _win32_getchar(void);
1539 int     _win32_putchar(int c);
1540 void*   _win32_malloc(size_t size);
1541 void*   _win32_calloc(size_t numitems, size_t size);
1542 void*   _win32_realloc(void *block, size_t size);
1543 void    _win32_free(void *block);
1544 unsigned _win32_sleep(unsigned int);
1545 int     _win32_spawnvp(int mode, const char *cmdname, const char *const *argv);
1546 int     _win32_times(struct tms *timebuf);
1547 int     _win32_stat(const char *path, struct stat *buf);
1548 int     _win32_ioctl(int i, unsigned int u, char *data);
1549 int     _win32_utime(const char *f, struct utimbuf *t);
1550 char*   _win32_getenv(const char *name);
1551 int     _win32_open_osfhandle(long handle, int flags);
1552 long    _win32_get_osfhandle(int fd);
1553
1554 u_long _win32_htonl (u_long hostlong);
1555 u_short _win32_htons (u_short hostshort);
1556 u_long _win32_ntohl (u_long netlong);
1557 u_short _win32_ntohs (u_short netshort);
1558 unsigned long _win32_inet_addr (const char * cp);
1559 char * _win32_inet_ntoa (struct in_addr in);
1560
1561 SOCKET _win32_socket (int af, int type, int protocol);
1562 int _win32_bind (SOCKET s, const struct sockaddr *addr, int namelen);
1563 int _win32_listen (SOCKET s, int backlog);
1564 SOCKET _win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen);
1565 int _win32_connect (SOCKET s, const struct sockaddr *name, int namelen);
1566 int _win32_send (SOCKET s, const char * buf, int len, int flags);
1567 int _win32_sendto (SOCKET s, const char * buf, int len, int flags,
1568                        const struct sockaddr *to, int tolen);
1569 int _win32_recv (SOCKET s, char * buf, int len, int flags);
1570 int _win32_recvfrom (SOCKET s, char * buf, int len, int flags,
1571                          struct sockaddr *from, int * fromlen);
1572 int _win32_shutdown (SOCKET s, int how);
1573 int _win32_closesocket (SOCKET s);
1574 int _win32_ioctlsocket (SOCKET s, long cmd, u_long *argp);
1575 int _win32_setsockopt (SOCKET s, int level, int optname,
1576                            const char * optval, int optlen);
1577 int _win32_getsockopt (SOCKET s, int level, int optname, char * optval, int *optlen);
1578 int _win32_getpeername (SOCKET s, struct sockaddr *name, int * namelen);
1579 int _win32_getsockname (SOCKET s, struct sockaddr *name, int * namelen);
1580 int _win32_gethostname (char * name, int namelen);
1581 struct hostent * _win32_gethostbyname(const char * name);
1582 struct hostent * _win32_gethostbyaddr(const char * addr, int len, int type);
1583 struct protoent * _win32_getprotobyname(const char * name);
1584 struct protoent * _win32_getprotobynumber(int proto);
1585 struct servent * _win32_getservbyname(const char * name, const char * proto);
1586 struct servent * _win32_getservbyport(int port, const char * proto);
1587 int _win32_select (int nfds, Perl_fd_set *rfds, Perl_fd_set *wfds, Perl_fd_set *xfds,
1588                   const struct timeval *timeout);
1589 void _win32_endnetent(void);
1590 void _win32_endhostent(void);
1591 void _win32_endprotoent(void);
1592 void _win32_endservent(void);
1593 struct netent * _win32_getnetent(void);
1594 struct netent * _win32_getnetbyname(char *name);
1595 struct netent * _win32_getnetbyaddr(long net, int type);
1596 struct protoent *_win32_getprotoent(void);
1597 struct servent *_win32_getservent(void);
1598 void _win32_sethostent(int stayopen);
1599 void _win32_setnetent(int stayopen);
1600 void _win32_setprotoent(int stayopen);
1601 void _win32_setservent(int stayopen);
1602
1603 #pragma warning(once : 4113)
1604 EOCODE
1605
1606
1607 close HDRFILE;
1608 close OUTFILE;