win32/GenCAPI.pl

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