/*
* Copyright �2001 Novell, Inc. All Rights Reserved.
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
* FILENAME : nwperlhost.h
* DESCRIPTION : This is modelled on the perlhost.h module of Win32 port.
* This is the host that include all the functions for running Perl within a class.
* Author : SGP, HYAK
* Date : January 2001.
*
*/
#ifndef ___NWPerlHost_H___
#define ___NWPerlHost_H___
#include "iperlsys.h"
#include "nwvmem.h"
#include "nw5sck.h"
#include "netware.h"
#define LPBYTE unsigned char *
#if !defined(PERL_OBJECT)
START_EXTERN_C
#endif /* PERL_OBJECT */
extern int do_spawn2(char *cmd, int exectype);
extern int do_aspawn(void *vreally, void **vmark, void **vsp);
extern void Perl_init_os_extras(void);
#if !defined(PERL_OBJECT)
END_EXTERN_C
#endif /* PERL_OBJECT */
#ifdef PERL_OBJECT
extern int g_do_aspawn(void *vreally, void **vmark, void **vsp);
#define do_aspawn g_do_aspawn
#endif /* PERL_OBJECT */
class CPerlHost
{
public:
CPerlHost(void);
CPerlHost(struct IPerlMem** ppMem, struct IPerlMem** ppMemShared,
struct IPerlMem** ppMemParse, struct IPerlEnv** ppEnv,
struct IPerlStdIO** ppStdIO, struct IPerlLIO** ppLIO,
struct IPerlDir** ppDir, struct IPerlSock** ppSock,
struct IPerlProc** ppProc);
CPerlHost(const CPerlHost& host);
virtual ~CPerlHost(void);
static CPerlHost* IPerlMem2Host(struct IPerlMem* piPerl);
static CPerlHost* IPerlMemShared2Host(struct IPerlMem* piPerl);
static CPerlHost* IPerlMemParse2Host(struct IPerlMem* piPerl);
static CPerlHost* IPerlEnv2Host(struct IPerlEnv* piPerl);
static CPerlHost* IPerlStdIO2Host(struct IPerlStdIO* piPerl);
static CPerlHost* IPerlLIO2Host(struct IPerlLIO* piPerl);
static CPerlHost* IPerlDir2Host(struct IPerlDir* piPerl);
static CPerlHost* IPerlSock2Host(struct IPerlSock* piPerl);
static CPerlHost* IPerlProc2Host(struct IPerlProc* piPerl);
/* IPerlMem */
inline void* Malloc(size_t size) { return m_pVMem->Malloc(size); };
inline void* Realloc(void* ptr, size_t size) { return m_pVMem->Realloc(ptr, size); };
inline void Free(void* ptr) { m_pVMem->Free(ptr); };
inline void* Calloc(size_t num, size_t size){ return m_pVMem->Calloc(num, size); };
/* IPerlMemShared */
inline void* MallocShared(size_t size)
{
return m_pVMemShared->Malloc(size);
};
inline void* ReallocShared(void* ptr, size_t size) { return m_pVMemShared->Realloc(ptr, size); };
inline void FreeShared(void* ptr) { m_pVMemShared->Free(ptr); };
inline void* CallocShared(size_t num, size_t size)
{
size_t count = num*size;
void* lpVoid = MallocShared(count);
return lpVoid;
};
/* IPerlMemParse */
inline void* MallocParse(size_t size) { return m_pVMemParse->Malloc(size); };
inline void* ReallocParse(void* ptr, size_t size) { return m_pVMemParse->Realloc(ptr, size); };
inline void FreeParse(void* ptr) { m_pVMemParse->Free(ptr); };
inline void* CallocParse(size_t num, size_t size)
{
size_t count = num*size;
void* lpVoid = MallocParse(count);
return lpVoid;
};
/* IPerlEnv */
char *Getenv(const char *varname);
int Putenv(const char *envstring);
inline char *Getenv(const char *varname, unsigned long *len)
{
*len = 0;
char *e = Getenv(varname);
if (e)
*len = strlen(e);
return e;
}
public:
/* IPerlDIR */
/* IPerllProc */
void Abort(void);
void Exit(int status);
void _Exit(int status);
int Execl(const char *cmdname, const char *arg0, const char *arg1, const char *arg2, const char *arg3);
int Execv(const char *cmdname, const char *const *argv);
int Execvp(const char *cmdname, const char *const *argv);
public:
struct IPerlMem m_hostperlMem;
struct IPerlMem m_hostperlMemShared;
struct IPerlMem m_hostperlMemParse;
struct IPerlEnv m_hostperlEnv;
struct IPerlStdIO m_hostperlStdIO;
struct IPerlLIO m_hostperlLIO;
struct IPerlDir m_hostperlDir;
struct IPerlSock m_hostperlSock;
struct IPerlProc m_hostperlProc;
struct IPerlMem* m_pHostperlMem;
struct IPerlMem* m_pHostperlMemShared;
struct IPerlMem* m_pHostperlMemParse;
struct IPerlEnv* m_pHostperlEnv;
struct IPerlStdIO* m_pHostperlStdIO;
struct IPerlLIO* m_pHostperlLIO;
struct IPerlDir* m_pHostperlDir;
struct IPerlSock* m_pHostperlSock;
struct IPerlProc* m_pHostperlProc;
protected:
VMem* m_pVMem;
VMem* m_pVMemShared;
VMem* m_pVMemParse;
};
#define STRUCT2PTR(x, y) (CPerlHost*)(((LPBYTE)x)-offsetof(CPerlHost, y))
inline CPerlHost* IPerlMem2Host(struct IPerlMem* piPerl)
{
return STRUCT2PTR(piPerl, m_hostperlMem);
}
inline CPerlHost* IPerlMemShared2Host(struct IPerlMem* piPerl)
{
return STRUCT2PTR(piPerl, m_hostperlMemShared);
}
inline CPerlHost* IPerlMemParse2Host(struct IPerlMem* piPerl)
{
return STRUCT2PTR(piPerl, m_hostperlMemParse);
}
inline CPerlHost* IPerlEnv2Host(struct IPerlEnv* piPerl)
{
return STRUCT2PTR(piPerl, m_hostperlEnv);
}
inline CPerlHost* IPerlStdIO2Host(struct IPerlStdIO* piPerl)
{
return STRUCT2PTR(piPerl, m_hostperlStdIO);
}
inline CPerlHost* IPerlLIO2Host(struct IPerlLIO* piPerl)
{
return STRUCT2PTR(piPerl, m_hostperlLIO);
}
inline CPerlHost* IPerlDir2Host(struct IPerlDir* piPerl)
{
return STRUCT2PTR(piPerl, m_hostperlDir);
}
inline CPerlHost* IPerlSock2Host(struct IPerlSock* piPerl)
{
return STRUCT2PTR(piPerl, m_hostperlSock);
}
inline CPerlHost* IPerlProc2Host(struct IPerlProc* piPerl)
{
return STRUCT2PTR(piPerl, m_hostperlProc);
}
#undef IPERL2HOST
#define IPERL2HOST(x) IPerlMem2Host(x)
/* IPerlMem */
void*
PerlMemMalloc(struct IPerlMem* piPerl, size_t size)
{
return IPERL2HOST(piPerl)->Malloc(size);
}
void*
PerlMemRealloc(struct IPerlMem* piPerl, void* ptr, size_t size)
{
return IPERL2HOST(piPerl)->Realloc(ptr, size);
}
void
PerlMemFree(struct IPerlMem* piPerl, void* ptr)
{
IPERL2HOST(piPerl)->Free(ptr);
}
void*
PerlMemCalloc(struct IPerlMem* piPerl, size_t num, size_t size)
{
return IPERL2HOST(piPerl)->Calloc(num, size);
}
struct IPerlMem perlMem =
{
PerlMemMalloc,
PerlMemRealloc,
PerlMemFree,
PerlMemCalloc,
};
#undef IPERL2HOST
#define IPERL2HOST(x) IPerlMemShared2Host(x)
/* IPerlMemShared */
void*
PerlMemSharedMalloc(struct IPerlMem* piPerl, size_t size)
{
return IPERL2HOST(piPerl)->MallocShared(size);
}
void*
PerlMemSharedRealloc(struct IPerlMem* piPerl, void* ptr, size_t size)
{
return IPERL2HOST(piPerl)->ReallocShared(ptr, size);
}
void
PerlMemSharedFree(struct IPerlMem* piPerl, void* ptr)
{
IPERL2HOST(piPerl)->FreeShared(ptr);
}
void*
PerlMemSharedCalloc(struct IPerlMem* piPerl, size_t num, size_t size)
{
return IPERL2HOST(piPerl)->CallocShared(num, size);
}
struct IPerlMem perlMemShared =
{
PerlMemSharedMalloc,
PerlMemSharedRealloc,
PerlMemSharedFree,
PerlMemSharedCalloc,
};
#undef IPERL2HOST
#define IPERL2HOST(x) IPerlMemParse2Host(x)
/* IPerlMemParse */
void*
PerlMemParseMalloc(struct IPerlMem* piPerl, size_t size)
{
return IPERL2HOST(piPerl)->MallocParse(size);
}
void*
PerlMemParseRealloc(struct IPerlMem* piPerl, void* ptr, size_t size)
{
return IPERL2HOST(piPerl)->ReallocParse(ptr, size);
}
void
PerlMemParseFree(struct IPerlMem* piPerl, void* ptr)
{
IPERL2HOST(piPerl)->FreeParse(ptr);
}
void*
PerlMemParseCalloc(struct IPerlMem* piPerl, size_t num, size_t size)
{
return IPERL2HOST(piPerl)->CallocParse(num, size);
}
struct IPerlMem perlMemParse =
{
PerlMemParseMalloc,
PerlMemParseRealloc,
PerlMemParseFree,
PerlMemParseCalloc,
};
#undef IPERL2HOST
#define IPERL2HOST(x) IPerlEnv2Host(x)
/* IPerlEnv */
char*
PerlEnvGetenv(struct IPerlEnv* piPerl, const char *varname)
{
return IPERL2HOST(piPerl)->Getenv(varname);
};
int
PerlEnvPutenv(struct IPerlEnv* piPerl, const char *envstring)
{
return IPERL2HOST(piPerl)->Putenv(envstring);
};
char*
PerlEnvGetenv_len(struct IPerlEnv* piPerl, const char* varname, unsigned long* len)
{
return IPERL2HOST(piPerl)->Getenv(varname, len);
}
int
PerlEnvUname(struct IPerlEnv* piPerl, struct utsname *name)
{
return nw_uname(name);
}
void
PerlEnvClearenv(struct IPerlEnv* piPerl)
{
// If removed, compilation fails while compiling CGI2Perl.
}
void*
PerlEnvGetChildenv(struct IPerlEnv* piPerl)
{
// If removed, compilation fails while compiling CGI2Perl.
return NULL;
}
void
PerlEnvFreeChildenv(struct IPerlEnv* piPerl, void* childEnv)
{
// If removed, compilation fails while compiling CGI2Perl.
}
char*
PerlEnvGetChilddir(struct IPerlEnv* piPerl)
{
// If removed, compilation fails while compiling CGI2Perl.
return NULL;
}
void
PerlEnvFreeChilddir(struct IPerlEnv* piPerl, char* childDir)
{
// If removed, compilation fails while compiling CGI2Perl.
}
struct IPerlEnv perlEnv =
{
PerlEnvGetenv,
PerlEnvPutenv,
PerlEnvGetenv_len,
PerlEnvUname,
PerlEnvClearenv,
PerlEnvGetChildenv,
PerlEnvFreeChildenv,
PerlEnvGetChilddir,
PerlEnvFreeChilddir,
};
#undef IPERL2HOST
#define IPERL2HOST(x) IPerlStdIO2Host(x)
/* PerlStdIO */
PerlIO*
PerlStdIOStdin(struct IPerlStdIO* piPerl)
{
return (PerlIO*)nw_stdin();
}
PerlIO*
PerlStdIOStdout(struct IPerlStdIO* piPerl)
{
return (PerlIO*)nw_stdout();
}
PerlIO*
PerlStdIOStderr(struct IPerlStdIO* piPerl)
{
return (PerlIO*)nw_stderr();
}
PerlIO*
PerlStdIOOpen(struct IPerlStdIO* piPerl, const char *path, const char *mode)
{
return (PerlIO*)nw_fopen(path, mode);
}
int
PerlStdIOClose(struct IPerlStdIO* piPerl, PerlIO* pf)
{
return nw_fclose(((FILE*)pf));
}
int
PerlStdIOEof(struct IPerlStdIO* piPerl, PerlIO* pf)
{
return nw_feof((FILE*)pf);
}
int
PerlStdIOError(struct IPerlStdIO* piPerl, PerlIO* pf)
{
return nw_ferror((FILE*)pf);
}
void
PerlStdIOClearerr(struct IPerlStdIO* piPerl, PerlIO* pf)
{
nw_clearerr((FILE*)pf);
}
int
PerlStdIOGetc(struct IPerlStdIO* piPerl, PerlIO* pf)
{
return nw_getc((FILE*)pf);
}
char*
PerlStdIOGetBase(struct IPerlStdIO* piPerl, PerlIO* pf)
{
#ifdef FILE_base
FILE *f = (FILE*)pf;
return FILE_base(f);
#else
return Nullch;
#endif
}
int
PerlStdIOGetBufsiz(struct IPerlStdIO* piPerl, PerlIO* pf)
{
#ifdef FILE_bufsiz
FILE *f = (FILE*)pf;
return FILE_bufsiz(f);
#else
return (-1);
#endif
}
int
PerlStdIOGetCnt(struct IPerlStdIO* piPerl, PerlIO* pf)
{
#ifdef USE_STDIO_PTR
FILE *f = (FILE*)pf;
return FILE_cnt(f);
#else
return (-1);
#endif
}
char*
PerlStdIOGetPtr(struct IPerlStdIO* piPerl, PerlIO* pf)
{
#ifdef USE_STDIO_PTR
FILE *f = (FILE*)pf;
return FILE_ptr(f);
#else
return Nullch;
#endif
}
char*
PerlStdIOGets(struct IPerlStdIO* piPerl, PerlIO* pf, char* s, int n)
{
return nw_fgets(s, n, (FILE*)pf);
}
int
PerlStdIOPutc(struct IPerlStdIO* piPerl, PerlIO* pf, int c)
{
return nw_fputc(c, (FILE*)pf);
}
int
PerlStdIOPuts(struct IPerlStdIO* piPerl, PerlIO* pf, const char *s)
{
return nw_fputs(s, (FILE*)pf);
}
int
PerlStdIOFlush(struct IPerlStdIO* piPerl, PerlIO* pf)
{
return nw_fflush((FILE*)pf);
}
int
PerlStdIOUngetc(struct IPerlStdIO* piPerl, int c, PerlIO* pf) //(J)
{
return nw_ungetc(c, (FILE*)pf);
}
int
PerlStdIOFileno(struct IPerlStdIO* piPerl, PerlIO* pf)
{
return nw_fileno((FILE*)pf);
}
PerlIO*
PerlStdIOFdopen(struct IPerlStdIO* piPerl, int fd, const char *mode)
{
return (PerlIO*)nw_fdopen(fd, mode);
}
PerlIO*
PerlStdIOReopen(struct IPerlStdIO* piPerl, const char*path, const char*mode, PerlIO* pf)
{
return (PerlIO*)nw_freopen(path, mode, (FILE*)pf);
}
SSize_t
PerlStdIORead(struct IPerlStdIO* piPerl, void *buffer, Size_t size, Size_t dummy, PerlIO* pf)
{
return nw_fread(buffer, 1, size, (FILE*)pf);
}
SSize_t
PerlStdIOWrite(struct IPerlStdIO* piPerl, const void *buffer, Size_t size, Size_t dummy, PerlIO* pf)
//PerlStdIOWrite(struct IPerlStdIO* piPerl, PerlIO* pf, const void *buffer, Size_t size)
{
return nw_fwrite(buffer, 1, size, (FILE*)pf);
}
void
PerlStdIOSetBuf(struct IPerlStdIO* piPerl, PerlIO* pf, char* buffer)
{
nw_setbuf((FILE*)pf, buffer);
}
int
PerlStdIOSetVBuf(struct IPerlStdIO* piPerl, PerlIO* pf, char* buffer, int type, Size_t size)
{
return nw_setvbuf((FILE*)pf, buffer, type, size);
}
void
PerlStdIOSetCnt(struct IPerlStdIO* piPerl, PerlIO* pf, int n)
{
#ifdef STDIO_CNT_LVALUE
FILE *f = (FILE*)pf;
FILE_cnt(f) = n;
#endif
}
void
PerlStdIOSetPtrCnt(struct IPerlStdIO* piPerl, PerlIO* pf, char * ptr, int n)
{
#ifdef STDIO_PTR_LVALUE
FILE *f = (FILE*)pf;
FILE_ptr(f) = ptr;
FILE_cnt(f) = n;
#endif
}
void
PerlStdIOSetlinebuf(struct IPerlStdIO* piPerl, PerlIO* pf)
{
nw_setvbuf((FILE*)pf, NULL, _IOLBF, 0);
}
int
PerlStdIOPrintf(struct IPerlStdIO* piPerl, PerlIO* pf, const char *format,...)
{
va_list(arglist);
va_start(arglist, format);
return nw_vfprintf((FILE*)pf, format, arglist);
}
int
PerlStdIOVprintf(struct IPerlStdIO* piPerl, PerlIO* pf, const char *format, va_list arglist)
{
return nw_vfprintf((FILE*)pf, format, arglist);
}
long
PerlStdIOTell(struct IPerlStdIO* piPerl, PerlIO* pf)
{
return nw_ftell((FILE*)pf);
}
int
PerlStdIOSeek(struct IPerlStdIO* piPerl, PerlIO* pf, off_t offset, int origin)
{
return nw_fseek((FILE*)pf, offset, origin);
}
void
PerlStdIORewind(struct IPerlStdIO* piPerl, PerlIO* pf)
{
nw_rewind((FILE*)pf);
}
PerlIO*
PerlStdIOTmpfile(struct IPerlStdIO* piPerl)
{
return (PerlIO*)nw_tmpfile();
}
int
PerlStdIOGetpos(struct IPerlStdIO* piPerl, PerlIO* pf, Fpos_t *p)
{
return nw_fgetpos((FILE*)pf, p);
}
int
PerlStdIOSetpos(struct IPerlStdIO* piPerl, PerlIO* pf, const Fpos_t *p)
{
return nw_fsetpos((FILE*)pf, p);
}
void
PerlStdIOInit(struct IPerlStdIO* piPerl)
{
// If removed, compilation error occurs.
}
void
PerlStdIOInitOSExtras(struct IPerlStdIO* piPerl)
{
Perl_init_os_extras();
}
int
PerlStdIOOpenOSfhandle(struct IPerlStdIO* piPerl, long osfhandle, int flags)
{
return nw_open_osfhandle(osfhandle, flags);
}
int
PerlStdIOGetOSfhandle(struct IPerlStdIO* piPerl, int filenum)
{
return nw_get_osfhandle(filenum);
}
PerlIO*
PerlStdIOFdupopen(struct IPerlStdIO* piPerl, PerlIO* pf)
{
PerlIO* pfdup=NULL;
fpos_t pos=0;
char mode[3]={'\0'};
int fileno = nw_dup(nw_fileno((FILE*)pf));
/* open the file in the same mode */
if(((FILE*)pf)->_flag & _IOREAD) {
mode[0] = 'r';
mode[1] = 0;
}
else if(((FILE*)pf)->_flag & _IOWRT) {
mode[0] = 'a';
mode[1] = 0;
}
else if(((FILE*)pf)->_flag & _IORW) {
mode[0] = 'r';
mode[1] = '+';
mode[2] = 0;
}
/* it appears that the binmode is attached to the
* file descriptor so binmode files will be handled
* correctly
*/
pfdup = (PerlIO*)nw_fdopen(fileno, mode);
/* move the file pointer to the same position */
if (!fgetpos((FILE*)pf, &pos)) {
fsetpos((FILE*)pfdup, &pos);
}
return pfdup;
}
struct IPerlStdIO perlStdIO =
{
PerlStdIOStdin,
PerlStdIOStdout,
PerlStdIOStderr,
PerlStdIOOpen,
PerlStdIOClose,
PerlStdIOEof,
PerlStdIOError,
PerlStdIOClearerr,
PerlStdIOGetc,
PerlStdIOGetBase,
PerlStdIOGetBufsiz,
PerlStdIOGetCnt,
PerlStdIOGetPtr,
PerlStdIOGets,
PerlStdIOPutc,
PerlStdIOPuts,
PerlStdIOFlush,
PerlStdIOUngetc,
PerlStdIOFileno,
PerlStdIOFdopen,
PerlStdIOReopen,
PerlStdIORead,
PerlStdIOWrite,
PerlStdIOSetBuf,
PerlStdIOSetVBuf,
PerlStdIOSetCnt,
PerlStdIOSetPtrCnt,
PerlStdIOSetlinebuf,
PerlStdIOPrintf,
PerlStdIOVprintf,
PerlStdIOTell,
PerlStdIOSeek,
PerlStdIORewind,
PerlStdIOTmpfile,
PerlStdIOGetpos,
PerlStdIOSetpos,
PerlStdIOInit,
PerlStdIOInitOSExtras,
PerlStdIOFdupopen,
};
#undef IPERL2HOST
#define IPERL2HOST(x) IPerlLIO2Host(x)
/* IPerlLIO */
int
PerlLIOAccess(struct IPerlLIO* piPerl, const char *path, int mode)
{
return nw_access(path, mode);
}
int
PerlLIOChmod(struct IPerlLIO* piPerl, const char *filename, int pmode)
{
return nw_chmod(filename, pmode);
}
int
PerlLIOChown(struct IPerlLIO* piPerl, const char *filename, uid_t owner, gid_t group)
{
// If removed, compilation error occurs.
return 0;
}
int
PerlLIOChsize(struct IPerlLIO* piPerl, int handle, long size)
{
return (nw_chsize(handle,size));
}
int
PerlLIOClose(struct IPerlLIO* piPerl, int handle)
{
return nw_close(handle);
}
int
PerlLIODup(struct IPerlLIO* piPerl, int handle)
{
return nw_dup(handle);
}
int
PerlLIODup2(struct IPerlLIO* piPerl, int handle1, int handle2)
{
return nw_dup2(handle1, handle2);
}
int
PerlLIOFlock(struct IPerlLIO* piPerl, int fd, int oper)
{
//On NetWare simulate flock by locking a range on the file
return nw_flock(fd, oper);
}
int
PerlLIOFileStat(struct IPerlLIO* piPerl, int handle, struct stat *buffer)
{
return fstat(handle, buffer);
}
int
PerlLIOIOCtl(struct IPerlLIO* piPerl, int i, unsigned int u, char *data)
{
// If removed, compilation error occurs.
return 0;
}
int
PerlLIOIsatty(struct IPerlLIO* piPerl, int fd)
{
return nw_isatty(fd);
}
int
PerlLIOLink(struct IPerlLIO* piPerl, const char*oldname, const char *newname)
{
return nw_link(oldname, newname);
}
long
PerlLIOLseek(struct IPerlLIO* piPerl, int handle, long offset, int origin)
{
return nw_lseek(handle, offset, origin);
}
int
PerlLIOLstat(struct IPerlLIO* piPerl, const char *path, struct stat *buffer)
{
return nw_stat(path, buffer);
}
char*
PerlLIOMktemp(struct IPerlLIO* piPerl, char *Template)
{
return(nw_mktemp(Template));
}
int
PerlLIOOpen(struct IPerlLIO* piPerl, const char *filename, int oflag)
{
return nw_open(filename, oflag);
}
int
PerlLIOOpen3(struct IPerlLIO* piPerl, const char *filename, int oflag, int pmode)
{
return nw_open(filename, oflag, pmode);
}
int
PerlLIORead(struct IPerlLIO* piPerl, int handle, void *buffer, unsigned int count)
{
return nw_read(handle, buffer, count);
}
int
PerlLIORename(struct IPerlLIO* piPerl, const char *OldFileName, const char *newname)
{
return nw_rename(OldFileName, newname);
}
int
PerlLIOSetmode(struct IPerlLIO* piPerl, FILE *fp, int mode)
{
return nw_setmode(fp, mode);
}
int
PerlLIONameStat(struct IPerlLIO* piPerl, const char *path, struct stat *buffer)
{
return nw_stat(path, buffer);
}
char*
PerlLIOTmpnam(struct IPerlLIO* piPerl, char *string)
{
return tmpnam(string);
}
int
PerlLIOUmask(struct IPerlLIO* piPerl, int pmode)
{
return umask(pmode);
}
int
PerlLIOUnlink(struct IPerlLIO* piPerl, const char *filename)
{
return nw_unlink(filename);
}
int
PerlLIOUtime(struct IPerlLIO* piPerl, char *filename, struct utimbuf *times)
{
return nw_utime(filename, times);
}
int
PerlLIOWrite(struct IPerlLIO* piPerl, int handle, const void *buffer, unsigned int count)
{
return nw_write(handle, buffer, count);
}
struct IPerlLIO perlLIO =
{
PerlLIOAccess,
PerlLIOChmod,
PerlLIOChown,
PerlLIOChsize,
PerlLIOClose,
PerlLIODup,
PerlLIODup2,
PerlLIOFlock,
PerlLIOFileStat,
PerlLIOIOCtl,
PerlLIOIsatty,
PerlLIOLink,
PerlLIOLseek,
PerlLIOLstat,
PerlLIOMktemp,
PerlLIOOpen,
PerlLIOOpen3,
PerlLIORead,
PerlLIORename,
PerlLIOSetmode,
PerlLIONameStat,
PerlLIOTmpnam,
PerlLIOUmask,
PerlLIOUnlink,
PerlLIOUtime,
PerlLIOWrite,
};
#undef IPERL2HOST
#define IPERL2HOST(x) IPerlDir2Host(x)
/* IPerlDIR */
int
PerlDirMakedir(struct IPerlDir* piPerl, const char *dirname, int mode)
{
return mkdir(dirname);
}
int
PerlDirChdir(struct IPerlDir* piPerl, const char *dirname)
{
return nw_chdir(dirname);
}
int
PerlDirRmdir(struct IPerlDir* piPerl, const char *dirname)
{
return nw_rmdir(dirname);
}
int
PerlDirClose(struct IPerlDir* piPerl, DIR *dirp)
{
return nw_closedir(dirp);
}
DIR*
PerlDirOpen(struct IPerlDir* piPerl, char *filename)
{
return nw_opendir(filename);
}
struct direct *
PerlDirRead(struct IPerlDir* piPerl, DIR *dirp)
{
return nw_readdir(dirp);
}
void
PerlDirRewind(struct IPerlDir* piPerl, DIR *dirp)
{
nw_rewinddir(dirp);
}
void
PerlDirSeek(struct IPerlDir* piPerl, DIR *dirp, long loc)
{
nw_seekdir(dirp, loc);
}
long
PerlDirTell(struct IPerlDir* piPerl, DIR *dirp)
{
return nw_telldir(dirp);
}
struct IPerlDir perlDir =
{
PerlDirMakedir,
PerlDirChdir,
PerlDirRmdir,
PerlDirClose,
PerlDirOpen,
PerlDirRead,
PerlDirRewind,
PerlDirSeek,
PerlDirTell,
};
/* IPerlSock */
u_long
PerlSockHtonl(struct IPerlSock* piPerl, u_long hostlong)
{
return(nw_htonl(hostlong));
}
u_short
PerlSockHtons(struct IPerlSock* piPerl, u_short hostshort)
{
return(nw_htons(hostshort));
}
u_long
PerlSockNtohl(struct IPerlSock* piPerl, u_long netlong)
{
return nw_ntohl(netlong);
}
u_short
PerlSockNtohs(struct IPerlSock* piPerl, u_short netshort)
{
return nw_ntohs(netshort);
}
SOCKET PerlSockAccept(struct IPerlSock* piPerl, SOCKET s, struct sockaddr* addr, int* addrlen)
{
return nw_accept(s, addr, addrlen);
}
int
PerlSockBind(struct IPerlSock* piPerl, SOCKET s, const struct sockaddr* name, int namelen)
{
return nw_bind(s, name, namelen);
}
int
PerlSockConnect(struct IPerlSock* piPerl, SOCKET s, const struct sockaddr* name, int namelen)
{
return nw_connect(s, name, namelen);
}
void
PerlSockEndhostent(struct IPerlSock* piPerl)
{
nw_endhostent();
}
void
PerlSockEndnetent(struct IPerlSock* piPerl)
{
nw_endnetent();
}
void
PerlSockEndprotoent(struct IPerlSock* piPerl)
{
nw_endprotoent();
}
void
PerlSockEndservent(struct IPerlSock* piPerl)
{
nw_endservent();
}
struct hostent*
PerlSockGethostbyaddr(struct IPerlSock* piPerl, const char* addr, int len, int type)
{
return(nw_gethostbyaddr(addr,len,type));
}
struct hostent*
PerlSockGethostbyname(struct IPerlSock* piPerl, const char* name)
{
return nw_gethostbyname(name);
}
struct hostent*
PerlSockGethostent(struct IPerlSock* piPerl)
{
return(nw_gethostent());
}
int
PerlSockGethostname(struct IPerlSock* piPerl, char* name, int namelen)
{
return nw_gethostname(name,namelen);
}
struct netent *
PerlSockGetnetbyaddr(struct IPerlSock* piPerl, long net, int type)
{
return nw_getnetbyaddr(net, type);
}
struct netent *
PerlSockGetnetbyname(struct IPerlSock* piPerl, const char *name)
{
return nw_getnetbyname((char*)name);
}
struct netent *
PerlSockGetnetent(struct IPerlSock* piPerl)
{
return nw_getnetent();
}
int PerlSockGetpeername(struct IPerlSock* piPerl, SOCKET s, struct sockaddr* name, int* namelen)
{
return nw_getpeername(s, name, namelen);
}
struct protoent*
PerlSockGetprotobyname(struct IPerlSock* piPerl, const char* name)
{
return nw_getprotobyname(name);
}
struct protoent*
PerlSockGetprotobynumber(struct IPerlSock* piPerl, int number)
{
return nw_getprotobynumber(number);
}
struct protoent*
PerlSockGetprotoent(struct IPerlSock* piPerl)
{
return nw_getprotoent();
}
struct servent*
PerlSockGetservbyname(struct IPerlSock* piPerl, const char* name, const char* proto)
{
return nw_getservbyname((char*)name, (char*)proto);
}
struct servent*
PerlSockGetservbyport(struct IPerlSock* piPerl, int port, const char* proto)
{
return nw_getservbyport(port, proto);
}
struct servent*
PerlSockGetservent(struct IPerlSock* piPerl)
{
return nw_getservent();
}
int
PerlSockGetsockname(struct IPerlSock* piPerl, SOCKET s, struct sockaddr* name, int* namelen)
{
return nw_getsockname(s, name, namelen);
}
int
PerlSockGetsockopt(struct IPerlSock* piPerl, SOCKET s, int level, int optname, char* optval, int* optlen)
{
return nw_getsockopt(s, level, optname, optval, optlen);
}
unsigned long
PerlSockInetAddr(struct IPerlSock* piPerl, const char* cp)
{
return(nw_inet_addr(cp));
}
char*
PerlSockInetNtoa(struct IPerlSock* piPerl, struct in_addr in)
{
return nw_inet_ntoa(in);
}
int
PerlSockListen(struct IPerlSock* piPerl, SOCKET s, int backlog)
{
return (nw_listen(s, backlog));
}
int
PerlSockRecv(struct IPerlSock* piPerl, SOCKET s, char* buffer, int len, int flags)
{
return (nw_recv(s, buffer, len, flags));
}
int
PerlSockRecvfrom(struct IPerlSock* piPerl, SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen)
{
return nw_recvfrom(s, buffer, len, flags, from, fromlen);
}
int
PerlSockSelect(struct IPerlSock* piPerl, int nfds, char* readfds, char* writefds, char* exceptfds, const struct timeval* timeout)
{
return nw_select(nfds, (fd_set*) readfds, (fd_set*) writefds, (fd_set*) exceptfds, timeout);
}
int
PerlSockSend(struct IPerlSock* piPerl, SOCKET s, const char* buffer, int len, int flags)
{
return (nw_send(s, buffer, len, flags));
}
int
PerlSockSendto(struct IPerlSock* piPerl, SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen)
{
return(nw_sendto(s, buffer, len, flags, to, tolen));
}
void
PerlSockSethostent(struct IPerlSock* piPerl, int stayopen)
{
nw_sethostent(stayopen);
}
void
PerlSockSetnetent(struct IPerlSock* piPerl, int stayopen)
{
nw_setnetent(stayopen);
}
void
PerlSockSetprotoent(struct IPerlSock* piPerl, int stayopen)
{
nw_setprotoent(stayopen);
}
void
PerlSockSetservent(struct IPerlSock* piPerl, int stayopen)
{
nw_setservent(stayopen);
}
int
PerlSockSetsockopt(struct IPerlSock* piPerl, SOCKET s, int level, int optname, const char* optval, int optlen)
{
return nw_setsockopt(s, level, optname, optval, optlen);
}
int
PerlSockShutdown(struct IPerlSock* piPerl, SOCKET s, int how)
{
return nw_shutdown(s, how);
}
SOCKET
PerlSockSocket(struct IPerlSock* piPerl, int af, int type, int protocol)
{
return nw_socket(af, type, protocol);
}
int
PerlSockSocketpair(struct IPerlSock* piPerl, int domain, int type, int protocol, int* fds)
{
dTHX; // (J) dTHXo
Perl_croak(aTHX_ "socketpair not implemented!\n");
return 0;
}
int
PerlSockIoctlsocket(struct IPerlSock* piPerl, SOCKET s, long cmd, u_long *argp)
{
dTHX; // (J) dTHXo
Perl_croak(aTHX_ "ioctlsocket not implemented!\n");
return 0;
}
struct IPerlSock perlSock =
{
PerlSockHtonl,
PerlSockHtons,
PerlSockNtohl,
PerlSockNtohs,
PerlSockAccept,
PerlSockBind,
PerlSockConnect,
PerlSockEndhostent,
PerlSockEndnetent,
PerlSockEndprotoent,
PerlSockEndservent,
PerlSockGethostname,
PerlSockGetpeername,
PerlSockGethostbyaddr,
PerlSockGethostbyname,
PerlSockGethostent,
PerlSockGetnetbyaddr,
PerlSockGetnetbyname,
PerlSockGetnetent,
PerlSockGetprotobyname,
PerlSockGetprotobynumber,
PerlSockGetprotoent,
PerlSockGetservbyname,
PerlSockGetservbyport,
PerlSockGetservent,
PerlSockGetsockname,
PerlSockGetsockopt,
PerlSockInetAddr,
PerlSockInetNtoa,
PerlSockListen,
PerlSockRecv,
PerlSockRecvfrom,
PerlSockSelect,
PerlSockSend,
PerlSockSendto,
PerlSockSethostent,
PerlSockSetnetent,
PerlSockSetprotoent,
PerlSockSetservent,
PerlSockSetsockopt,
PerlSockShutdown,
PerlSockSocket,
PerlSockSocketpair,
//Following commented by sgp bcos of comiplation error too many initializers (E279)
// PerlSockClosesocket,
};
/* IPerlProc */
#define EXECF_EXEC 1
#define EXECF_SPAWN 2
void
PerlProcAbort(struct IPerlProc* piPerl)
{
nw_abort();
}
char *
PerlProcCrypt(struct IPerlProc* piPerl, const char* clear, const char* salt)
{
return nw_crypt(clear, salt);
}
void
PerlProcExit(struct IPerlProc* piPerl, int status)
{
// exit(status);
dTHX;
//dJMPENV;
JMPENV_JUMP(2);
}
void
PerlProc_Exit(struct IPerlProc* piPerl, int status)
{
// _exit(status);
dTHX;
//dJMPENV;
JMPENV_JUMP(2);
}
int
PerlProcExecl(struct IPerlProc* piPerl, const char *cmdname, const char *arg0, const char *arg1, const char *arg2, const char *arg3)
{
// If removed, compilation error occurs.
return 0;
}
int
PerlProcExecv(struct IPerlProc* piPerl, const char *cmdname, const char *const *argv)
{
return nw_execvp((char *)cmdname, (char **)argv);
}
int
PerlProcExecvp(struct IPerlProc* piPerl, const char *cmdname, const char *const *argv)
{
return nw_execvp((char *)cmdname, (char **)argv);
}
uid_t
PerlProcGetuid(struct IPerlProc* piPerl)
{
// If removed, compilation error occurs.
return 0;
}
uid_t
PerlProcGeteuid(struct IPerlProc* piPerl)
{
// If removed, compilation error occurs.
return 0;
}
gid_t
PerlProcGetgid(struct IPerlProc* piPerl)
{
// If removed, compilation error occurs.
return 0;
}
gid_t
PerlProcGetegid(struct IPerlProc* piPerl)
{
// If removed, compilation error occurs.
return 0;
}
char *
PerlProcGetlogin(struct IPerlProc* piPerl)
{
// If removed, compilation error occurs.
return NULL;
}
int
PerlProcKill(struct IPerlProc* piPerl, int pid, int sig)
{
return nw_kill(pid, sig);
}
int
PerlProcKillpg(struct IPerlProc* piPerl, int pid, int sig)
{
dTHX; // (J) dTHXo
Perl_croak(aTHX_ "killpg not implemented!\n");
return 0;
}
int
PerlProcPauseProc(struct IPerlProc* piPerl)
{
return nw_sleep((32767L << 16) + 32767);
}
PerlIO*
PerlProcPopen(struct IPerlProc* piPerl, const char *command, const char *mode)
{
dTHX; // (J) dTHXo
PERL_FLUSHALL_FOR_CHILD;
return (PerlIO*)nw_Popen((char *)command, (char *)mode, (int *)errno);
}
int
PerlProcPclose(struct IPerlProc* piPerl, PerlIO *stream)
{
return nw_Pclose((FILE*)stream, (int *)errno);
}
int
PerlProcPipe(struct IPerlProc* piPerl, int *phandles)
{
return nw_Pipe((int *)phandles, (int *)errno);
}
int
PerlProcSetuid(struct IPerlProc* piPerl, uid_t u)
{
// If removed, compilation error occurs.
return 0;
}
int
PerlProcSetgid(struct IPerlProc* piPerl, gid_t g)
{
// If removed, compilation error occurs.
return 0;
}
int
PerlProcSleep(struct IPerlProc* piPerl, unsigned int s)
{
return nw_sleep(s);
}
int
PerlProcTimes(struct IPerlProc* piPerl, struct tms *timebuf)
{
return nw_times(timebuf);
}
int
PerlProcWait(struct IPerlProc* piPerl, int *status)
{
return nw_wait(status);
}
int
PerlProcWaitpid(struct IPerlProc* piPerl, int pid, int *status, int flags)
{
return nw_waitpid(pid, status, flags);
}
Sighandler_t
PerlProcSignal(struct IPerlProc* piPerl, int sig, Sighandler_t subcode)
{
// If removed, compilation error occurs.
return 0;
}
int
PerlProcFork(struct IPerlProc* piPerl)
{
// If removed, compilation error occurs.
return 0;
}
int
PerlProcGetpid(struct IPerlProc* piPerl)
{
return nw_getpid();
}
BOOL
PerlProcDoCmd(struct IPerlProc* piPerl, char *cmd)
{
do_spawn2(cmd, EXECF_EXEC);
return FALSE;
}
int
PerlProcSpawn(struct IPerlProc* piPerl, char* cmds)
{
return do_spawn2(cmds, EXECF_SPAWN);
}
int
PerlProcSpawnvp(struct IPerlProc* piPerl, int mode, const char *cmdname, const char *const *argv)
{
return nw_spawnvp(mode, (char *)cmdname, (char **)argv);
}
int
PerlProcASpawn(struct IPerlProc* piPerl, void *vreally, void **vmark, void **vsp)
{
return do_aspawn(vreally, vmark, vsp);
}
struct IPerlProc perlProc =
{
PerlProcAbort,
PerlProcCrypt,
PerlProcExit,
PerlProc_Exit,
PerlProcExecl,
PerlProcExecv,
PerlProcExecvp,
PerlProcGetuid,
PerlProcGeteuid,
PerlProcGetgid,
PerlProcGetegid,
PerlProcGetlogin,
PerlProcKill,
PerlProcKillpg,
PerlProcPauseProc,
PerlProcPopen,
PerlProcPclose,
PerlProcPipe,
PerlProcSetuid,
PerlProcSetgid,
PerlProcSleep,
PerlProcTimes,
PerlProcWait,
PerlProcWaitpid,
PerlProcSignal,
PerlProcFork,
PerlProcGetpid,
/* PerlProcDynaLoader,
PerlProcGetOSError,
PerlProcDoCmd,
PerlProcSpawn,
PerlProcSpawnvp,
PerlProcASpawn,*/
};
/*
* CPerlHost
*/
CPerlHost::CPerlHost(void)
{
m_pVMem = new VMem();
m_pVMemShared = new VMem();
m_pVMemParse = new VMem();
memcpy(&m_hostperlMem, &perlMem, sizeof(perlMem));
memcpy(&m_hostperlMemShared, &perlMemShared, sizeof(perlMemShared));
memcpy(&m_hostperlMemParse, &perlMemParse, sizeof(perlMemParse));
memcpy(&m_hostperlEnv, &perlEnv, sizeof(perlEnv));
memcpy(&m_hostperlStdIO, &perlStdIO, sizeof(perlStdIO));
memcpy(&m_hostperlLIO, &perlLIO, sizeof(perlLIO));
memcpy(&m_hostperlDir, &perlDir, sizeof(perlDir));
memcpy(&m_hostperlSock, &perlSock, sizeof(perlSock));
memcpy(&m_hostperlProc, &perlProc, sizeof(perlProc));
m_pHostperlMem = &m_hostperlMem;
m_pHostperlMemShared = &m_hostperlMemShared;
m_pHostperlMemParse = &m_hostperlMemParse;
m_pHostperlEnv = &m_hostperlEnv;
m_pHostperlStdIO = &m_hostperlStdIO;
m_pHostperlLIO = &m_hostperlLIO;
m_pHostperlDir = &m_hostperlDir;
m_pHostperlSock = &m_hostperlSock;
m_pHostperlProc = &m_hostperlProc;
}
#define SETUPEXCHANGE(xptr, iptr, table) \
STMT_START { \
if (xptr) { \
iptr = *xptr; \
*xptr = &table; \
} \
else { \
iptr = &table; \
} \
} STMT_END
CPerlHost::CPerlHost(struct IPerlMem** ppMem, struct IPerlMem** ppMemShared,
struct IPerlMem** ppMemParse, struct IPerlEnv** ppEnv,
struct IPerlStdIO** ppStdIO, struct IPerlLIO** ppLIO,
struct IPerlDir** ppDir, struct IPerlSock** ppSock,
struct IPerlProc** ppProc)
{
m_pVMem = new VMem();
m_pVMemShared = new VMem();
m_pVMemParse = new VMem();
memcpy(&m_hostperlMem, &perlMem, sizeof(perlMem));
memcpy(&m_hostperlMemShared, &perlMemShared, sizeof(perlMemShared));
memcpy(&m_hostperlMemParse, &perlMemParse, sizeof(perlMemParse));
memcpy(&m_hostperlEnv, &perlEnv, sizeof(perlEnv));
memcpy(&m_hostperlStdIO, &perlStdIO, sizeof(perlStdIO));
memcpy(&m_hostperlLIO, &perlLIO, sizeof(perlLIO));
memcpy(&m_hostperlDir, &perlDir, sizeof(perlDir));
memcpy(&m_hostperlSock, &perlSock, sizeof(perlSock));
memcpy(&m_hostperlProc, &perlProc, sizeof(perlProc));
SETUPEXCHANGE(ppMem, m_pHostperlMem, m_hostperlMem);
SETUPEXCHANGE(ppMemShared, m_pHostperlMemShared, m_hostperlMemShared);
SETUPEXCHANGE(ppMemParse, m_pHostperlMemParse, m_hostperlMemParse);
SETUPEXCHANGE(ppEnv, m_pHostperlEnv, m_hostperlEnv);
SETUPEXCHANGE(ppStdIO, m_pHostperlStdIO, m_hostperlStdIO);
SETUPEXCHANGE(ppLIO, m_pHostperlLIO, m_hostperlLIO);
SETUPEXCHANGE(ppDir, m_pHostperlDir, m_hostperlDir);
SETUPEXCHANGE(ppSock, m_pHostperlSock, m_hostperlSock);
SETUPEXCHANGE(ppProc, m_pHostperlProc, m_hostperlProc);
}
#undef SETUPEXCHANGE
CPerlHost::CPerlHost(const CPerlHost& host)
{
memcpy(&m_hostperlMem, &perlMem, sizeof(perlMem));
memcpy(&m_hostperlMemShared, &perlMemShared, sizeof(perlMemShared));
memcpy(&m_hostperlMemParse, &perlMemParse, sizeof(perlMemParse));
memcpy(&m_hostperlEnv, &perlEnv, sizeof(perlEnv));
memcpy(&m_hostperlStdIO, &perlStdIO, sizeof(perlStdIO));
memcpy(&m_hostperlLIO, &perlLIO, sizeof(perlLIO));
memcpy(&m_hostperlDir, &perlDir, sizeof(perlDir));
memcpy(&m_hostperlSock, &perlSock, sizeof(perlSock));
memcpy(&m_hostperlProc, &perlProc, sizeof(perlProc));
m_pHostperlMem = &m_hostperlMem;
m_pHostperlMemShared = &m_hostperlMemShared;
m_pHostperlMemParse = &m_hostperlMemParse;
m_pHostperlEnv = &m_hostperlEnv;
m_pHostperlStdIO = &m_hostperlStdIO;
m_pHostperlLIO = &m_hostperlLIO;
m_pHostperlDir = &m_hostperlDir;
m_pHostperlSock = &m_hostperlSock;
m_pHostperlProc = &m_hostperlProc;
}
CPerlHost::~CPerlHost(void)
{
if ( m_pVMemParse ) delete m_pVMemParse;
if ( m_pVMemShared ) delete m_pVMemShared;
if ( m_pVMem ) delete m_pVMem;
}
char*
CPerlHost::Getenv(const char *varname)
{
// getenv is always present. In old CLIB, it is implemented
// to always return NULL. With java loaded on NW411, it will
// return values set by envset. Is correctly implemented by
// CLIB on MOAB.
//
return getenv(varname);
}
int
CPerlHost::Putenv(const char *envstring)
{
return(putenv(envstring));
}
#endif /* ___NWPerlHost_H___ */
|
