win32/perlhost.h

   1
   2 #include "iperlsys.h"
   3
   4 extern CPerlObj *pPerl;
   5
   6 #define CALLFUNC0RET(x)\
   7     int ret = x;\
   8     if (ret < 0)\
   9         err = errno;\
  10     return ret;
  11
  12 #define PROCESS_AND_RETURN  \
  13     if (errno)              \
  14         err = errno;        \
  15     return r
  16
  17 #define CALLFUNCRET(x)\
  18     int ret = x;\
  19     if (ret)\
  20         err = errno;\
  21     return ret;
  22
  23 #define CALLFUNCERR(x)\
  24     int ret = x;\
  25     if (errno)\
  26         err = errno;\
  27     return ret;
  28
  29 #define LCALLFUNCERR(x)\
  30     long ret = x;\
  31     if (errno)\
  32         err = errno;\
  33     return ret;
  34
  35 class CPerlDir : public IPerlDir
  36 {
  37 public:
  38     CPerlDir() {};
  39     virtual int Makedir(const char *dirname, int mode, int &err)
  40     {
  41         CALLFUNC0RET(win32_mkdir(dirname, mode));
  42     };
  43     virtual int Chdir(const char *dirname, int &err)
  44     {
  45         CALLFUNC0RET(win32_chdir(dirname));
  46     };
  47     virtual int Rmdir(const char *dirname, int &err)
  48     {
  49         CALLFUNC0RET(win32_rmdir(dirname));
  50     };
  51     virtual int Close(DIR *dirp, int &err)
  52     {
  53         return win32_closedir(dirp);
  54     };
  55     virtual DIR *Open(char *filename, int &err)
  56     {
  57         return win32_opendir(filename);
  58     };
  59     virtual struct direct *Read(DIR *dirp, int &err)
  60     {
  61         return win32_readdir(dirp);
  62     };
  63     virtual void Rewind(DIR *dirp, int &err)
  64     {
  65         win32_rewinddir(dirp);
  66     };
  67     virtual void Seek(DIR *dirp, long loc, int &err)
  68     {
  69         win32_seekdir(dirp, loc);
  70     };
  71     virtual long Tell(DIR *dirp, int &err)
  72     {
  73         return win32_telldir(dirp);
  74     };
  75 };
  76
  77
  78 extern char *           g_win32_get_privlib(char *pl);
  79 extern char *           g_win32_get_sitelib(char *pl);
  80
  81 class CPerlEnv : public IPerlEnv
  82 {
  83 public:
  84     CPerlEnv() {};
  85     virtual char *Getenv(const char *varname, int &err)
  86     {
  87         return win32_getenv(varname);
  88     };
  89     virtual int Putenv(const char *envstring, int &err)
  90     {
  91         return win32_putenv(envstring);
  92     };
  93     virtual char* LibPath(char *pl)
  94     {
  95         return g_win32_get_privlib(pl);
  96     };
  97     virtual char* SiteLibPath(char *pl)
  98     {
  99         return g_win32_get_sitelib(pl);
 100     };
 101     virtual int Uname(struct utsname *name, int &err)
 102     {
 103         return win32_uname(name);
 104     };
 105 };
 106
 107 class CPerlSock : public IPerlSock
 108 {
 109 public:
 110     CPerlSock() {};
 111     virtual u_long Htonl(u_long hostlong)
 112     {
 113         return win32_htonl(hostlong);
 114     };
 115     virtual u_short Htons(u_short hostshort)
 116     {
 117         return win32_htons(hostshort);
 118     };
 119     virtual u_long Ntohl(u_long netlong)
 120     {
 121         return win32_ntohl(netlong);
 122     };
 123     virtual u_short Ntohs(u_short netshort)
 124     {
 125         return win32_ntohs(netshort);
 126     }
 127
 128     virtual SOCKET Accept(SOCKET s, struct sockaddr* addr, int* addrlen, int &err)
 129     {
 130         SOCKET r = win32_accept(s, addr, addrlen);
 131         PROCESS_AND_RETURN;
 132     };
 133     virtual int Bind(SOCKET s, const struct sockaddr* name, int namelen, int &err)
 134     {
 135         int r = win32_bind(s, name, namelen);
 136         PROCESS_AND_RETURN;
 137     };
 138     virtual int Connect(SOCKET s, const struct sockaddr* name, int namelen, int &err)
 139     {
 140         int r = win32_connect(s, name, namelen);
 141         PROCESS_AND_RETURN;
 142     };
 143     virtual void Endhostent(int &err)
 144     {
 145         win32_endhostent();
 146     };
 147     virtual void Endnetent(int &err)
 148     {
 149         win32_endnetent();
 150     };
 151     virtual void Endprotoent(int &err)
 152     {
 153         win32_endprotoent();
 154     };
 155     virtual void Endservent(int &err)
 156     {
 157         win32_endservent();
 158     };
 159     virtual struct hostent* Gethostbyaddr(const char* addr, int len, int type, int &err)
 160     {
 161         struct hostent *r = win32_gethostbyaddr(addr, len, type);
 162         PROCESS_AND_RETURN;
 163     };
 164     virtual struct hostent* Gethostbyname(const char* name, int &err)
 165     {
 166         struct hostent *r = win32_gethostbyname(name);
 167         PROCESS_AND_RETURN;
 168     };
 169     virtual struct hostent* Gethostent(int &err)
 170     {
 171         croak("gethostent not implemented!\n");
 172         return NULL;
 173     };
 174     virtual int Gethostname(char* name, int namelen, int &err)
 175     {
 176         int r = win32_gethostname(name, namelen);
 177         PROCESS_AND_RETURN;
 178     };
 179     virtual struct netent *Getnetbyaddr(long net, int type, int &err)
 180     {
 181         struct netent *r = win32_getnetbyaddr(net, type);
 182         PROCESS_AND_RETURN;
 183     };
 184     virtual struct netent *Getnetbyname(const char *name, int &err)
 185     {
 186         struct netent *r = win32_getnetbyname((char*)name);
 187         PROCESS_AND_RETURN;
 188     };
 189     virtual struct netent *Getnetent(int &err)
 190     {
 191         struct netent *r = win32_getnetent();
 192         PROCESS_AND_RETURN;
 193     };
 194     virtual int Getpeername(SOCKET s, struct sockaddr* name, int* namelen, int &err)
 195     {
 196         int r = win32_getpeername(s, name, namelen);
 197         PROCESS_AND_RETURN;
 198     };
 199     virtual struct protoent* Getprotobyname(const char* name, int &err)
 200     {
 201         struct protoent *r = win32_getprotobyname(name);
 202         PROCESS_AND_RETURN;
 203     };
 204     virtual struct protoent* Getprotobynumber(int number, int &err)
 205     {
 206         struct protoent *r = win32_getprotobynumber(number);
 207         PROCESS_AND_RETURN;
 208     };
 209     virtual struct protoent* Getprotoent(int &err)
 210     {
 211         struct protoent *r = win32_getprotoent();
 212         PROCESS_AND_RETURN;
 213     };
 214     virtual struct servent* Getservbyname(const char* name, const char* proto, int &err)
 215     {
 216         struct servent *r = win32_getservbyname(name, proto);
 217         PROCESS_AND_RETURN;
 218     };
 219     virtual struct servent* Getservbyport(int port, const char* proto, int &err)
 220     {
 221         struct servent *r = win32_getservbyport(port, proto);
 222         PROCESS_AND_RETURN;
 223     };
 224     virtual struct servent* Getservent(int &err)
 225     {
 226         struct servent *r = win32_getservent();
 227         PROCESS_AND_RETURN;
 228     };
 229     virtual int Getsockname(SOCKET s, struct sockaddr* name, int* namelen, int &err)
 230     {
 231         int r = win32_getsockname(s, name, namelen);
 232         PROCESS_AND_RETURN;
 233     };
 234     virtual int Getsockopt(SOCKET s, int level, int optname, char* optval, int* optlen, int &err)
 235     {
 236         int r = win32_getsockopt(s, level, optname, optval, optlen);
 237         PROCESS_AND_RETURN;
 238     };
 239     virtual unsigned long InetAddr(const char* cp, int &err)
 240     {
 241         unsigned long r = win32_inet_addr(cp);
 242         PROCESS_AND_RETURN;
 243     };
 244     virtual char* InetNtoa(struct in_addr in, int &err)
 245     {
 246         char *r = win32_inet_ntoa(in);
 247         PROCESS_AND_RETURN;
 248     };
 249     virtual int Listen(SOCKET s, int backlog, int &err)
 250     {
 251         int r = win32_listen(s, backlog);
 252         PROCESS_AND_RETURN;
 253     };
 254     virtual int Recv(SOCKET s, char* buffer, int len, int flags, int &err)
 255     {
 256         int r = win32_recv(s, buffer, len, flags);
 257         PROCESS_AND_RETURN;
 258     };
 259     virtual int Recvfrom(SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen, int &err)
 260     {
 261         int r = win32_recvfrom(s, buffer, len, flags, from, fromlen);
 262         PROCESS_AND_RETURN;
 263     };
 264     virtual int Select(int nfds, char* readfds, char* writefds, char* exceptfds, const struct timeval* timeout, int &err)
 265     {
 266         int r = win32_select(nfds, (Perl_fd_set*)readfds, (Perl_fd_set*)writefds, (Perl_fd_set*)exceptfds, timeout);
 267         PROCESS_AND_RETURN;
 268     };
 269     virtual int Send(SOCKET s, const char* buffer, int len, int flags, int &err)
 270     {
 271         int r = win32_send(s, buffer, len, flags);
 272         PROCESS_AND_RETURN;
 273     };
 274     virtual int Sendto(SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen, int &err)
 275     {
 276         int r = win32_sendto(s, buffer, len, flags, to, tolen);
 277         PROCESS_AND_RETURN;
 278     };
 279     virtual void Sethostent(int stayopen, int &err)
 280     {
 281         win32_sethostent(stayopen);
 282     };
 283     virtual void Setnetent(int stayopen, int &err)
 284     {
 285         win32_setnetent(stayopen);
 286     };
 287     virtual void Setprotoent(int stayopen, int &err)
 288     {
 289         win32_setprotoent(stayopen);
 290     };
 291     virtual void Setservent(int stayopen, int &err)
 292     {
 293         win32_setservent(stayopen);
 294     };
 295     virtual int Setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen, int &err)
 296     {
 297         int r = win32_setsockopt(s, level, optname, optval, optlen);
 298         PROCESS_AND_RETURN;
 299     };
 300     virtual int Shutdown(SOCKET s, int how, int &err)
 301     {
 302         int r = win32_shutdown(s, how);
 303         PROCESS_AND_RETURN;
 304     };
 305     virtual SOCKET Socket(int af, int type, int protocol, int &err)
 306     {
 307         SOCKET r = win32_socket(af, type, protocol);
 308         PROCESS_AND_RETURN;
 309     };
 310     virtual int Socketpair(int domain, int type, int protocol, int* fds, int &err)
 311     {
 312         croak("socketpair not implemented!\n");
 313         return 0;
 314     };
 315     virtual int Closesocket(SOCKET s, int& err)
 316     {
 317         int r = win32_closesocket(s);
 318         PROCESS_AND_RETURN;
 319     };
 320     virtual int Ioctlsocket(SOCKET s, long cmd, u_long *argp, int& err)
 321     {
 322         int r = win32_ioctlsocket(s, cmd, argp);
 323         PROCESS_AND_RETURN;
 324     };
 325 };
 326
 327 class CPerlLIO : public IPerlLIO
 328 {
 329 public:
 330     CPerlLIO() {};
 331     virtual int Access(const char *path, int mode, int &err)
 332     {
 333         CALLFUNCRET(access(path, mode))
 334     };
 335     virtual int Chmod(const char *filename, int pmode, int &err)
 336     {
 337         CALLFUNCRET(chmod(filename, pmode))
 338     };
 339     virtual int Chown(const char *filename, uid_t owner, gid_t group, int &err)
 340     {
 341         CALLFUNCERR(chown(filename, owner, group))
 342     };
 343     virtual int Chsize(int handle, long size, int &err)
 344     {
 345         CALLFUNCRET(chsize(handle, size))
 346     };
 347     virtual int Close(int handle, int &err)
 348     {
 349         CALLFUNCRET(win32_close(handle))
 350     };
 351     virtual int Dup(int handle, int &err)
 352     {
 353         CALLFUNCERR(win32_dup(handle))
 354     };
 355     virtual int Dup2(int handle1, int handle2, int &err)
 356     {
 357         CALLFUNCERR(win32_dup2(handle1, handle2))
 358     };
 359     virtual int Flock(int fd, int oper, int &err)
 360     {
 361         CALLFUNCERR(win32_flock(fd, oper))
 362     };
 363     virtual int FileStat(int handle, struct stat *buffer, int &err)
 364     {
 365         CALLFUNCERR(fstat(handle, buffer))
 366     };
 367     virtual int IOCtl(int i, unsigned int u, char *data, int &err)
 368     {
 369         CALLFUNCERR(win32_ioctlsocket((SOCKET)i, (long)u, (u_long*)data))
 370     };
 371     virtual int Isatty(int fd, int &err)
 372     {
 373         return isatty(fd);
 374     };
 375     virtual long Lseek(int handle, long offset, int origin, int &err)
 376     {
 377         LCALLFUNCERR(win32_lseek(handle, offset, origin))
 378     };
 379     virtual int Lstat(const char *path, struct stat *buffer, int &err)
 380     {
 381         return NameStat(path, buffer, err);
 382     };
 383     virtual char *Mktemp(char *Template, int &err)
 384     {
 385         return mktemp(Template);
 386     };
 387     virtual int Open(const char *filename, int oflag, int &err)
 388     {
 389         CALLFUNCERR(win32_open(filename, oflag))
 390     };
 391     virtual int Open(const char *filename, int oflag, int pmode, int &err)
 392     {
 393         int ret;
 394         if(stricmp(filename, "/dev/null") == 0)
 395             ret = open("NUL", oflag, pmode);
 396         else
 397             ret = open(filename, oflag, pmode);
 398
 399         if(errno)
 400             err = errno;
 401         return ret;
 402     };
 403     virtual int Read(int handle, void *buffer, unsigned int count, int &err)
 404     {
 405         CALLFUNCERR(win32_read(handle, buffer, count))
 406     };
 407     virtual int Rename(const char *OldFileName, const char *newname, int &err)
 408     {
 409         CALLFUNCRET(win32_rename(OldFileName, newname))
 410     };
 411     virtual int Setmode(int handle, int mode, int &err)
 412     {
 413         CALLFUNCRET(win32_setmode(handle, mode))
 414     };
 415     virtual int NameStat(const char *path, struct stat *buffer, int &err)
 416     {
 417         return win32_stat(path, buffer);
 418     };
 419     virtual char *Tmpnam(char *string, int &err)
 420     {
 421         return tmpnam(string);
 422     };
 423     virtual int Umask(int pmode, int &err)
 424     {
 425         return umask(pmode);
 426     };
 427     virtual int Unlink(const char *filename, int &err)
 428     {
 429         chmod(filename, S_IREAD | S_IWRITE);
 430         CALLFUNCRET(unlink(filename))
 431     };
 432     virtual int Utime(char *filename, struct utimbuf *times, int &err)
 433     {
 434         CALLFUNCRET(win32_utime(filename, times))
 435     };
 436     virtual int Write(int handle, const void *buffer, unsigned int count, int &err)
 437     {
 438         CALLFUNCERR(win32_write(handle, buffer, count))
 439     };
 440 };
 441
 442 class CPerlMem : public IPerlMem
 443 {
 444 public:
 445     CPerlMem() {};
 446     virtual void* Malloc(size_t size)
 447     {
 448         return win32_malloc(size);
 449     };
 450     virtual void* Realloc(void* ptr, size_t size)
 451     {
 452         return win32_realloc(ptr, size);
 453     };
 454     virtual void Free(void* ptr)
 455     {
 456         win32_free(ptr);
 457     };
 458 };
 459
 460 #define EXECF_EXEC 1
 461 #define EXECF_SPAWN 2
 462
 463 extern char *           g_getlogin(void);
 464 extern int              do_spawn2(char *cmd, int exectype);
 465 extern int              g_do_aspawn(void *vreally, void **vmark, void **vsp);
 466
 467 class CPerlProc : public IPerlProc
 468 {
 469 public:
 470     CPerlProc() {};
 471     virtual void Abort(void)
 472     {
 473         win32_abort();
 474     };
 475     virtual char * Crypt(const char* clear, const char* salt)
 476     {
 477         return win32_crypt(clear, salt);
 478     };
 479     virtual void Exit(int status)
 480     {
 481         exit(status);
 482     };
 483     virtual void _Exit(int status)
 484     {
 485         _exit(status);
 486     };
 487     virtual int Execl(const char *cmdname, const char *arg0, const char *arg1, const char *arg2, const char *arg3)
 488     {
 489         return execl(cmdname, arg0, arg1, arg2, arg3);
 490     };
 491     virtual int Execv(const char *cmdname, const char *const *argv)
 492     {
 493         return win32_execvp(cmdname, argv);
 494     };
 495     virtual int Execvp(const char *cmdname, const char *const *argv)
 496     {
 497         return win32_execvp(cmdname, argv);
 498     };
 499     virtual uid_t Getuid(void)
 500     {
 501         return getuid();
 502     };
 503     virtual uid_t Geteuid(void)
 504     {
 505         return geteuid();
 506     };
 507     virtual gid_t Getgid(void)
 508     {
 509         return getgid();
 510     };
 511     virtual gid_t Getegid(void)
 512     {
 513         return getegid();
 514     };
 515     virtual char *Getlogin(void)
 516     {
 517         return g_getlogin();
 518     };
 519     virtual int Kill(int pid, int sig)
 520     {
 521         return win32_kill(pid, sig);
 522     };
 523     virtual int Killpg(int pid, int sig)
 524     {
 525         croak("killpg not implemented!\n");
 526         return 0;
 527     };
 528     virtual int PauseProc(void)
 529     {
 530         return win32_sleep((32767L << 16) + 32767);
 531     };
 532     virtual PerlIO* Popen(const char *command, const char *mode)
 533     {
 534         win32_fflush(stdout);
 535         win32_fflush(stderr);
 536         return (PerlIO*)win32_popen(command, mode);
 537     };
 538     virtual int Pclose(PerlIO *stream)
 539     {
 540         return win32_pclose((FILE*)stream);
 541     };
 542     virtual int Pipe(int *phandles)
 543     {
 544         return win32_pipe(phandles, 512, O_BINARY);
 545     };
 546     virtual int Setuid(uid_t u)
 547     {
 548         return setuid(u);
 549     };
 550     virtual int Setgid(gid_t g)
 551     {
 552         return setgid(g);
 553     };
 554     virtual int Sleep(unsigned int s)
 555     {
 556         return win32_sleep(s);
 557     };
 558     virtual int Times(struct tms *timebuf)
 559     {
 560         return win32_times(timebuf);
 561     };
 562     virtual int Wait(int *status)
 563     {
 564         return win32_wait(status);
 565     };
 566     virtual int Waitpid(int pid, int *status, int flags)
 567     {
 568         return win32_waitpid(pid, status, flags);
 569     };
 570     virtual Sighandler_t Signal(int sig, Sighandler_t subcode)
 571     {
 572         return 0;
 573     };
 574     virtual void GetSysMsg(char*& sMsg, DWORD& dwLen, DWORD dwErr)
 575     {
 576         dwLen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
 577                           |FORMAT_MESSAGE_IGNORE_INSERTS
 578                           |FORMAT_MESSAGE_FROM_SYSTEM, NULL,
 579                            dwErr, 0, (char *)&sMsg, 1, NULL);
 580         if (0 < dwLen) {
 581             while (0 < dwLen  &&  isspace(sMsg[--dwLen]))
 582                 ;
 583             if ('.' != sMsg[dwLen])
 584                 dwLen++;
 585             sMsg[dwLen]= '\0';
 586         }
 587         if (0 == dwLen) {
 588             sMsg = (char*)LocalAlloc(0, 64/**sizeof(TCHAR)*/);
 589             dwLen = sprintf(sMsg,
 590                         "Unknown error #0x%lX (lookup 0x%lX)",
 591                         dwErr, GetLastError());
 592         }
 593     };
 594     virtual void FreeBuf(char* sMsg)
 595     {
 596         LocalFree(sMsg);
 597     };
 598     virtual BOOL DoCmd(char *cmd)
 599     {
 600         do_spawn2(cmd, EXECF_EXEC);
 601         return FALSE;
 602     };
 603     virtual int Spawn(char* cmds)
 604     {
 605         return do_spawn2(cmds, EXECF_SPAWN);
 606     };
 607     virtual int Spawnvp(int mode, const char *cmdname, const char *const *argv)
 608     {
 609         return win32_spawnvp(mode, cmdname, argv);
 610     };
 611     virtual int ASpawn(void *vreally, void **vmark, void **vsp)
 612     {
 613         return g_do_aspawn(vreally, vmark, vsp);
 614     };
 615 };
 616
 617
 618 class CPerlStdIO : public IPerlStdIO
 619 {
 620 public:
 621     CPerlStdIO() {};
 622     virtual PerlIO* Stdin(void)
 623     {
 624         return (PerlIO*)win32_stdin();
 625     };
 626     virtual PerlIO* Stdout(void)
 627     {
 628         return (PerlIO*)win32_stdout();
 629     };
 630     virtual PerlIO* Stderr(void)
 631     {
 632         return (PerlIO*)win32_stderr();
 633     };
 634     virtual PerlIO* Open(const char *path, const char *mode, int &err)
 635     {
 636         PerlIO*pf = (PerlIO*)win32_fopen(path, mode);
 637         if(errno)
 638             err = errno;
 639         return pf;
 640     };
 641     virtual int Close(PerlIO* pf, int &err)
 642     {
 643         CALLFUNCERR(win32_fclose(((FILE*)pf)))
 644     };
 645     virtual int Eof(PerlIO* pf, int &err)
 646     {
 647         CALLFUNCERR(win32_feof((FILE*)pf))
 648     };
 649     virtual int Error(PerlIO* pf, int &err)
 650     {
 651         CALLFUNCERR(win32_ferror((FILE*)pf))
 652     };
 653     virtual void Clearerr(PerlIO* pf, int &err)
 654     {
 655         win32_clearerr((FILE*)pf);
 656     };
 657     virtual int Getc(PerlIO* pf, int &err)
 658     {
 659         CALLFUNCERR(win32_getc((FILE*)pf))
 660     };
 661     virtual char* GetBase(PerlIO* pf, int &err)
 662     {
 663 #ifdef FILE_base
 664         FILE *f = (FILE*)pf;
 665         return FILE_base(f);
 666 #else
 667         return Nullch;
 668 #endif
 669     };
 670     virtual int GetBufsiz(PerlIO* pf, int &err)
 671     {
 672 #ifdef FILE_bufsiz
 673         FILE *f = (FILE*)pf;
 674         return FILE_bufsiz(f);
 675 #else
 676         return (-1);
 677 #endif
 678     };
 679     virtual int GetCnt(PerlIO* pf, int &err)
 680     {
 681 #ifdef USE_STDIO_PTR
 682         FILE *f = (FILE*)pf;
 683         return FILE_cnt(f);
 684 #else
 685         return (-1);
 686 #endif
 687     };
 688     virtual char* GetPtr(PerlIO* pf, int &err)
 689     {
 690 #ifdef USE_STDIO_PTR
 691         FILE *f = (FILE*)pf;
 692         return FILE_ptr(f);
 693 #else
 694         return Nullch;
 695 #endif
 696     };
 697     virtual char* Gets(PerlIO* pf, char* s, int n, int& err)
 698     {
 699         char* ret = win32_fgets(s, n, (FILE*)pf);
 700         if(errno)
 701             err = errno;
 702         return ret;
 703     };
 704     virtual int Putc(PerlIO* pf, int c, int &err)
 705     {
 706         CALLFUNCERR(win32_fputc(c, (FILE*)pf))
 707     };
 708     virtual int Puts(PerlIO* pf, const char *s, int &err)
 709     {
 710         CALLFUNCERR(win32_fputs(s, (FILE*)pf))
 711     };
 712     virtual int Flush(PerlIO* pf, int &err)
 713     {
 714         CALLFUNCERR(win32_fflush((FILE*)pf))
 715     };
 716     virtual int Ungetc(PerlIO* pf,int c, int &err)
 717     {
 718         CALLFUNCERR(win32_ungetc(c, (FILE*)pf))
 719     };
 720     virtual int Fileno(PerlIO* pf, int &err)
 721     {
 722         CALLFUNCERR(win32_fileno((FILE*)pf))
 723     };
 724     virtual PerlIO* Fdopen(int fd, const char *mode, int &err)
 725     {
 726         PerlIO* pf = (PerlIO*)win32_fdopen(fd, mode);
 727         if(errno)
 728             err = errno;
 729         return pf;
 730     };
 731     virtual PerlIO* Reopen(const char*path, const char*mode, PerlIO* pf, int &err)
 732     {
 733         PerlIO* newPf = (PerlIO*)win32_freopen(path, mode, (FILE*)pf);
 734         if(errno)
 735             err = errno;
 736         return newPf;
 737     };
 738     virtual SSize_t Read(PerlIO* pf, void *buffer, Size_t size, int &err)
 739     {
 740         SSize_t i = win32_fread(buffer, 1, size, (FILE*)pf);
 741         if(errno)
 742             err = errno;
 743         return i;
 744     };
 745     virtual SSize_t Write(PerlIO* pf, const void *buffer, Size_t size, int &err)
 746     {
 747         SSize_t i = win32_fwrite(buffer, 1, size, (FILE*)pf);
 748         if(errno)
 749             err = errno;
 750         return i;
 751     };
 752     virtual void SetBuf(PerlIO* pf, char* buffer, int &err)
 753     {
 754         win32_setbuf((FILE*)pf, buffer);
 755     };
 756     virtual int SetVBuf(PerlIO* pf, char* buffer, int type, Size_t size, int &err)
 757     {
 758         int i = win32_setvbuf((FILE*)pf, buffer, type, size);
 759         if(errno)
 760             err = errno;
 761         return i;
 762     };
 763     virtual void SetCnt(PerlIO* pf, int n, int &err)
 764     {
 765 #ifdef STDIO_CNT_LVALUE
 766         FILE *f = (FILE*)pf;
 767         FILE_cnt(f) = n;
 768 #endif
 769     };
 770     virtual void SetPtrCnt(PerlIO* pf, char * ptr, int n, int& err)
 771     {
 772 #ifdef STDIO_PTR_LVALUE
 773         FILE *f = (FILE*)pf;
 774         FILE_ptr(f) = ptr;
 775         FILE_cnt(f) = n;
 776 #endif
 777     };
 778     virtual void Setlinebuf(PerlIO* pf, int &err)
 779     {
 780         win32_setvbuf((FILE*)pf, NULL, _IOLBF, 0);
 781     };
 782     virtual int Printf(PerlIO* pf, int &err, const char *format,...)
 783     {
 784         va_list(arglist);
 785         va_start(arglist, format);
 786         int i = win32_vfprintf((FILE*)pf, format, arglist);
 787         if(errno)
 788             err = errno;
 789         return i;
 790     };
 791     virtual int Vprintf(PerlIO* pf, int &err, const char *format, va_list arglist)
 792     {
 793         int i = win32_vfprintf((FILE*)pf, format, arglist);
 794         if(errno)
 795             err = errno;
 796         return i;
 797     };
 798     virtual long Tell(PerlIO* pf, int &err)
 799     {
 800         long l = win32_ftell((FILE*)pf);
 801         if(errno)
 802             err = errno;
 803         return l;
 804     };
 805     virtual int Seek(PerlIO* pf, off_t offset, int origin, int &err)
 806     {
 807         int i = win32_fseek((FILE*)pf, offset, origin);
 808         if(errno)
 809             err = errno;
 810         return i;
 811     };
 812     virtual void Rewind(PerlIO* pf, int &err)
 813     {
 814         win32_rewind((FILE*)pf);
 815     };
 816     virtual PerlIO* Tmpfile(int &err)
 817     {
 818         PerlIO* pf = (PerlIO*)win32_tmpfile();
 819         if(errno)
 820             err = errno;
 821         return pf;
 822     };
 823     virtual int Getpos(PerlIO* pf, Fpos_t *p, int &err)
 824     {
 825         int i = win32_fgetpos((FILE*)pf, p);
 826         if(errno)
 827             err = errno;
 828         return i;
 829     };
 830     virtual int Setpos(PerlIO* pf, const Fpos_t *p, int &err)
 831     {
 832         int i = win32_fsetpos((FILE*)pf, p);
 833         if(errno)
 834             err = errno;
 835         return i;
 836     };
 837     virtual void Init(int &err)
 838     {
 839     };
 840     virtual void InitOSExtras(void* p)
 841     {
 842         Perl_init_os_extras();
 843     };
 844     virtual int OpenOSfhandle(long osfhandle, int flags)
 845     {
 846         return win32_open_osfhandle(osfhandle, flags);
 847     }
 848     virtual int GetOSfhandle(int filenum)
 849     {
 850         return win32_get_osfhandle(filenum);
 851     }
 852 };
 853
 854 class CPerlHost
 855 {
 856 public:
 857     CPerlHost() { pPerl = NULL; };
 858     inline BOOL PerlCreate(void)
 859     {
 860         try
 861         {
 862             pPerl = perl_alloc(&perlMem, &perlEnv, &perlStdIO, &perlLIO,
 863                                &perlDir, &perlSock, &perlProc);
 864             if(pPerl != NULL)
 865             {
 866                 try
 867                 {
 868                     perl_construct();
 869                 }
 870                 catch(...)
 871                 {
 872                     win32_fprintf(stderr, "%s\n",
 873                                   "Error: Unable to construct data structures");
 874                     perl_free();
 875                     pPerl = NULL;
 876                 }
 877             }
 878         }
 879         catch(...)
 880         {
 881             win32_fprintf(stderr, "%s\n", "Error: Unable to allocate memory");
 882             pPerl = NULL;
 883         }
 884         return (pPerl != NULL);
 885     };
 886     inline int PerlParse(void (*xs_init)(CPerlObj*), int argc, char** argv, char** env)
 887     {
 888         int retVal;
 889         try
 890         {
 891             retVal = perl_parse(xs_init, argc, argv, env);
 892         }
 893         catch(int x)
 894         {
 895             // this is where exit() should arrive
 896             retVal = x;
 897         }
 898         catch(...)
 899         {
 900             win32_fprintf(stderr, "Error: Parse exception\n");
 901             retVal = -1;
 902         }
 903         *win32_errno() = 0;
 904         return retVal;
 905     };
 906     inline int PerlRun(void)
 907     {
 908         int retVal;
 909         try
 910         {
 911             retVal = perl_run();
 912         }
 913         catch(int x)
 914         {
 915             // this is where exit() should arrive
 916             retVal = x;
 917         }
 918         catch(...)
 919         {
 920             win32_fprintf(stderr, "Error: Runtime exception\n");
 921             retVal = -1;
 922         }
 923         return retVal;
 924     };
 925     inline void PerlDestroy(void)
 926     {
 927         try
 928         {
 929             perl_destruct();
 930             perl_free();
 931         }
 932         catch(...)
 933         {
 934         }
 935     };
 936
 937 protected:
 938     CPerlDir    perlDir;
 939     CPerlEnv    perlEnv;
 940     CPerlLIO    perlLIO;
 941     CPerlMem    perlMem;
 942     CPerlProc   perlProc;
 943     CPerlSock   perlSock;
 944     CPerlStdIO  perlStdIO;
 945 };