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