home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 2000 May / PCP163A.iso / full / activeperl / APi522e.exe / data.z / perlhost.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-11-01  |  22.6 KB  |  949 lines
  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.     CALLFUNCRET(win32_unlink(filename))
  430.     };
  431.     virtual int Utime(char *filename, struct utimbuf *times, int &err)
  432.     {
  433.     CALLFUNCRET(win32_utime(filename, times))
  434.     };
  435.     virtual int Write(int handle, const void *buffer, unsigned int count, int &err)
  436.     {
  437.     CALLFUNCERR(win32_write(handle, buffer, count))
  438.     };
  439. };
  440.  
  441. class CPerlMem : public IPerlMem
  442. {
  443. public:
  444.     CPerlMem() {};
  445.     virtual void* Malloc(size_t size)
  446.     {
  447.     return win32_malloc(size);
  448.     };
  449.     virtual void* Realloc(void* ptr, size_t size)
  450.     {
  451.     return win32_realloc(ptr, size);
  452.     };
  453.     virtual void Free(void* ptr)
  454.     {
  455.     win32_free(ptr);
  456.     };
  457. };
  458.  
  459. #define EXECF_EXEC 1
  460. #define EXECF_SPAWN 2
  461.  
  462. extern char *        g_getlogin(void);
  463. extern int        do_spawn2(char *cmd, int exectype);
  464. extern int        g_do_aspawn(void *vreally, void **vmark, void **vsp);
  465.  
  466. class CPerlProc : public IPerlProc
  467. {
  468. public:
  469.     CPerlProc() {};
  470.     virtual void Abort(void)
  471.     {
  472.     win32_abort();
  473.     };
  474.     virtual char * Crypt(const char* clear, const char* salt)
  475.     {
  476.     return win32_crypt(clear, salt);
  477.     };
  478.     virtual void Exit(int status)
  479.     {
  480.     exit(status);
  481.     };
  482.     virtual void _Exit(int status)
  483.     {
  484.     _exit(status);
  485.     };
  486.     virtual int Execl(const char *cmdname, const char *arg0, const char *arg1, const char *arg2, const char *arg3)
  487.     {
  488.     return execl(cmdname, arg0, arg1, arg2, arg3);
  489.     };
  490.     virtual int Execv(const char *cmdname, const char *const *argv)
  491.     {
  492.     return win32_execvp(cmdname, argv);
  493.     };
  494.     virtual int Execvp(const char *cmdname, const char *const *argv)
  495.     {
  496.     return win32_execvp(cmdname, argv);
  497.     };
  498.     virtual uid_t Getuid(void)
  499.     {
  500.     return getuid();
  501.     };
  502.     virtual uid_t Geteuid(void)
  503.     {
  504.     return geteuid();
  505.     };
  506.     virtual gid_t Getgid(void)
  507.     {
  508.     return getgid();
  509.     };
  510.     virtual gid_t Getegid(void)
  511.     {
  512.     return getegid();
  513.     };
  514.     virtual char *Getlogin(void)
  515.     {
  516.     return g_getlogin();
  517.     };
  518.     virtual int Kill(int pid, int sig)
  519.     {
  520.     return win32_kill(pid, sig);
  521.     };
  522.     virtual int Killpg(int pid, int sig)
  523.     {
  524.     croak("killpg not implemented!\n");
  525.     return 0;
  526.     };
  527.     virtual int PauseProc(void)
  528.     {
  529.     return win32_sleep((32767L << 16) + 32767);
  530.     };
  531.     virtual PerlIO* Popen(const char *command, const char *mode)
  532.     {
  533.     win32_fflush(stdout);
  534.     win32_fflush(stderr);
  535.     return (PerlIO*)win32_popen(command, mode);
  536.     };
  537.     virtual int Pclose(PerlIO *stream)
  538.     {
  539.     return win32_pclose((FILE*)stream);
  540.     };
  541.     virtual int Pipe(int *phandles)
  542.     {
  543.     return win32_pipe(phandles, 512, O_BINARY);
  544.     };
  545.     virtual int Setuid(uid_t u)
  546.     {
  547.     return setuid(u);
  548.     };
  549.     virtual int Setgid(gid_t g)
  550.     {
  551.     return setgid(g);
  552.     };
  553.     virtual int Sleep(unsigned int s)
  554.     {
  555.     return win32_sleep(s);
  556.     };
  557.     virtual int Times(struct tms *timebuf)
  558.     {
  559.     return win32_times(timebuf);
  560.     };
  561.     virtual int Wait(int *status)
  562.     {
  563.     return win32_wait(status);
  564.     };
  565.     virtual int Waitpid(int pid, int *status, int flags)
  566.     {
  567.     return win32_waitpid(pid, status, flags);
  568.     };
  569.     virtual Sighandler_t Signal(int sig, Sighandler_t subcode)
  570.     {
  571.     return 0;
  572.     };
  573.     virtual void GetSysMsg(char*& sMsg, DWORD& dwLen, DWORD dwErr)
  574.     {
  575.     dwLen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
  576.               |FORMAT_MESSAGE_IGNORE_INSERTS
  577.               |FORMAT_MESSAGE_FROM_SYSTEM, NULL,
  578.                dwErr, 0, (char *)&sMsg, 1, NULL);
  579.     /* strip trailing whitespace and period */
  580.     if (0 < dwLen) {
  581.         do {
  582.         --dwLen;    /* dwLen doesn't include trailing null */
  583.         } while (0 < dwLen && isSPACE(sMsg[dwLen]));
  584.         if ('.' != sMsg[dwLen])
  585.         dwLen++;
  586.         sMsg[dwLen] = '\0';
  587.     }
  588.     if (0 == dwLen) {
  589.         sMsg = (char*)LocalAlloc(0, 64/**sizeof(TCHAR)*/);
  590.         dwLen = sprintf(sMsg,
  591.             "Unknown error #0x%lX (lookup 0x%lX)",
  592.             dwErr, GetLastError());
  593.     }
  594.     };
  595.     virtual void FreeBuf(char* sMsg)
  596.     {
  597.     LocalFree(sMsg);
  598.     };
  599.     virtual BOOL DoCmd(char *cmd)
  600.     {
  601.     do_spawn2(cmd, EXECF_EXEC);
  602.         return FALSE;
  603.     };
  604.     virtual int Spawn(char* cmds)
  605.     {
  606.     return do_spawn2(cmds, EXECF_SPAWN);
  607.     };
  608.     virtual int Spawnvp(int mode, const char *cmdname, const char *const *argv)
  609.     {
  610.     return win32_spawnvp(mode, cmdname, argv);
  611.     };
  612.     virtual int ASpawn(void *vreally, void **vmark, void **vsp)
  613.     {
  614.     return g_do_aspawn(vreally, vmark, vsp);
  615.     };
  616. };
  617.  
  618.  
  619. class CPerlStdIO : public IPerlStdIO
  620. {
  621. public:
  622.     CPerlStdIO() {};
  623.     virtual PerlIO* Stdin(void)
  624.     {
  625.     return (PerlIO*)win32_stdin();
  626.     };
  627.     virtual PerlIO* Stdout(void)
  628.     {
  629.     return (PerlIO*)win32_stdout();
  630.     };
  631.     virtual PerlIO* Stderr(void)
  632.     {
  633.     return (PerlIO*)win32_stderr();
  634.     };
  635.     virtual PerlIO* Open(const char *path, const char *mode, int &err)
  636.     {
  637.     PerlIO*pf = (PerlIO*)win32_fopen(path, mode);
  638.     if(errno)
  639.         err = errno;
  640.     return pf;
  641.     };
  642.     virtual int Close(PerlIO* pf, int &err)
  643.     {
  644.     CALLFUNCERR(win32_fclose(((FILE*)pf)))
  645.     };
  646.     virtual int Eof(PerlIO* pf, int &err)
  647.     {
  648.     CALLFUNCERR(win32_feof((FILE*)pf))
  649.     };
  650.     virtual int Error(PerlIO* pf, int &err)
  651.     {
  652.     CALLFUNCERR(win32_ferror((FILE*)pf))
  653.     };
  654.     virtual void Clearerr(PerlIO* pf, int &err)
  655.     {
  656.     win32_clearerr((FILE*)pf);
  657.     };
  658.     virtual int Getc(PerlIO* pf, int &err)
  659.     {
  660.     CALLFUNCERR(win32_getc((FILE*)pf))
  661.     };
  662.     virtual char* GetBase(PerlIO* pf, int &err)
  663.     {
  664. #ifdef FILE_base
  665.     FILE *f = (FILE*)pf;
  666.     return FILE_base(f);
  667. #else
  668.     return Nullch;
  669. #endif
  670.     };
  671.     virtual int GetBufsiz(PerlIO* pf, int &err)
  672.     {
  673. #ifdef FILE_bufsiz
  674.     FILE *f = (FILE*)pf;
  675.     return FILE_bufsiz(f);
  676. #else
  677.     return (-1);
  678. #endif
  679.     };
  680.     virtual int GetCnt(PerlIO* pf, int &err)
  681.     {
  682. #ifdef USE_STDIO_PTR
  683.     FILE *f = (FILE*)pf;
  684.     return FILE_cnt(f);
  685. #else
  686.     return (-1);
  687. #endif
  688.     };
  689.     virtual char* GetPtr(PerlIO* pf, int &err)
  690.     {
  691. #ifdef USE_STDIO_PTR
  692.     FILE *f = (FILE*)pf;
  693.     return FILE_ptr(f);
  694. #else
  695.     return Nullch;
  696. #endif
  697.     };
  698.     virtual char* Gets(PerlIO* pf, char* s, int n, int& err)
  699.     {
  700.     char* ret = win32_fgets(s, n, (FILE*)pf);
  701.     if(errno)
  702.         err = errno;
  703.     return ret;
  704.     };
  705.     virtual int Putc(PerlIO* pf, int c, int &err)
  706.     {
  707.     CALLFUNCERR(win32_fputc(c, (FILE*)pf))
  708.     };
  709.     virtual int Puts(PerlIO* pf, const char *s, int &err)
  710.     {
  711.     CALLFUNCERR(win32_fputs(s, (FILE*)pf))
  712.     };
  713.     virtual int Flush(PerlIO* pf, int &err)
  714.     {
  715.     CALLFUNCERR(win32_fflush((FILE*)pf))
  716.     };
  717.     virtual int Ungetc(PerlIO* pf,int c, int &err)
  718.     {
  719.     CALLFUNCERR(win32_ungetc(c, (FILE*)pf))
  720.     };
  721.     virtual int Fileno(PerlIO* pf, int &err)
  722.     {
  723.     CALLFUNCERR(win32_fileno((FILE*)pf))
  724.     };
  725.     virtual PerlIO* Fdopen(int fd, const char *mode, int &err)
  726.     {
  727.     PerlIO* pf = (PerlIO*)win32_fdopen(fd, mode);
  728.     if(errno)
  729.         err = errno;
  730.     return pf;
  731.     };
  732.     virtual PerlIO* Reopen(const char*path, const char*mode, PerlIO* pf, int &err)
  733.     {
  734.     PerlIO* newPf = (PerlIO*)win32_freopen(path, mode, (FILE*)pf);
  735.     if(errno)
  736.         err = errno;
  737.     return newPf;
  738.     };
  739.     virtual SSize_t Read(PerlIO* pf, void *buffer, Size_t size, int &err)
  740.     {
  741.     SSize_t i = win32_fread(buffer, 1, size, (FILE*)pf);
  742.     if(errno)
  743.         err = errno;
  744.     return i;
  745.     };
  746.     virtual SSize_t Write(PerlIO* pf, const void *buffer, Size_t size, int &err)
  747.     {
  748.     SSize_t i = win32_fwrite(buffer, 1, size, (FILE*)pf);
  749.     if(errno)
  750.         err = errno;
  751.     return i;
  752.     };
  753.     virtual void SetBuf(PerlIO* pf, char* buffer, int &err)
  754.     {
  755.     win32_setbuf((FILE*)pf, buffer);
  756.     };
  757.     virtual int SetVBuf(PerlIO* pf, char* buffer, int type, Size_t size, int &err)
  758.     {
  759.     int i = win32_setvbuf((FILE*)pf, buffer, type, size);
  760.     if(errno)
  761.         err = errno;
  762.     return i;
  763.     };
  764.     virtual void SetCnt(PerlIO* pf, int n, int &err)
  765.     {
  766. #ifdef STDIO_CNT_LVALUE
  767.     FILE *f = (FILE*)pf;
  768.     FILE_cnt(f) = n;
  769. #endif
  770.     };
  771.     virtual void SetPtrCnt(PerlIO* pf, char * ptr, int n, int& err)
  772.     {
  773. #ifdef STDIO_PTR_LVALUE
  774.     FILE *f = (FILE*)pf;
  775.     FILE_ptr(f) = ptr;
  776.     FILE_cnt(f) = n;
  777. #endif
  778.     };
  779.     virtual void Setlinebuf(PerlIO* pf, int &err)
  780.     {
  781.     win32_setvbuf((FILE*)pf, NULL, _IOLBF, 0);
  782.     };
  783.     virtual int Printf(PerlIO* pf, int &err, const char *format,...)
  784.     {
  785.     va_list(arglist);
  786.     va_start(arglist, format);
  787.     int i = win32_vfprintf((FILE*)pf, format, arglist);
  788.     if(errno)
  789.         err = errno;
  790.     return i;
  791.     };
  792.     virtual int Vprintf(PerlIO* pf, int &err, const char *format, va_list arglist)
  793.     {
  794.     int i = win32_vfprintf((FILE*)pf, format, arglist);
  795.     if(errno)
  796.         err = errno;
  797.     return i;
  798.     };
  799.     virtual long Tell(PerlIO* pf, int &err)
  800.     {
  801.     long l = win32_ftell((FILE*)pf);
  802.     if(errno)
  803.         err = errno;
  804.     return l;
  805.     };
  806.     virtual int Seek(PerlIO* pf, off_t offset, int origin, int &err)
  807.     {
  808.     int i = win32_fseek((FILE*)pf, offset, origin);
  809.     if(errno)
  810.         err = errno;
  811.     return i;
  812.     };
  813.     virtual void Rewind(PerlIO* pf, int &err)
  814.     {
  815.     win32_rewind((FILE*)pf);
  816.     };
  817.     virtual PerlIO* Tmpfile(int &err)
  818.     {
  819.     PerlIO* pf = (PerlIO*)win32_tmpfile();
  820.     if(errno)
  821.         err = errno;
  822.     return pf;
  823.     };
  824.     virtual int Getpos(PerlIO* pf, Fpos_t *p, int &err)
  825.     {
  826.     int i = win32_fgetpos((FILE*)pf, p);
  827.     if(errno)
  828.         err = errno;
  829.     return i;
  830.     };
  831.     virtual int Setpos(PerlIO* pf, const Fpos_t *p, int &err)
  832.     {
  833.     int i = win32_fsetpos((FILE*)pf, p);
  834.     if(errno)
  835.         err = errno;
  836.     return i;
  837.     };
  838.     virtual void Init(int &err)
  839.     {
  840.     };
  841.     virtual void InitOSExtras(void* p)
  842.     {
  843.     Perl_init_os_extras();
  844.     };
  845.     virtual int OpenOSfhandle(long osfhandle, int flags)
  846.     {
  847.     return win32_open_osfhandle(osfhandle, flags);
  848.     }
  849.     virtual int GetOSfhandle(int filenum)
  850.     {
  851.     return win32_get_osfhandle(filenum);
  852.     }
  853. };
  854.  
  855. class CPerlHost
  856. {
  857. public:
  858.     CPerlHost() { pPerl = NULL; };
  859.     inline BOOL PerlCreate(void)
  860.     {
  861.     try
  862.     {
  863.         pPerl = perl_alloc(&perlMem, &perlEnv, &perlStdIO, &perlLIO,
  864.                    &perlDir, &perlSock, &perlProc);
  865.         if(pPerl != NULL)
  866.         {
  867.         perl_init_i18nl10n(1);
  868.  
  869.         try
  870.         {
  871.             pPerl->perl_construct();
  872.         }
  873.         catch(...)
  874.         {
  875.             win32_fprintf(stderr, "%s\n",
  876.                   "Error: Unable to construct data structures");
  877.             pPerl->perl_free();
  878.             pPerl = NULL;
  879.         }
  880.         }
  881.     }
  882.     catch(...)
  883.     {
  884.         win32_fprintf(stderr, "%s\n", "Error: Unable to allocate memory");
  885.         pPerl = NULL;
  886.     }
  887.     return (pPerl != NULL);
  888.     };
  889.     inline int PerlParse(void (*xs_init)(CPerlObj*), int argc, char** argv, char** env)
  890.     {
  891.     int retVal;
  892.     try
  893.     {
  894.         retVal = pPerl->perl_parse(xs_init, argc, argv, env);
  895.     }
  896.     catch(int x)
  897.     {
  898.         // this is where exit() should arrive
  899.         retVal = x;
  900.     }
  901.     catch(...)
  902.     {
  903.         win32_fprintf(stderr, "Error: Parse exception\n");
  904.         retVal = -1;
  905.     }
  906.     *win32_errno() = 0;
  907.     return retVal;
  908.     };
  909.     inline int PerlRun(void)
  910.     {
  911.     int retVal;
  912.     try
  913.     {
  914.         retVal = pPerl->perl_run();
  915.     }
  916.     catch(int x)
  917.     {
  918.         // this is where exit() should arrive
  919.         retVal = x;
  920.     }
  921.     catch(...)
  922.     {
  923.         win32_fprintf(stderr, "Error: Runtime exception\n");
  924.         retVal = -1;
  925.     }
  926.     return retVal;
  927.     };
  928.     inline void PerlDestroy(void)
  929.     {
  930.     try
  931.     {
  932.         pPerl->perl_destruct();
  933.         pPerl->perl_free();
  934.     }
  935.     catch(...)
  936.     {
  937.     }
  938.     };
  939.  
  940. protected:
  941.     CPerlDir    perlDir;
  942.     CPerlEnv    perlEnv;
  943.     CPerlLIO    perlLIO;
  944.     CPerlMem    perlMem;
  945.     CPerlProc    perlProc;
  946.     CPerlSock    perlSock;
  947.     CPerlStdIO    perlStdIO;
  948. };
  949.