more complete pseudo-fork() support for Windows

p4raw-id: //depot/perl@4602

10 files changed, 4131 insertions, 1495 deletions

diff --git a/win32/Makefile b/win32/Makefile
index c4bb568570..fe38d99dba 100644
--- a/win32/Makefile
+++ b/win32/Makefile
@@ -65,6 +65,21 @@ INST_ARCH	= \$(ARCHNAME)
 #USE_OBJECT	= define
 
 #
+# XXX WARNING! This option currently undergoing changes.  May be broken.
+#
+# Beginnings of interpreter cloning/threads: still rather rough, fails
+# tests.  This should be enabled to get the fork() emulation.  Do not
+# enable unless you know what you're doing!
+#
+USE_ITHREADS	= define
+
+#
+# uncomment to enable the implicit "host" layer for all system calls
+# made by perl.  This is needed and auto-enabled by USE_OBJECT above.
+#
+USE_IMP_SYS	= define
+
+#
 # uncomment one of the following lines if you are using either
 # Visual C++ 2.x or Visual C++ 6.x (aka Visual Studio 98)
 #
@@ -84,6 +99,7 @@ INST_ARCH	= \$(ARCHNAME)
 # and follow the directions in the package to install.
 #
 #USE_PERLCRT	= define
+#BUILD_FOR_WIN95    = define
 
 #
 # uncomment to enable linking with setargv.obj under the Visual C
@@ -145,10 +161,8 @@ CCLIBDIR	= $(CCHOME)\lib
 #
 #BUILDOPT	= $(BUILDOPT) -DPERL_INTERNAL_GLOB
 
-# Beginnings of interpreter cloning/threads: still rather rough, fails
-# many tests.  Do not enable unless you know what you're doing!
-#
-#BUILDOPT	= $(BUILDOPT) -DUSE_ITHREADS
+# Enabling this runs a cloned toplevel interpreter (fails tests)
+#BUILDOPT	= $(BUILDOPT) -DTOP_CLONE
 
 # specify semicolon-separated list of extra directories that modules will
 # look for libraries (spaces in path names need not be quoted)
@@ -178,6 +192,7 @@ CRYPT_FLAG	= -DHAVE_DES_FCRYPT
 PERL_MALLOC	= undef
 USE_THREADS	= undef
 USE_MULTI	= undef
+USE_IMP_SYS	= define
 !ENDIF
 
 !IF "$(PERL_MALLOC)" == ""
@@ -188,6 +203,10 @@ PERL_MALLOC	= undef
 USE_THREADS	= undef
 !ENDIF
 
+!IF "$(USE_THREADS)" == "define"
+USE_ITHREADS	= undef
+!ENDIF
+
 !IF "$(USE_MULTI)" == ""
 USE_MULTI	= undef
 !ENDIF
@@ -196,10 +215,26 @@ USE_MULTI	= undef
 USE_OBJECT	= undef
 !ENDIF
 
+!IF "$(USE_ITHREADS)" == ""
+USE_ITHREADS	= undef
+!ENDIF
+
+!IF "$(USE_IMP_SYS)" == ""
+USE_IMP_SYS	= undef
+!ENDIF
+
 !IF "$(USE_MULTI)$(USE_THREADS)$(USE_OBJECT)" != "undefundefundef"
 BUILDOPT	= $(BUILDOPT) -DPERL_IMPLICIT_CONTEXT
 !ENDIF
 
+!IF "$(USE_ITHREADS)" != "undef"
+BUILDOPT	= $(BUILDOPT) -DUSE_ITHREADS
+!ENDIF
+
+!IF "$(USE_IMP_SYS)" != "undef"
+BUILDOPT	= $(BUILDOPT) -DPERL_IMPLICIT_SYS
+!ENDIF
+
 !IF "$(PROCESSOR_ARCHITECTURE)" == ""
 PROCESSOR_ARCHITECTURE	= x86
 !ENDIF
@@ -365,6 +400,7 @@ PERLDLL		= ..\perl.dll
 MINIPERL	= ..\miniperl.exe
 MINIDIR		= .\mini
 PERLEXE		= ..\perl.exe
+WPERLEXE	= ..\wperl.exe
 GLOBEXE		= ..\perlglob.exe
 CONFIGPM	= ..\lib\Config.pm
 MINIMOD		= ..\lib\ExtUtils\Miniperl.pm
@@ -404,7 +440,7 @@ MAKE		= nmake -nologo
 CFGSH_TMPL	= config.vc
 CFGH_TMPL	= config_H.vc
 
-!IF "$(USE_PERLCRT)" == ""
+!IF "$(BUILD_FOR_WIN95)" == "define"
 PERL95EXE	= ..\perl95.exe
 !ENDIF
 
@@ -527,7 +563,10 @@ CORE_NOCFG_H	=		\
 		.\include\dirent.h	\
 		.\include\netdb.h	\
 		.\include\sys\socket.h	\
-		.\win32.h
+		.\win32.h	\
+		.\perlhost.h	\
+		.\vdir.h	\
+		.\vmem.h
 
 CORE_H		= $(CORE_NOCFG_H) .\config.h
 
@@ -727,6 +766,12 @@ $(MINICORE_OBJ) : $(CORE_NOCFG_H)
 $(MINIWIN32_OBJ) : $(CORE_NOCFG_H)
 	$(CC) -c $(CFLAGS) $(OBJOUT_FLAG)$@ $(*F).c
 
+# -DPERL_IMPLICIT_SYS needs C++ for perllib.c
+!IF "$(USE_IMP_SYS)$(USE_OBJECT)" == "defineundef"
+perllib$(o)	: perllib.c
+	$(CC) -c -I. $(CFLAGS_O) $(CXX_FLAG) $(OBJOUT_FLAG)$@ perllib.c
+!ENDIF
+
 # 1. we don't want to rebuild miniperl.exe when config.h changes
 # 2. we don't want to rebuild miniperl.exe with non-default config.h
 $(MINI_OBJ)	: $(CORE_NOCFG_H)
@@ -781,10 +826,12 @@ perlmain$(o) : perlmain.c
 $(PERLEXE): $(PERLDLL) $(CONFIGPM) $(PERLEXE_OBJ)
 	$(LINK32) -subsystem:console -out:$@ $(LINK_FLAGS) $(LIBFILES) \
 	    $(PERLEXE_OBJ) $(SETARGV_OBJ) $(PERLIMPLIB) 
+	copy $(PERLEXE) $(WPERLEXE)
+	editbin /subsystem:windows $(WPERLEXE)
 	copy splittree.pl .. 
 	$(MINIPERL) -I..\lib ..\splittree.pl "../LIB" $(AUTODIR)
 
-!IF "$(USE_PERLCRT)" == ""
+!IF "$(BUILD_FOR_WIN95)" == "define"
 
 perl95.c : runperl.c 
 	copy runperl.c perl95.c
@@ -977,9 +1024,10 @@ install : all installbare installhtml
 
 installbare : utils
 	$(PERLEXE) ..\installperl
-!IF "$(USE_PERLCRT)" == ""
+!IF "$(BUILD_FOR_WIN95)" == "define"
 	$(XCOPY) $(PERL95EXE) $(INST_BIN)\*.*
 !ENDIF
+	if exist $(WPERLEXE) $(XCOPY) $(WPERLEXE) $(INST_BIN)\*.*
 	$(XCOPY) $(GLOBEXE) $(INST_BIN)\*.*
 	$(XCOPY) bin\*.bat $(INST_SCRIPT)\*.*
 
@@ -1025,6 +1073,7 @@ clean :
 	-@erase /f config.h
 	-@erase $(GLOBEXE)
 	-@erase $(PERLEXE)
+	-@erase $(WPERLEXE)
 	-@erase $(PERLDLL)
 	-@erase $(CORE_OBJ)
 	-rmdir /s /q $(MINIDIR) || rmdir /s $(MINIDIR)
diff --git a/win32/makefile.mk b/win32/makefile.mk
index 2550611c88..b5e1d19c7d 100644
--- a/win32/makefile.mk
+++ b/win32/makefile.mk
@@ -70,6 +70,21 @@ INST_ARCH	*= \$(ARCHNAME)
 #USE_OBJECT	*= define
 
 #
+# XXX WARNING! This option currently undergoing changes.  May be broken.
+#
+# Beginnings of interpreter cloning/threads: still rather rough, fails
+# tests.  This should be enabled to get the fork() emulation.  Do not
+# enable unless you know what you're doing!
+#
+USE_ITHREADS	*= define
+
+#
+# uncomment to enable the implicit "host" layer for all system calls
+# made by perl.  This is needed and auto-enabled by USE_OBJECT above.
+#
+USE_IMP_SYS	*= define
+
+#
 # uncomment exactly one of the following
 # 
 # Visual C++ 2.x
@@ -165,6 +180,9 @@ CCLIBDIR	*= $(CCHOME)\lib
 #
 #BUILDOPT	+= -DPERL_INTERNAL_GLOB
 
+# Enabling this runs a cloned toplevel interpreter (fails tests)
+#BUILDOPT	+= -DTOP_CLONE
+
 #
 # specify semicolon-separated list of extra directories that modules will
 # look for libraries (spaces in path names need not be quoted)
@@ -200,18 +218,33 @@ CRYPT_FLAG	= -DHAVE_DES_FCRYPT
 PERL_MALLOC	!= undef
 USE_THREADS	!= undef
 USE_MULTI	!= undef
+USE_IMP_SYS	!= define
 .ENDIF
 
 PERL_MALLOC	*= undef
 
 USE_THREADS	*= undef
+
+.IF "$(USE_THREADS)" == "define"
+USE_ITHREADS	!= undef
+.ENDIF
+
 USE_MULTI	*= undef
 USE_OBJECT	*= undef
+USE_ITHREADS	*= undef
+USE_IMP_SYS	*= undef
 
 .IF "$(USE_MULTI)$(USE_THREADS)$(USE_OBJECT)" != "undefundefundef"
 BUILDOPT	+= -DPERL_IMPLICIT_CONTEXT
 .ENDIF
 
+.IF "$(USE_ITHREADS)" != "undef"
+BUILDOPT	+= -DUSE_ITHREADS
+.ENDIF
+
+.IF "$(USE_IMP_SYS)" != "undef"
+BUILDOPT	+= -DPERL_IMPLICIT_SYS
+.ENDIF
 
 .IMPORT .IGNORE : PROCESSOR_ARCHITECTURE
 
@@ -459,6 +492,7 @@ $(o).dll:
 MINIPERL	= ..\miniperl.exe
 MINIDIR		= .\mini
 PERLEXE		= ..\perl.exe
+WPERLEXE	= ..\wperl.exe
 GLOBEXE		= ..\perlglob.exe
 CONFIGPM	= ..\lib\Config.pm
 MINIMOD		= ..\lib\ExtUtils\Miniperl.pm
@@ -644,7 +678,10 @@ CORE_NOCFG_H	=		\
 		.\include\dirent.h	\
 		.\include\netdb.h	\
 		.\include\sys\socket.h	\
-		.\win32.h
+		.\win32.h	\
+		.\perlhost.h	\
+		.\vdir.h	\
+		.\vmem.h
 
 CORE_H		= $(CORE_NOCFG_H) .\config.h
 
@@ -870,6 +907,12 @@ $(MINICORE_OBJ) : $(CORE_NOCFG_H)
 $(MINIWIN32_OBJ) : $(CORE_NOCFG_H)
 	$(CC) -c $(CFLAGS) $(OBJOUT_FLAG)$@ $(*B).c
 
+# -DPERL_IMPLICIT_SYS needs C++ for perllib.c
+.IF "$(USE_IMP_SYS)$(USE_OBJECT)" == "defineundef"
+perllib$(o)	: perllib.c
+	$(CC) -c -I. $(CFLAGS_O) $(CXX_FLAG) $(OBJOUT_FLAG)$@ perllib.c
+.ENDIF
+
 # 1. we don't want to rebuild miniperl.exe when config.h changes
 # 2. we don't want to rebuild miniperl.exe with non-default config.h
 $(MINI_OBJ)	: $(CORE_NOCFG_H)
@@ -959,6 +1002,8 @@ $(PERLEXE): $(PERLDLL) $(CONFIGPM) $(PERLEXE_OBJ)
 .ELSE
 	$(LINK32) -subsystem:console -out:$@ $(LINK_FLAGS) $(LIBFILES) \
 	    $(PERLEXE_OBJ) $(SETARGV_OBJ) $(PERLIMPLIB) 
+	copy $(PERLEXE) $(WPERLEXE)
+	editbin /subsystem:windows $(WPERLEXE)
 .ENDIF
 	copy splittree.pl .. 
 	$(MINIPERL) -I..\lib ..\splittree.pl "../LIB" $(AUTODIR)
@@ -1137,6 +1182,7 @@ installbare : utils
 .IF "$(PERL95EXE)" != ""
 	$(XCOPY) $(PERL95EXE) $(INST_BIN)\*.*
 .ENDIF
+	if exist $(WPERLEXE) $(XCOPY) $(WPERLEXE) $(INST_BIN)\*.*
 	$(XCOPY) $(GLOBEXE) $(INST_BIN)\*.*
 	$(XCOPY) bin\*.bat $(INST_SCRIPT)\*.*
 
@@ -1185,6 +1231,7 @@ clean :
 	-@erase /f config.h
 	-@erase $(GLOBEXE)
 	-@erase $(PERLEXE)
+	-@erase $(WPERLEXE)
 	-@erase $(PERLDLL)
 	-@erase $(CORE_OBJ)
 	-rmdir /s /q $(MINIDIR) || rmdir /s $(MINIDIR)
diff --git a/win32/perlhost.h b/win32/perlhost.h
new file mode 100644
index 0000000000..236a97c00b
--- /dev/null
+++ b/win32/perlhost.h
@@ -0,0 +1,2283 @@
+/* perlhost.h
+ *
+ * (c) 1999 Microsoft Corporation. All rights reserved. 
+ * Portions (c) 1999 ActiveState Tool Corp, http://www.ActiveState.com/
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ */
+
+#ifndef ___PerlHost_H___
+#define ___PerlHost_H___
+
+#include "iperlsys.h"
+#include "vmem.h"
+#include "vdir.h"
+
+#if !defined(PERL_OBJECT)
+START_EXTERN_C
+#endif
+extern char *		g_win32_get_privlib(char *pl);
+extern char *		g_win32_get_sitelib(char *pl);
+extern char *		g_getlogin(void);
+extern int		do_spawn2(char *cmd, int exectype);
+#if !defined(PERL_OBJECT)
+END_EXTERN_C
+#endif
+
+#ifdef PERL_OBJECT
+extern int		g_do_aspawn(void *vreally, void **vmark, void **vsp);
+#define do_aspawn	g_do_aspawn
+#endif
+
+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(CPerlHost& host);
+    ~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);
+
+    BOOL PerlCreate(void);
+    int PerlParse(int argc, char** argv, char** env);
+    int PerlRun(void);
+    void PerlDestroy(void);
+
+/* 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)
+    {
+	size_t count = num*size;
+	void* lpVoid = Malloc(count);
+	if (lpVoid)
+	    ZeroMemory(lpVoid, count);
+	return lpVoid;
+    };
+    inline void GetLock(void) { m_pVMem->GetLock(); };
+    inline void FreeLock(void) { m_pVMem->FreeLock(); };
+    inline int IsLocked(void) { return m_pVMem->IsLocked(); };
+
+/* 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);
+	if (lpVoid)
+	    ZeroMemory(lpVoid, count);
+	return lpVoid;
+    };
+    inline void GetLockShared(void) { m_pVMem->GetLock(); };
+    inline void FreeLockShared(void) { m_pVMem->FreeLock(); };
+    inline int IsLockedShared(void) { return m_pVMem->IsLocked(); };
+
+/* 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);
+	if (lpVoid)
+	    ZeroMemory(lpVoid, count);
+	return lpVoid;
+    };
+    inline void GetLockParse(void) { m_pVMem->GetLock(); };
+    inline void FreeLockParse(void) { m_pVMem->FreeLock(); };
+    inline int IsLockedParse(void) { return m_pVMem->IsLocked(); };
+
+/* 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;
+    }
+    void* CreateChildEnv(void) { return CreateLocalEnvironmentStrings(*m_pvDir); };
+    void FreeChildEnv(void* pStr) { FreeLocalEnvironmentStrings((char*)pStr); };
+    char* GetChildDir(void);
+    void FreeChildDir(char* pStr);
+    void Reset(void);
+    void Clearenv(void);
+
+    inline LPSTR GetIndex(DWORD &dwIndex)
+    {
+	if(dwIndex < m_dwEnvCount)
+	{
+	    ++dwIndex;
+	    return m_lppEnvList[dwIndex-1];
+	}
+	return NULL;
+    };
+
+protected:
+    LPSTR Find(LPCSTR lpStr);
+    void Add(LPCSTR lpStr);
+
+    LPSTR CreateLocalEnvironmentStrings(VDir &vDir);
+    void FreeLocalEnvironmentStrings(LPSTR lpStr);
+    LPSTR* Lookup(LPCSTR lpStr);
+    DWORD CalculateEnvironmentSpace(void);
+
+public:
+
+/* IPerlDIR */
+    virtual int Chdir(const char *dirname);
+
+/* 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);
+
+    inline VMem* GetMemShared(void) { m_pVMemShared->AddRef(); return m_pVMemShared; };
+    inline VMem* GetMemParse(void) { m_pVMemParse->AddRef(); return m_pVMemParse; };
+    inline VDir* GetDir(void) { return m_pvDir; };
+
+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;
+
+    inline char* MapPathA(const char *pInName) { return m_pvDir->MapPathA(pInName); };
+    inline WCHAR* MapPathW(const WCHAR *pInName) { return m_pvDir->MapPathW(pInName); };
+protected:
+
+    VDir*   m_pvDir;
+    VMem*   m_pVMem;
+    VMem*   m_pVMemShared;
+    VMem*   m_pVMemParse;
+
+    DWORD   m_dwEnvCount;
+    LPSTR*  m_lppEnvList;
+};
+
+
+#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);
+}
+
+void
+PerlMemGetLock(struct IPerlMem* piPerl)
+{
+    IPERL2HOST(piPerl)->GetLock();
+}
+
+void
+PerlMemFreeLock(struct IPerlMem* piPerl)
+{
+    IPERL2HOST(piPerl)->FreeLock();
+}
+
+int
+PerlMemIsLocked(struct IPerlMem* piPerl)
+{
+    return IPERL2HOST(piPerl)->IsLocked();
+}
+
+struct IPerlMem perlMem =
+{
+    PerlMemMalloc,
+    PerlMemRealloc,
+    PerlMemFree,
+    PerlMemCalloc,
+    PerlMemGetLock,
+    PerlMemFreeLock,
+    PerlMemIsLocked,
+};
+
+#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);
+}
+
+void
+PerlMemSharedGetLock(struct IPerlMem* piPerl)
+{
+    IPERL2HOST(piPerl)->GetLockShared();
+}
+
+void
+PerlMemSharedFreeLock(struct IPerlMem* piPerl)
+{
+    IPERL2HOST(piPerl)->FreeLockShared();
+}
+
+int
+PerlMemSharedIsLocked(struct IPerlMem* piPerl)
+{
+    return IPERL2HOST(piPerl)->IsLockedShared();
+}
+
+struct IPerlMem perlMemShared =
+{
+    PerlMemSharedMalloc,
+    PerlMemSharedRealloc,
+    PerlMemSharedFree,
+    PerlMemSharedCalloc,
+    PerlMemSharedGetLock,
+    PerlMemSharedFreeLock,
+    PerlMemSharedIsLocked,
+};
+
+#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);
+}
+
+void
+PerlMemParseGetLock(struct IPerlMem* piPerl)
+{
+    IPERL2HOST(piPerl)->GetLockParse();
+}
+
+void
+PerlMemParseFreeLock(struct IPerlMem* piPerl)
+{
+    IPERL2HOST(piPerl)->FreeLockParse();
+}
+
+int
+PerlMemParseIsLocked(struct IPerlMem* piPerl)
+{
+    return IPERL2HOST(piPerl)->IsLockedParse();
+}
+
+struct IPerlMem perlMemParse =
+{
+    PerlMemParseMalloc,
+    PerlMemParseRealloc,
+    PerlMemParseFree,
+    PerlMemParseCalloc,
+    PerlMemParseGetLock,
+    PerlMemParseFreeLock,
+    PerlMemParseIsLocked,
+};
+
+
+#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 win32_uname(name);
+}
+
+void
+PerlEnvClearenv(struct IPerlEnv* piPerl)
+{
+    IPERL2HOST(piPerl)->Clearenv();
+}
+
+void*
+PerlEnvGetChildenv(struct IPerlEnv* piPerl)
+{
+    return IPERL2HOST(piPerl)->CreateChildEnv();
+}
+
+void
+PerlEnvFreeChildenv(struct IPerlEnv* piPerl, void* childEnv)
+{
+    IPERL2HOST(piPerl)->FreeChildEnv(childEnv);
+}
+
+char*
+PerlEnvGetChilddir(struct IPerlEnv* piPerl)
+{
+    return IPERL2HOST(piPerl)->GetChildDir();
+}
+
+void
+PerlEnvFreeChilddir(struct IPerlEnv* piPerl, char* childDir)
+{
+    IPERL2HOST(piPerl)->FreeChildDir(childDir);
+}
+
+unsigned long
+PerlEnvOsId(struct IPerlEnv* piPerl)
+{
+    return win32_os_id();
+}
+
+char*
+PerlEnvLibPath(struct IPerlEnv* piPerl, char *pl)
+{
+    return g_win32_get_privlib(pl);
+}
+
+char*
+PerlEnvSiteLibPath(struct IPerlEnv* piPerl, char *pl)
+{
+    return g_win32_get_sitelib(pl);
+}
+
+struct IPerlEnv perlEnv = 
+{
+    PerlEnvGetenv,
+    PerlEnvPutenv,
+    PerlEnvGetenv_len,
+    PerlEnvUname,
+    PerlEnvClearenv,
+    PerlEnvGetChildenv,
+    PerlEnvFreeChildenv,
+    PerlEnvGetChilddir,
+    PerlEnvFreeChilddir,
+    PerlEnvOsId,
+    PerlEnvLibPath,
+    PerlEnvSiteLibPath,
+};
+
+#undef IPERL2HOST
+#define IPERL2HOST(x) IPerlStdIO2Host(x)
+
+/* PerlStdIO */
+PerlIO*
+PerlStdIOStdin(struct IPerlStdIO* piPerl)
+{
+    return (PerlIO*)win32_stdin();
+}
+
+PerlIO*
+PerlStdIOStdout(struct IPerlStdIO* piPerl)
+{
+    return (PerlIO*)win32_stdout();
+}
+
+PerlIO*
+PerlStdIOStderr(struct IPerlStdIO* piPerl)
+{
+    return (PerlIO*)win32_stderr();
+}
+
+PerlIO*
+PerlStdIOOpen(struct IPerlStdIO* piPerl, const char *path, const char *mode)
+{
+    return (PerlIO*)win32_fopen(path, mode);
+}
+
+int
+PerlStdIOClose(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    return win32_fclose(((FILE*)pf));
+}
+
+int
+PerlStdIOEof(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    return win32_feof((FILE*)pf);
+}
+
+int
+PerlStdIOError(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    return win32_ferror((FILE*)pf);
+}
+
+void
+PerlStdIOClearerr(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    win32_clearerr((FILE*)pf);
+}
+
+int
+PerlStdIOGetc(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    return win32_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 win32_fgets(s, n, (FILE*)pf);
+}
+
+int
+PerlStdIOPutc(struct IPerlStdIO* piPerl, PerlIO* pf, int c)
+{
+    return win32_fputc(c, (FILE*)pf);
+}
+
+int
+PerlStdIOPuts(struct IPerlStdIO* piPerl, PerlIO* pf, const char *s)
+{
+    return win32_fputs(s, (FILE*)pf);
+}
+
+int
+PerlStdIOFlush(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    return win32_fflush((FILE*)pf);
+}
+
+int
+PerlStdIOUngetc(struct IPerlStdIO* piPerl, PerlIO* pf,int c)
+{
+    return win32_ungetc(c, (FILE*)pf);
+}
+
+int
+PerlStdIOFileno(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    return win32_fileno((FILE*)pf);
+}
+
+PerlIO*
+PerlStdIOFdopen(struct IPerlStdIO* piPerl, int fd, const char *mode)
+{
+    return (PerlIO*)win32_fdopen(fd, mode);
+}
+
+PerlIO*
+PerlStdIOReopen(struct IPerlStdIO* piPerl, const char*path, const char*mode, PerlIO* pf)
+{
+    return (PerlIO*)win32_freopen(path, mode, (FILE*)pf);
+}
+
+SSize_t
+PerlStdIORead(struct IPerlStdIO* piPerl, PerlIO* pf, void *buffer, Size_t size)
+{
+    return win32_fread(buffer, 1, size, (FILE*)pf);
+}
+
+SSize_t
+PerlStdIOWrite(struct IPerlStdIO* piPerl, PerlIO* pf, const void *buffer, Size_t size)
+{
+    return win32_fwrite(buffer, 1, size, (FILE*)pf);
+}
+
+void
+PerlStdIOSetBuf(struct IPerlStdIO* piPerl, PerlIO* pf, char* buffer)
+{
+    win32_setbuf((FILE*)pf, buffer);
+}
+
+int
+PerlStdIOSetVBuf(struct IPerlStdIO* piPerl, PerlIO* pf, char* buffer, int type, Size_t size)
+{
+    return win32_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)
+{
+    win32_setvbuf((FILE*)pf, NULL, _IOLBF, 0);
+}
+
+int
+PerlStdIOPrintf(struct IPerlStdIO* piPerl, PerlIO* pf, const char *format,...)
+{
+    va_list(arglist);
+    va_start(arglist, format);
+    return win32_vfprintf((FILE*)pf, format, arglist);
+}
+
+int
+PerlStdIOVprintf(struct IPerlStdIO* piPerl, PerlIO* pf, const char *format, va_list arglist)
+{
+    return win32_vfprintf((FILE*)pf, format, arglist);
+}
+
+long
+PerlStdIOTell(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    return win32_ftell((FILE*)pf);
+}
+
+int
+PerlStdIOSeek(struct IPerlStdIO* piPerl, PerlIO* pf, off_t offset, int origin)
+{
+    return win32_fseek((FILE*)pf, offset, origin);
+}
+
+void
+PerlStdIORewind(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    win32_rewind((FILE*)pf);
+}
+
+PerlIO*
+PerlStdIOTmpfile(struct IPerlStdIO* piPerl)
+{
+    return (PerlIO*)win32_tmpfile();
+}
+
+int
+PerlStdIOGetpos(struct IPerlStdIO* piPerl, PerlIO* pf, Fpos_t *p)
+{
+    return win32_fgetpos((FILE*)pf, p);
+}
+
+int
+PerlStdIOSetpos(struct IPerlStdIO* piPerl, PerlIO* pf, const Fpos_t *p)
+{
+    return win32_fsetpos((FILE*)pf, p);
+}
+void
+PerlStdIOInit(struct IPerlStdIO* piPerl)
+{
+}
+
+void
+PerlStdIOInitOSExtras(struct IPerlStdIO* piPerl)
+{
+    Perl_init_os_extras();
+}
+
+int
+PerlStdIOOpenOSfhandle(struct IPerlStdIO* piPerl, long osfhandle, int flags)
+{
+    return win32_open_osfhandle(osfhandle, flags);
+}
+
+int
+PerlStdIOGetOSfhandle(struct IPerlStdIO* piPerl, int filenum)
+{
+    return win32_get_osfhandle(filenum);
+}
+
+PerlIO*
+PerlStdIOFdupopen(struct IPerlStdIO* piPerl, PerlIO* pf)
+{
+    PerlIO* pfdup;
+    fpos_t pos;
+    char mode[3];
+    int fileno = win32_dup(win32_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*)win32_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 win32_access(path, mode);
+}
+
+int
+PerlLIOChmod(struct IPerlLIO* piPerl, const char *filename, int pmode)
+{
+    return win32_chmod(filename, pmode);
+}
+
+int
+PerlLIOChown(struct IPerlLIO* piPerl, const char *filename, uid_t owner, gid_t group)
+{
+    return chown(filename, owner, group);
+}
+
+int
+PerlLIOChsize(struct IPerlLIO* piPerl, int handle, long size)
+{
+    return chsize(handle, size);
+}
+
+int
+PerlLIOClose(struct IPerlLIO* piPerl, int handle)
+{
+    return win32_close(handle);
+}
+
+int
+PerlLIODup(struct IPerlLIO* piPerl, int handle)
+{
+    return win32_dup(handle);
+}
+
+int
+PerlLIODup2(struct IPerlLIO* piPerl, int handle1, int handle2)
+{
+    return win32_dup2(handle1, handle2);
+}
+
+int
+PerlLIOFlock(struct IPerlLIO* piPerl, int fd, int oper)
+{
+    return win32_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)
+{
+    return win32_ioctlsocket((SOCKET)i, (long)u, (u_long*)data);
+}
+
+int
+PerlLIOIsatty(struct IPerlLIO* piPerl, int fd)
+{
+    return isatty(fd);
+}
+
+int
+PerlLIOLink(struct IPerlLIO* piPerl, const char*oldname, const char *newname)
+{
+    return win32_link(oldname, newname);
+}
+
+long
+PerlLIOLseek(struct IPerlLIO* piPerl, int handle, long offset, int origin)
+{
+    return win32_lseek(handle, offset, origin);
+}
+
+int
+PerlLIOLstat(struct IPerlLIO* piPerl, const char *path, struct stat *buffer)
+{
+    return win32_stat(path, buffer);
+}
+
+char*
+PerlLIOMktemp(struct IPerlLIO* piPerl, char *Template)
+{
+    return mktemp(Template);
+}
+
+int
+PerlLIOOpen(struct IPerlLIO* piPerl, const char *filename, int oflag)
+{
+    return win32_open(filename, oflag);
+}
+
+int
+PerlLIOOpen3(struct IPerlLIO* piPerl, const char *filename, int oflag, int pmode)
+{
+    return win32_open(filename, oflag, pmode);
+}
+
+int
+PerlLIORead(struct IPerlLIO* piPerl, int handle, void *buffer, unsigned int count)
+{
+    return win32_read(handle, buffer, count);
+}
+
+int
+PerlLIORename(struct IPerlLIO* piPerl, const char *OldFileName, const char *newname)
+{
+    return win32_rename(OldFileName, newname);
+}
+
+int
+PerlLIOSetmode(struct IPerlLIO* piPerl, int handle, int mode)
+{
+    return win32_setmode(handle, mode);
+}
+
+int
+PerlLIONameStat(struct IPerlLIO* piPerl, const char *path, struct stat *buffer)
+{
+    return win32_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 win32_unlink(filename);
+}
+
+int
+PerlLIOUtime(struct IPerlLIO* piPerl, char *filename, struct utimbuf *times)
+{
+    return win32_utime(filename, times);
+}
+
+int
+PerlLIOWrite(struct IPerlLIO* piPerl, int handle, const void *buffer, unsigned int count)
+{
+    return win32_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 win32_mkdir(dirname, mode);
+}
+
+int
+PerlDirChdir(struct IPerlDir* piPerl, const char *dirname)
+{
+    return IPERL2HOST(piPerl)->Chdir(dirname);
+}
+
+int
+PerlDirRmdir(struct IPerlDir* piPerl, const char *dirname)
+{
+    return win32_rmdir(dirname);
+}
+
+int
+PerlDirClose(struct IPerlDir* piPerl, DIR *dirp)
+{
+    return win32_closedir(dirp);
+}
+
+DIR*
+PerlDirOpen(struct IPerlDir* piPerl, char *filename)
+{
+    return win32_opendir(filename);
+}
+
+struct direct *
+PerlDirRead(struct IPerlDir* piPerl, DIR *dirp)
+{
+    return win32_readdir(dirp);
+}
+
+void
+PerlDirRewind(struct IPerlDir* piPerl, DIR *dirp)
+{
+    win32_rewinddir(dirp);
+}
+
+void
+PerlDirSeek(struct IPerlDir* piPerl, DIR *dirp, long loc)
+{
+    win32_seekdir(dirp, loc);
+}
+
+long
+PerlDirTell(struct IPerlDir* piPerl, DIR *dirp)
+{
+    return win32_telldir(dirp);
+}
+
+char*
+PerlDirMapPathA(struct IPerlDir* piPerl, const char* path)
+{
+    return IPERL2HOST(piPerl)->MapPathA(path);
+}
+
+WCHAR*
+PerlDirMapPathW(struct IPerlDir* piPerl, const WCHAR* path)
+{
+    return IPERL2HOST(piPerl)->MapPathW(path);
+}
+
+struct IPerlDir perlDir =
+{
+    PerlDirMakedir,
+    PerlDirChdir,
+    PerlDirRmdir,
+    PerlDirClose,
+    PerlDirOpen,
+    PerlDirRead,
+    PerlDirRewind,
+    PerlDirSeek,
+    PerlDirTell,
+    PerlDirMapPathA,
+    PerlDirMapPathW,
+};
+
+
+/* IPerlSock */
+u_long
+PerlSockHtonl(struct IPerlSock* piPerl, u_long hostlong)
+{
+    return win32_htonl(hostlong);
+}
+
+u_short
+PerlSockHtons(struct IPerlSock* piPerl, u_short hostshort)
+{
+    return win32_htons(hostshort);
+}
+
+u_long
+PerlSockNtohl(struct IPerlSock* piPerl, u_long netlong)
+{
+    return win32_ntohl(netlong);
+}
+
+u_short
+PerlSockNtohs(struct IPerlSock* piPerl, u_short netshort)
+{
+    return win32_ntohs(netshort);
+}
+
+SOCKET PerlSockAccept(struct IPerlSock* piPerl, SOCKET s, struct sockaddr* addr, int* addrlen)
+{
+    return win32_accept(s, addr, addrlen);
+}
+
+int
+PerlSockBind(struct IPerlSock* piPerl, SOCKET s, const struct sockaddr* name, int namelen)
+{
+    return win32_bind(s, name, namelen);
+}
+
+int
+PerlSockConnect(struct IPerlSock* piPerl, SOCKET s, const struct sockaddr* name, int namelen)
+{
+    return win32_connect(s, name, namelen);
+}
+
+void
+PerlSockEndhostent(struct IPerlSock* piPerl)
+{
+    win32_endhostent();
+}
+
+void
+PerlSockEndnetent(struct IPerlSock* piPerl)
+{
+    win32_endnetent();
+}
+
+void
+PerlSockEndprotoent(struct IPerlSock* piPerl)
+{
+    win32_endprotoent();
+}
+
+void
+PerlSockEndservent(struct IPerlSock* piPerl)
+{
+    win32_endservent();
+}
+
+struct hostent*
+PerlSockGethostbyaddr(struct IPerlSock* piPerl, const char* addr, int len, int type)
+{
+    return win32_gethostbyaddr(addr, len, type);
+}
+
+struct hostent*
+PerlSockGethostbyname(struct IPerlSock* piPerl, const char* name)
+{
+    return win32_gethostbyname(name);
+}
+
+struct hostent*
+PerlSockGethostent(struct IPerlSock* piPerl)
+{
+    dTHXo;
+    Perl_croak(aTHX_ "gethostent not implemented!\n");
+    return NULL;
+}
+
+int
+PerlSockGethostname(struct IPerlSock* piPerl, char* name, int namelen)
+{
+    return win32_gethostname(name, namelen);
+}
+
+struct netent *
+PerlSockGetnetbyaddr(struct IPerlSock* piPerl, long net, int type)
+{
+    return win32_getnetbyaddr(net, type);
+}
+
+struct netent *
+PerlSockGetnetbyname(struct IPerlSock* piPerl, const char *name)
+{
+    return win32_getnetbyname((char*)name);
+}
+
+struct netent *
+PerlSockGetnetent(struct IPerlSock* piPerl)
+{
+    return win32_getnetent();
+}
+
+int PerlSockGetpeername(struct IPerlSock* piPerl, SOCKET s, struct sockaddr* name, int* namelen)
+{
+    return win32_getpeername(s, name, namelen);
+}
+
+struct protoent*
+PerlSockGetprotobyname(struct IPerlSock* piPerl, const char* name)
+{
+    return win32_getprotobyname(name);
+}
+
+struct protoent*
+PerlSockGetprotobynumber(struct IPerlSock* piPerl, int number)
+{
+    return win32_getprotobynumber(number);
+}
+
+struct protoent*
+PerlSockGetprotoent(struct IPerlSock* piPerl)
+{
+    return win32_getprotoent();
+}
+
+struct servent*
+PerlSockGetservbyname(struct IPerlSock* piPerl, const char* name, const char* proto)
+{
+    return win32_getservbyname(name, proto);
+}
+
+struct servent*
+PerlSockGetservbyport(struct IPerlSock* piPerl, int port, const char* proto)
+{
+    return win32_getservbyport(port, proto);
+}
+
+struct servent*
+PerlSockGetservent(struct IPerlSock* piPerl)
+{
+    return win32_getservent();
+}
+
+int
+PerlSockGetsockname(struct IPerlSock* piPerl, SOCKET s, struct sockaddr* name, int* namelen)
+{
+    return win32_getsockname(s, name, namelen);
+}
+
+int
+PerlSockGetsockopt(struct IPerlSock* piPerl, SOCKET s, int level, int optname, char* optval, int* optlen)
+{
+    return win32_getsockopt(s, level, optname, optval, optlen);
+}
+
+unsigned long
+PerlSockInetAddr(struct IPerlSock* piPerl, const char* cp)
+{
+    return win32_inet_addr(cp);
+}
+
+char*
+PerlSockInetNtoa(struct IPerlSock* piPerl, struct in_addr in)
+{
+    return win32_inet_ntoa(in);
+}
+
+int
+PerlSockListen(struct IPerlSock* piPerl, SOCKET s, int backlog)
+{
+    return win32_listen(s, backlog);
+}
+
+int
+PerlSockRecv(struct IPerlSock* piPerl, SOCKET s, char* buffer, int len, int flags)
+{
+    return win32_recv(s, buffer, len, flags);
+}
+
+int
+PerlSockRecvfrom(struct IPerlSock* piPerl, SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen)
+{
+    return win32_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 win32_select(nfds, (Perl_fd_set*)readfds, (Perl_fd_set*)writefds, (Perl_fd_set*)exceptfds, timeout);
+}
+
+int
+PerlSockSend(struct IPerlSock* piPerl, SOCKET s, const char* buffer, int len, int flags)
+{
+    return win32_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 win32_sendto(s, buffer, len, flags, to, tolen);
+}
+
+void
+PerlSockSethostent(struct IPerlSock* piPerl, int stayopen)
+{
+    win32_sethostent(stayopen);
+}
+
+void
+PerlSockSetnetent(struct IPerlSock* piPerl, int stayopen)
+{
+    win32_setnetent(stayopen);
+}
+
+void
+PerlSockSetprotoent(struct IPerlSock* piPerl, int stayopen)
+{
+    win32_setprotoent(stayopen);
+}
+
+void
+PerlSockSetservent(struct IPerlSock* piPerl, int stayopen)
+{
+    win32_setservent(stayopen);
+}
+
+int
+PerlSockSetsockopt(struct IPerlSock* piPerl, SOCKET s, int level, int optname, const char* optval, int optlen)
+{
+    return win32_setsockopt(s, level, optname, optval, optlen);
+}
+
+int
+PerlSockShutdown(struct IPerlSock* piPerl, SOCKET s, int how)
+{
+    return win32_shutdown(s, how);
+}
+
+SOCKET
+PerlSockSocket(struct IPerlSock* piPerl, int af, int type, int protocol)
+{
+    return win32_socket(af, type, protocol);
+}
+
+int
+PerlSockSocketpair(struct IPerlSock* piPerl, int domain, int type, int protocol, int* fds)
+{
+    dTHXo;
+    Perl_croak(aTHX_ "socketpair not implemented!\n");
+    return 0;
+}
+
+int
+PerlSockClosesocket(struct IPerlSock* piPerl, SOCKET s)
+{
+    return win32_closesocket(s);
+}
+
+int
+PerlSockIoctlsocket(struct IPerlSock* piPerl, SOCKET s, long cmd, u_long *argp)
+{
+    return win32_ioctlsocket(s, cmd, argp);
+}
+
+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,
+    PerlSockClosesocket,
+};
+
+
+/* IPerlProc */
+
+#define EXECF_EXEC 1
+#define EXECF_SPAWN 2
+
+void
+PerlProcAbort(struct IPerlProc* piPerl)
+{
+    win32_abort();
+}
+
+char *
+PerlProcCrypt(struct IPerlProc* piPerl, const char* clear, const char* salt)
+{
+    return win32_crypt(clear, salt);
+}
+
+void
+PerlProcExit(struct IPerlProc* piPerl, int status)
+{
+    exit(status);
+}
+
+void
+PerlProc_Exit(struct IPerlProc* piPerl, int status)
+{
+    _exit(status);
+}
+
+int
+PerlProcExecl(struct IPerlProc* piPerl, const char *cmdname, const char *arg0, const char *arg1, const char *arg2, const char *arg3)
+{
+    return execl(cmdname, arg0, arg1, arg2, arg3);
+}
+
+int
+PerlProcExecv(struct IPerlProc* piPerl, const char *cmdname, const char *const *argv)
+{
+    return win32_execvp(cmdname, argv);
+}
+
+int
+PerlProcExecvp(struct IPerlProc* piPerl, const char *cmdname, const char *const *argv)
+{
+    return win32_execvp(cmdname, argv);
+}
+
+uid_t
+PerlProcGetuid(struct IPerlProc* piPerl)
+{
+    return getuid();
+}
+
+uid_t
+PerlProcGeteuid(struct IPerlProc* piPerl)
+{
+    return geteuid();
+}
+
+gid_t
+PerlProcGetgid(struct IPerlProc* piPerl)
+{
+    return getgid();
+}
+
+gid_t
+PerlProcGetegid(struct IPerlProc* piPerl)
+{
+    return getegid();
+}
+
+char *
+PerlProcGetlogin(struct IPerlProc* piPerl)
+{
+    return g_getlogin();
+}
+
+int
+PerlProcKill(struct IPerlProc* piPerl, int pid, int sig)
+{
+    return win32_kill(pid, sig);
+}
+
+int
+PerlProcKillpg(struct IPerlProc* piPerl, int pid, int sig)
+{
+    dTHXo;
+    Perl_croak(aTHX_ "killpg not implemented!\n");
+    return 0;
+}
+
+int
+PerlProcPauseProc(struct IPerlProc* piPerl)
+{
+    return win32_sleep((32767L << 16) + 32767);
+}
+
+PerlIO*
+PerlProcPopen(struct IPerlProc* piPerl, const char *command, const char *mode)
+{
+    dTHXo;
+    PERL_FLUSHALL_FOR_CHILD;
+    return (PerlIO*)win32_popen(command, mode);
+}
+
+int
+PerlProcPclose(struct IPerlProc* piPerl, PerlIO *stream)
+{
+    return win32_pclose((FILE*)stream);
+}
+
+int
+PerlProcPipe(struct IPerlProc* piPerl, int *phandles)
+{
+    return win32_pipe(phandles, 512, O_BINARY);
+}
+
+int
+PerlProcSetuid(struct IPerlProc* piPerl, uid_t u)
+{
+    return setuid(u);
+}
+
+int
+PerlProcSetgid(struct IPerlProc* piPerl, gid_t g)
+{
+    return setgid(g);
+}
+
+int
+PerlProcSleep(struct IPerlProc* piPerl, unsigned int s)
+{
+    return win32_sleep(s);
+}
+
+int
+PerlProcTimes(struct IPerlProc* piPerl, struct tms *timebuf)
+{
+    return win32_times(timebuf);
+}
+
+int
+PerlProcWait(struct IPerlProc* piPerl, int *status)
+{
+    return win32_wait(status);
+}
+
+int
+PerlProcWaitpid(struct IPerlProc* piPerl, int pid, int *status, int flags)
+{
+    return win32_waitpid(pid, status, flags);
+}
+
+Sighandler_t
+PerlProcSignal(struct IPerlProc* piPerl, int sig, Sighandler_t subcode)
+{
+    return 0;
+}
+
+static DWORD WINAPI
+win32_start_child(LPVOID arg)
+{
+    PerlInterpreter *my_perl = (PerlInterpreter*)arg;
+    GV *tmpgv;
+    int status;
+#ifdef PERL_OBJECT
+    CPerlObj *pPerl = (CPerlObj*)my_perl;
+#endif
+#ifdef PERL_SYNC_FORK
+    static long sync_fork_id = 0;
+    long id = ++sync_fork_id;
+#endif
+
+
+    PERL_SET_INTERP(my_perl);
+
+    /* set $$ to pseudo id */
+#ifdef PERL_SYNC_FORK
+    w32_pseudo_id = id;
+#else
+    w32_pseudo_id = GetCurrentThreadId();
+#endif
+    if (tmpgv = gv_fetchpv("$", TRUE, SVt_PV))
+	sv_setiv(GvSV(tmpgv), -(IV)w32_pseudo_id);
+    hv_clear(PL_pidstatus);
+
+    /* push a zero on the stack (we are the child) */
+    {
+	djSP;
+	dTARGET;
+	PUSHi(0);
+	PUTBACK;
+    }
+
+    /* continue from next op */
+    PL_op = PL_op->op_next;
+
+    {
+	dJMPENV;
+	volatile oldscope = PL_scopestack_ix;
+
+restart:
+	JMPENV_PUSH(status);
+	switch (status) {
+	case 0:
+	    CALLRUNOPS(aTHX);
+	    status = 0;
+	    break;
+	case 2:
+	    while (PL_scopestack_ix > oldscope)
+		LEAVE;
+	    FREETMPS;
+	    PL_curstash = PL_defstash;
+	    if (PL_endav && !PL_minus_c)
+		call_list(oldscope, PL_endav);
+	    status = STATUS_NATIVE_EXPORT;
+	    break;
+	case 3:
+	    if (PL_restartop) {
+		POPSTACK_TO(PL_mainstack);
+		PL_op = PL_restartop;
+		PL_restartop = Nullop;
+		goto restart;
+	    }
+	    PerlIO_printf(Perl_error_log, "panic: restartop\n");
+	    FREETMPS;
+	    status = 1;
+	    break;
+	}
+	JMPENV_POP;
+
+	/* XXX hack to avoid perl_destruct() freeing optree */
+	PL_main_root = Nullop;
+    }
+
+    /* destroy everything (waits for any pseudo-forked children) */
+    perl_destruct(my_perl);
+    perl_free(my_perl);
+
+#ifdef PERL_SYNC_FORK
+    return id;
+#else
+    return (DWORD)status;
+#endif
+}
+
+int
+PerlProcFork(struct IPerlProc* piPerl)
+{
+    dTHXo;
+    DWORD id;
+    HANDLE handle;
+    CPerlHost *h = new CPerlHost();
+    PerlInterpreter *new_perl = perl_clone_using((PerlInterpreter*)aTHXo, 1,
+						 h->m_pHostperlMem,
+						 h->m_pHostperlMemShared,
+						 h->m_pHostperlMemParse,
+						 h->m_pHostperlEnv,
+						 h->m_pHostperlStdIO,
+						 h->m_pHostperlLIO,
+						 h->m_pHostperlDir,
+						 h->m_pHostperlSock,
+						 h->m_pHostperlProc
+						 );
+#ifdef PERL_SYNC_FORK
+    id = win32_start_child((LPVOID)new_perl);
+    PERL_SET_INTERP(aTHXo);
+#else
+    handle = CreateThread(NULL, 0, win32_start_child,
+			  (LPVOID)new_perl, 0, &id);
+    PERL_SET_INTERP(aTHXo);
+    if (!handle)
+	Perl_croak(aTHX_ "panic: pseudo fork() failed");
+    w32_pseudo_child_handles[w32_num_pseudo_children] = handle;
+    w32_pseudo_child_pids[w32_num_pseudo_children] = id;
+    ++w32_num_pseudo_children;
+#endif
+    return -(int)id;
+}
+
+int
+PerlProcGetpid(struct IPerlProc* piPerl)
+{
+    return win32_getpid();
+}
+
+void*
+PerlProcDynaLoader(struct IPerlProc* piPerl, const char* filename)
+{
+    return win32_dynaload(filename);
+}
+
+void
+PerlProcGetOSError(struct IPerlProc* piPerl, SV* sv, DWORD dwErr)
+{
+    win32_str_os_error(sv, dwErr);
+}
+
+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 win32_spawnvp(mode, cmdname, 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_pvDir = new VDir();
+    m_pVMem = new VMem();
+    m_pVMemShared = new VMem();
+    m_pVMemParse =  new VMem();
+
+    m_pvDir->Init(NULL, m_pVMem);
+
+    m_dwEnvCount = 0;
+    m_lppEnvList = NULL;
+
+    CopyMemory(&m_hostperlMem, &perlMem, sizeof(perlMem));
+    CopyMemory(&m_hostperlMemShared, &perlMemShared, sizeof(perlMemShared));
+    CopyMemory(&m_hostperlMemParse, &perlMemParse, sizeof(perlMemParse));
+    CopyMemory(&m_hostperlEnv, &perlEnv, sizeof(perlEnv));
+    CopyMemory(&m_hostperlStdIO, &perlStdIO, sizeof(perlStdIO));
+    CopyMemory(&m_hostperlLIO, &perlLIO, sizeof(perlLIO));
+    CopyMemory(&m_hostperlDir, &perlDir, sizeof(perlDir));
+    CopyMemory(&m_hostperlSock, &perlSock, sizeof(perlSock));
+    CopyMemory(&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_pvDir = new VDir();
+    m_pVMem = new VMem();
+    m_pVMemShared = new VMem();
+    m_pVMemParse =  new VMem();
+
+    m_pvDir->Init(NULL, m_pVMem);
+
+    m_dwEnvCount = 0;
+    m_lppEnvList = NULL;
+
+    CopyMemory(&m_hostperlMem, &perlMem, sizeof(perlMem));
+    CopyMemory(&m_hostperlMemShared, &perlMemShared, sizeof(perlMemShared));
+    CopyMemory(&m_hostperlMemParse, &perlMemParse, sizeof(perlMemParse));
+    CopyMemory(&m_hostperlEnv, &perlEnv, sizeof(perlEnv));
+    CopyMemory(&m_hostperlStdIO, &perlStdIO, sizeof(perlStdIO));
+    CopyMemory(&m_hostperlLIO, &perlLIO, sizeof(perlLIO));
+    CopyMemory(&m_hostperlDir, &perlDir, sizeof(perlDir));
+    CopyMemory(&m_hostperlSock, &perlSock, sizeof(perlSock));
+    CopyMemory(&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(CPerlHost& host)
+{
+    m_pVMem = new VMem();
+    m_pVMemShared = host.GetMemShared();
+    m_pVMemParse =  host.GetMemParse();
+
+    /* duplicate directory info */
+    m_pvDir = new VDir();
+    m_pvDir->Init(host.GetDir(), m_pVMem);
+
+    CopyMemory(&m_hostperlMem, &perlMem, sizeof(perlMem));
+    CopyMemory(&m_hostperlMemShared, &perlMemShared, sizeof(perlMemShared));
+    CopyMemory(&m_hostperlMemParse, &perlMemParse, sizeof(perlMemParse));
+    CopyMemory(&m_hostperlEnv, &perlEnv, sizeof(perlEnv));
+    CopyMemory(&m_hostperlStdIO, &perlStdIO, sizeof(perlStdIO));
+    CopyMemory(&m_hostperlLIO, &perlLIO, sizeof(perlLIO));
+    CopyMemory(&m_hostperlDir, &perlDir, sizeof(perlDir));
+    CopyMemory(&m_hostperlSock, &perlSock, sizeof(perlSock));
+    CopyMemory(&m_hostperlProc, &perlProc, sizeof(perlProc));
+    m_pHostperlMem	    = &host.m_hostperlMem;
+    m_pHostperlMemShared    = &host.m_hostperlMemShared;
+    m_pHostperlMemParse	    = &host.m_hostperlMemParse;
+    m_pHostperlEnv	    = &host.m_hostperlEnv;
+    m_pHostperlStdIO	    = &host.m_hostperlStdIO;
+    m_pHostperlLIO	    = &host.m_hostperlLIO;
+    m_pHostperlDir	    = &host.m_hostperlDir;
+    m_pHostperlSock	    = &host.m_hostperlSock;
+    m_pHostperlProc	    = &host.m_hostperlProc;
+
+    m_dwEnvCount = 0;
+    m_lppEnvList = NULL;
+
+    /* duplicate environment info */
+    LPSTR lpPtr;
+    DWORD dwIndex = 0;
+    while(lpPtr = host.GetIndex(dwIndex))
+	Add(lpPtr);
+}
+
+CPerlHost::~CPerlHost(void)
+{
+//  Reset();
+    delete m_pvDir;
+    m_pVMemParse->Release();
+    m_pVMemShared->Release();
+    m_pVMem->Release();
+}
+
+LPSTR
+CPerlHost::Find(LPCSTR lpStr)
+{
+    LPSTR lpPtr;
+    LPSTR* lppPtr = Lookup(lpStr);
+    if(lppPtr != NULL) {
+	for(lpPtr = *lppPtr; *lpPtr != '\0' && *lpPtr != '='; ++lpPtr)
+	    ;
+
+	if(*lpPtr == '=')
+	    ++lpPtr;
+
+	return lpPtr;
+    }
+    return NULL;
+}
+
+int
+lookup(const void *arg1, const void *arg2)
+{   // Compare strings
+    char*ptr1, *ptr2;
+    char c1,c2;
+
+    ptr1 = *(char**)arg1;
+    ptr2 = *(char**)arg2;
+    for(;;) {
+	c1 = *ptr1++;
+	c2 = *ptr2++;
+	if(c1 == '\0' || c1 == '=') {
+	    if(c2 == '\0' || c2 == '=')
+		break;
+
+	    return -1; // string 1 < string 2
+	}
+	else if(c2 == '\0' || c2 == '=')
+	    return 1; // string 1 > string 2
+	else if(c1 != c2) {
+	    c1 = toupper(c1);
+	    c2 = toupper(c2);
+	    if(c1 != c2) {
+		if(c1 < c2)
+		    return -1; // string 1 < string 2
+
+		return 1; // string 1 > string 2
+	    }
+	}
+    }
+    return 0;
+}
+
+LPSTR*
+CPerlHost::Lookup(LPCSTR lpStr)
+{
+    return (LPSTR*)bsearch(&lpStr, m_lppEnvList, m_dwEnvCount, sizeof(LPSTR), lookup);
+}
+
+int
+compare(const void *arg1, const void *arg2)
+{   // Compare strings
+    char*ptr1, *ptr2;
+    char c1,c2;
+
+    ptr1 = *(char**)arg1;
+    ptr2 = *(char**)arg2;
+    for(;;) {
+	c1 = *ptr1++;
+	c2 = *ptr2++;
+	if(c1 == '\0' || c1 == '=') {
+	    if(c1 == c2)
+		break;
+
+	    return -1; // string 1 < string 2
+	}
+	else if(c2 == '\0' || c2 == '=')
+	    return 1; // string 1 > string 2
+	else if(c1 != c2) {
+	    c1 = toupper(c1);
+	    c2 = toupper(c2);
+	    if(c1 != c2) {
+		if(c1 < c2)
+		    return -1; // string 1 < string 2
+	    
+		return 1; // string 1 > string 2
+	    }
+	}
+    }
+    return 0;
+}
+
+void
+CPerlHost::Add(LPCSTR lpStr)
+{
+    dTHXo;
+    char szBuffer[1024];
+    LPSTR *lpPtr;
+    int index, length = strlen(lpStr)+1;
+
+    for(index = 0; lpStr[index] != '\0' && lpStr[index] != '='; ++index)
+	szBuffer[index] = lpStr[index];
+
+    szBuffer[index] = '\0';
+
+    // replacing ?
+    lpPtr = Lookup(szBuffer);
+    if(lpPtr != NULL) {
+	Renew(*lpPtr, length, char);
+	strcpy(*lpPtr, lpStr);
+    }
+    else {
+	++m_dwEnvCount;
+	Renew(m_lppEnvList, m_dwEnvCount, LPSTR);
+	New(1, m_lppEnvList[m_dwEnvCount-1], length, char);
+	if(m_lppEnvList[m_dwEnvCount-1] != NULL) {
+	    strcpy(m_lppEnvList[m_dwEnvCount-1], lpStr);
+	    qsort(m_lppEnvList, m_dwEnvCount, sizeof(LPSTR), compare);
+	}
+	else
+	    --m_dwEnvCount;
+    }
+}
+
+DWORD
+CPerlHost::CalculateEnvironmentSpace(void)
+{
+    DWORD index;
+    DWORD dwSize = 0;
+    for(index = 0; index < m_dwEnvCount; ++index)
+	dwSize += strlen(m_lppEnvList[index]) + 1;
+
+    return dwSize;
+}
+
+void
+CPerlHost::FreeLocalEnvironmentStrings(LPSTR lpStr)
+{
+    dTHXo;
+    Safefree(lpStr);
+}
+
+char*
+CPerlHost::GetChildDir(void)
+{
+    dTHXo;
+    int length;
+    char* ptr;
+    New(0, ptr, MAX_PATH+1, char);
+    if(ptr) {
+	m_pvDir->GetCurrentDirectoryA(MAX_PATH+1, ptr);
+	length = strlen(ptr)-1;
+	if(length > 0) {
+	    if((ptr[length] == '\\') || (ptr[length] == '/'))
+		ptr[length] = 0;
+	}
+    }
+    return ptr;
+}
+
+void
+CPerlHost::FreeChildDir(char* pStr)
+{
+    dTHXo;
+    Safefree(pStr);
+}
+
+LPSTR
+CPerlHost::CreateLocalEnvironmentStrings(VDir &vDir)
+{
+    dTHXo;
+    LPSTR lpStr, lpPtr, lpEnvPtr, lpTmp, lpLocalEnv, lpAllocPtr;
+    DWORD dwSize, dwEnvIndex;
+    int nLength, compVal;
+
+    // get the process environment strings
+    lpAllocPtr = lpTmp = (LPSTR)GetEnvironmentStrings();
+
+    // step over current directory stuff
+    while(*lpTmp == '=')
+	lpTmp += strlen(lpTmp) + 1;
+
+    // save the start of the environment strings
+    lpEnvPtr = lpTmp;
+    for(dwSize = 1; *lpTmp != '\0'; lpTmp += strlen(lpTmp) + 1) {
+	// calculate the size of the environment strings
+	dwSize += strlen(lpTmp) + 1;
+    }
+
+    // add the size of current directories
+    dwSize += vDir.CalculateEnvironmentSpace();
+
+    // add the additional space used by changes made to the environment
+    dwSize += CalculateEnvironmentSpace();
+
+    New(1, lpStr, dwSize, char);
+    lpPtr = lpStr;
+    if(lpStr != NULL) {
+	// build the local environment
+	lpStr = vDir.BuildEnvironmentSpace(lpStr);
+
+	dwEnvIndex = 0;
+	lpLocalEnv = GetIndex(dwEnvIndex);
+	while(*lpEnvPtr != '\0') {
+	    if(lpLocalEnv == NULL) {
+		// all environment overrides have been added
+		// so copy string into place
+		strcpy(lpStr, lpEnvPtr);
+		nLength = strlen(lpEnvPtr) + 1;
+		lpStr += nLength;
+		lpEnvPtr += nLength;
+	    }
+	    else {	
+		// determine which string to copy next
+		compVal = compare(&lpEnvPtr, &lpLocalEnv);
+		if(compVal < 0) {
+		    strcpy(lpStr, lpEnvPtr);
+		    nLength = strlen(lpEnvPtr) + 1;
+		    lpStr += nLength;
+		    lpEnvPtr += nLength;
+		}
+		else {
+		    char *ptr = strchr(lpLocalEnv, '=');
+		    if(ptr && ptr[1]) {
+			strcpy(lpStr, lpLocalEnv);
+			lpStr += strlen(lpLocalEnv) + 1;
+		    }
+		    lpLocalEnv = GetIndex(dwEnvIndex);
+		    if(compVal == 0) {
+			// this string was replaced
+			lpEnvPtr += strlen(lpEnvPtr) + 1;
+		    }
+		}
+	    }
+	}
+
+	// add final NULL
+	*lpStr = '\0';
+    }
+
+    // release the process environment strings
+    FreeEnvironmentStrings(lpAllocPtr);
+
+    return lpPtr;
+}
+
+void
+CPerlHost::Reset(void)
+{
+    dTHXo;
+    if(m_lppEnvList != NULL) {
+	for(DWORD index = 0; index < m_dwEnvCount; ++index) {
+	    Safefree(m_lppEnvList[index]);
+	    m_lppEnvList[index] = NULL;
+	}
+    }
+    m_dwEnvCount = 0;
+}
+
+void
+CPerlHost::Clearenv(void)
+{
+    char ch;
+    LPSTR lpPtr, lpStr, lpEnvPtr;
+    if(m_lppEnvList != NULL) {
+	/* set every entry to an empty string */
+	for(DWORD index = 0; index < m_dwEnvCount; ++index) {
+	    char* ptr = strchr(m_lppEnvList[index], '=');
+	    if(ptr) {
+		*++ptr = 0;
+	    }
+	}
+    }
+
+    /* get the process environment strings */
+    lpStr = lpEnvPtr = (LPSTR)GetEnvironmentStrings();
+
+    /* step over current directory stuff */
+    while(*lpStr == '=')
+	lpStr += strlen(lpStr) + 1;
+
+    while(*lpStr) {
+	lpPtr = strchr(lpStr, '=');
+	if(lpPtr) {
+	    ch = *++lpPtr;
+	    *lpPtr = 0;
+	    Add(lpStr);
+	    *lpPtr = ch;
+	}
+	lpStr += strlen(lpStr) + 1;
+    }
+
+    FreeEnvironmentStrings(lpEnvPtr);
+}
+
+
+char*
+CPerlHost::Getenv(const char *varname)
+{
+    char* pEnv = Find(varname);
+    if(pEnv == NULL) {
+	pEnv = win32_getenv(varname);
+    }
+    else {
+	if(!*pEnv)
+	    pEnv = 0;
+    }
+
+    return pEnv;
+}
+
+int
+CPerlHost::Putenv(const char *envstring)
+{
+    Add(envstring);
+    return 0;
+}
+
+int
+CPerlHost::Chdir(const char *dirname)
+{
+    dTHXo;
+    int ret;
+    if (USING_WIDE()) {
+	WCHAR wBuffer[MAX_PATH];
+	A2WHELPER(dirname, wBuffer, sizeof(wBuffer));
+	ret = m_pvDir->SetCurrentDirectoryW(wBuffer);
+    }
+    else
+	ret = m_pvDir->SetCurrentDirectoryA((char*)dirname);
+    if(ret < 0) {
+	errno = ENOENT;
+    }
+    return ret;
+}
+
+#endif /* ___PerlHost_H___ */
diff --git a/win32/perllib.c b/win32/perllib.c
index 9cd542b9df..717b902e10 100644
--- a/win32/perllib.c
+++ b/win32/perllib.c
@@ -15,7 +15,7 @@
 #ifdef PERL_IMPLICIT_SYS
 #include "win32iop.h"
 #include <fcntl.h>
-#endif
+#endif /* PERL_IMPLICIT_SYS */
 
 
 /* Register any extra external extensions */
@@ -35,1284 +35,13 @@ xs_init(pTHXo)
 }
 
 #ifdef PERL_IMPLICIT_SYS
-/* IPerlMem */
-void*
-PerlMemMalloc(struct IPerlMem *I, size_t size)
-{
-    return win32_malloc(size);
-}
-void*
-PerlMemRealloc(struct IPerlMem *I, void* ptr, size_t size)
-{
-    return win32_realloc(ptr, size);
-}
-void
-PerlMemFree(struct IPerlMem *I, void* ptr)
-{
-    win32_free(ptr);
-}
-
-struct IPerlMem perlMem =
-{
-    PerlMemMalloc,
-    PerlMemRealloc,
-    PerlMemFree,
-};
-
-
-/* IPerlEnv */
-extern char *		g_win32_get_privlib(char *pl);
-extern char *		g_win32_get_sitelib(char *pl);
-
-
-char*
-PerlEnvGetenv(struct IPerlEnv *I, const char *varname)
-{
-    return win32_getenv(varname);
-};
-int
-PerlEnvPutenv(struct IPerlEnv *I, const char *envstring)
-{
-    return win32_putenv(envstring);
-};
-
-char*
-PerlEnvGetenv_len(struct IPerlEnv *I, const char* varname, unsigned long* len)
-{
-    char *e = win32_getenv(varname);
-    if (e)
-	*len = strlen(e);
-    return e;
-}
-
-int
-PerlEnvUname(struct IPerlEnv *I, struct utsname *name)
-{
-    return win32_uname(name);
-}
-
-void
-PerlEnvClearenv(struct IPerlEnv *I)
-{
-    dTHXo;
-    char *envv = GetEnvironmentStrings();
-    char *cur = envv;
-    STRLEN len;
-    while (*cur) {
-	char *end = strchr(cur,'=');
-	if (end && end != cur) {
-	    *end = '\0';
-	    my_setenv(cur,Nullch);
-	    *end = '=';
-	    cur = end + strlen(end+1)+2;
-	}
-	else if ((len = strlen(cur)))
-	    cur += len+1;
-    }
-    FreeEnvironmentStrings(envv);
-}
-
-void*
-PerlEnvGetChildEnv(struct IPerlEnv *I)
-{
-    return NULL;
-}
-
-void
-PerlEnvFreeChildEnv(struct IPerlEnv *I, void* env)
-{
-}
-
-char*
-PerlEnvGetChildDir(struct IPerlEnv *I)
-{
-    return NULL;
-}
-
-void
-PerlEnvFreeChildDir(struct IPerlEnv *I, char* dir)
-{
-}
-
-unsigned long
-PerlEnvOsId(struct IPerlEnv *I)
-{
-    return win32_os_id();
-}
-
-char*
-PerlEnvLibPath(struct IPerlEnv *I, char *pl)
-{
-    return g_win32_get_privlib(pl);
-}
-
-char*
-PerlEnvSiteLibPath(struct IPerlEnv *I, char *pl)
-{
-    return g_win32_get_sitelib(pl);
-}
-
-struct IPerlEnv perlEnv = 
-{
-    PerlEnvGetenv,
-    PerlEnvPutenv,
-    PerlEnvGetenv_len,
-    PerlEnvUname,
-    PerlEnvClearenv,
-    PerlEnvGetChildEnv,
-    PerlEnvFreeChildEnv,
-    PerlEnvGetChildDir,
-    PerlEnvFreeChildDir,
-    PerlEnvOsId,
-    PerlEnvLibPath,
-    PerlEnvSiteLibPath,
-};
-
-
-/* PerlStdIO */
-PerlIO*
-PerlStdIOStdin(struct IPerlStdIO *I)
-{
-    return (PerlIO*)win32_stdin();
-}
-
-PerlIO*
-PerlStdIOStdout(struct IPerlStdIO *I)
-{
-    return (PerlIO*)win32_stdout();
-}
-
-PerlIO*
-PerlStdIOStderr(struct IPerlStdIO *I)
-{
-    return (PerlIO*)win32_stderr();
-}
-
-PerlIO*
-PerlStdIOOpen(struct IPerlStdIO *I, const char *path, const char *mode)
-{
-    return (PerlIO*)win32_fopen(path, mode);
-}
-
-int
-PerlStdIOClose(struct IPerlStdIO *I, PerlIO* pf)
-{
-    return win32_fclose(((FILE*)pf));
-}
-
-int
-PerlStdIOEof(struct IPerlStdIO *I, PerlIO* pf)
-{
-    return win32_feof((FILE*)pf);
-}
-
-int
-PerlStdIOError(struct IPerlStdIO *I, PerlIO* pf)
-{
-    return win32_ferror((FILE*)pf);
-}
-
-void
-PerlStdIOClearerr(struct IPerlStdIO *I, PerlIO* pf)
-{
-    win32_clearerr((FILE*)pf);
-}
-
-int
-PerlStdIOGetc(struct IPerlStdIO *I, PerlIO* pf)
-{
-    return win32_getc((FILE*)pf);
-}
-
-char*
-PerlStdIOGetBase(struct IPerlStdIO *I, PerlIO* pf)
-{
-#ifdef FILE_base
-    FILE *f = (FILE*)pf;
-    return FILE_base(f);
-#else
-    return Nullch;
-#endif
-}
-
-int
-PerlStdIOGetBufsiz(struct IPerlStdIO *I, PerlIO* pf)
-{
-#ifdef FILE_bufsiz
-    FILE *f = (FILE*)pf;
-    return FILE_bufsiz(f);
-#else
-    return (-1);
-#endif
-}
-
-int
-PerlStdIOGetCnt(struct IPerlStdIO *I, PerlIO* pf)
-{
-#ifdef USE_STDIO_PTR
-    FILE *f = (FILE*)pf;
-    return FILE_cnt(f);
-#else
-    return (-1);
-#endif
-}
-
-char*
-PerlStdIOGetPtr(struct IPerlStdIO *I, PerlIO* pf)
-{
-#ifdef USE_STDIO_PTR
-    FILE *f = (FILE*)pf;
-    return FILE_ptr(f);
-#else
-    return Nullch;
-#endif
-}
-
-char*
-PerlStdIOGets(struct IPerlStdIO *I, PerlIO* pf, char* s, int n)
-{
-    return win32_fgets(s, n, (FILE*)pf);
-}
-
-int
-PerlStdIOPutc(struct IPerlStdIO *I, PerlIO* pf, int c)
-{
-    return win32_fputc(c, (FILE*)pf);
-}
-
-int
-PerlStdIOPuts(struct IPerlStdIO *I, PerlIO* pf, const char *s)
-{
-    return win32_fputs(s, (FILE*)pf);
-}
-
-int
-PerlStdIOFlush(struct IPerlStdIO *I, PerlIO* pf)
-{
-    return win32_fflush((FILE*)pf);
-}
-
-int
-PerlStdIOUngetc(struct IPerlStdIO *I, PerlIO* pf,int c)
-{
-    return win32_ungetc(c, (FILE*)pf);
-}
-
-int
-PerlStdIOFileno(struct IPerlStdIO *I, PerlIO* pf)
-{
-    return win32_fileno((FILE*)pf);
-}
-
-PerlIO*
-PerlStdIOFdopen(struct IPerlStdIO *I, int fd, const char *mode)
-{
-    return (PerlIO*)win32_fdopen(fd, mode);
-}
-
-PerlIO*
-PerlStdIOReopen(struct IPerlStdIO *I, const char*path, const char*mode, PerlIO* pf)
-{
-    return (PerlIO*)win32_freopen(path, mode, (FILE*)pf);
-}
-
-SSize_t
-PerlStdIORead(struct IPerlStdIO *I, PerlIO* pf, void *buffer, Size_t size)
-{
-    return win32_fread(buffer, 1, size, (FILE*)pf);
-}
-
-SSize_t
-PerlStdIOWrite(struct IPerlStdIO *I, PerlIO* pf, const void *buffer, Size_t size)
-{
-    return win32_fwrite(buffer, 1, size, (FILE*)pf);
-}
-
-void
-PerlStdIOSetBuf(struct IPerlStdIO *I, PerlIO* pf, char* buffer)
-{
-    win32_setbuf((FILE*)pf, buffer);
-}
-
-int
-PerlStdIOSetVBuf(struct IPerlStdIO *I, PerlIO* pf, char* buffer, int type, Size_t size)
-{
-    return win32_setvbuf((FILE*)pf, buffer, type, size);
-}
-
-void
-PerlStdIOSetCnt(struct IPerlStdIO *I, PerlIO* pf, int n)
-{
-#ifdef STDIO_CNT_LVALUE
-    FILE *f = (FILE*)pf;
-    FILE_cnt(f) = n;
-#endif
-}
-
-void
-PerlStdIOSetPtrCnt(struct IPerlStdIO *I, 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 *I, PerlIO* pf)
-{
-    win32_setvbuf((FILE*)pf, NULL, _IOLBF, 0);
-}
-
-int
-PerlStdIOPrintf(struct IPerlStdIO *I, PerlIO* pf, const char *format,...)
-{
-    va_list(arglist);
-    va_start(arglist, format);
-    return win32_vfprintf((FILE*)pf, format, arglist);
-}
-
-int
-PerlStdIOVprintf(struct IPerlStdIO *I, PerlIO* pf, const char *format, va_list arglist)
-{
-    return win32_vfprintf((FILE*)pf, format, arglist);
-}
-
-long
-PerlStdIOTell(struct IPerlStdIO *I, PerlIO* pf)
-{
-    return win32_ftell((FILE*)pf);
-}
-
-int
-PerlStdIOSeek(struct IPerlStdIO *I, PerlIO* pf, off_t offset, int origin)
-{
-    return win32_fseek((FILE*)pf, offset, origin);
-}
-
-void
-PerlStdIORewind(struct IPerlStdIO *I, PerlIO* pf)
-{
-    win32_rewind((FILE*)pf);
-}
-
-PerlIO*
-PerlStdIOTmpfile(struct IPerlStdIO *I)
-{
-    return (PerlIO*)win32_tmpfile();
-}
-
-int
-PerlStdIOGetpos(struct IPerlStdIO *I, PerlIO* pf, Fpos_t *p)
-{
-    return win32_fgetpos((FILE*)pf, p);
-}
-
-int
-PerlStdIOSetpos(struct IPerlStdIO *I, PerlIO* pf, const Fpos_t *p)
-{
-    return win32_fsetpos((FILE*)pf, p);
-}
-void
-PerlStdIOInit(struct IPerlStdIO *I)
-{
-}
-
-void
-PerlStdIOInitOSExtras(struct IPerlStdIO *I)
-{
-    Perl_init_os_extras();
-}
-
-int
-PerlStdIOOpenOSfhandle(struct IPerlStdIO *I, long osfhandle, int flags)
-{
-    return win32_open_osfhandle(osfhandle, flags);
-}
-
-int
-PerlStdIOGetOSfhandle(struct IPerlStdIO *I, int filenum)
-{
-    return win32_get_osfhandle(filenum);
-}
-
-
-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,
-};
-
-
-/* IPerlLIO */
-int
-PerlLIOAccess(struct IPerlLIO *I, const char *path, int mode)
-{
-    return access(path, mode);
-}
-
-int
-PerlLIOChmod(struct IPerlLIO *I, const char *filename, int pmode)
-{
-    return chmod(filename, pmode);
-}
-
-int
-PerlLIOChown(struct IPerlLIO *I, const char *filename, uid_t owner, gid_t group)
-{
-    return chown(filename, owner, group);
-}
-
-int
-PerlLIOChsize(struct IPerlLIO *I, int handle, long size)
-{
-    return chsize(handle, size);
-}
-
-int
-PerlLIOClose(struct IPerlLIO *I, int handle)
-{
-    return win32_close(handle);
-}
-
-int
-PerlLIODup(struct IPerlLIO *I, int handle)
-{
-    return win32_dup(handle);
-}
-
-int
-PerlLIODup2(struct IPerlLIO *I, int handle1, int handle2)
-{
-    return win32_dup2(handle1, handle2);
-}
-
-int
-PerlLIOFlock(struct IPerlLIO *I, int fd, int oper)
-{
-    return win32_flock(fd, oper);
-}
-
-int
-PerlLIOFileStat(struct IPerlLIO *I, int handle, struct stat *buffer)
-{
-    return fstat(handle, buffer);
-}
-
-int
-PerlLIOIOCtl(struct IPerlLIO *I, int i, unsigned int u, char *data)
-{
-    return win32_ioctlsocket((SOCKET)i, (long)u, (u_long*)data);
-}
-
-int
-PerlLIOIsatty(struct IPerlLIO *I, int fd)
-{
-    return isatty(fd);
-}
-
-int
-PerlLIOLink(struct IPerlLIO *I, const char*oldname, const char *newname)
-{
-    return win32_link(oldname, newname);
-}
-
-long
-PerlLIOLseek(struct IPerlLIO *I, int handle, long offset, int origin)
-{
-    return win32_lseek(handle, offset, origin);
-}
-
-int
-PerlLIOLstat(struct IPerlLIO* p, const char *path, struct stat *buffer)
-{
-    return win32_stat(path, buffer);
-}
-
-char*
-PerlLIOMktemp(struct IPerlLIO *I, char *Template)
-{
-    return mktemp(Template);
-}
-
-int
-PerlLIOOpen(struct IPerlLIO *I, const char *filename, int oflag)
-{
-    return win32_open(filename, oflag);
-}
-
-int
-PerlLIOOpen3(struct IPerlLIO *I, const char *filename, int oflag, int pmode)
-{
-    int ret;
-    if(stricmp(filename, "/dev/null") == 0)
-	ret = open("NUL", oflag, pmode);
-    else
-	ret = open(filename, oflag, pmode);
-
-    return ret;
-}
-
-int
-PerlLIORead(struct IPerlLIO *I, int handle, void *buffer, unsigned int count)
-{
-    return win32_read(handle, buffer, count);
-}
-
-int
-PerlLIORename(struct IPerlLIO *I, const char *OldFileName, const char *newname)
-{
-    return win32_rename(OldFileName, newname);
-}
-
-int
-PerlLIOSetmode(struct IPerlLIO *I, int handle, int mode)
-{
-    return win32_setmode(handle, mode);
-}
-
-int
-PerlLIONameStat(struct IPerlLIO *I, const char *path, struct stat *buffer)
-{
-    return win32_stat(path, buffer);
-}
-
-char*
-PerlLIOTmpnam(struct IPerlLIO *I, char *string)
-{
-    return tmpnam(string);
-}
-
-int
-PerlLIOUmask(struct IPerlLIO *I, int pmode)
-{
-    return umask(pmode);
-}
-
-int
-PerlLIOUnlink(struct IPerlLIO *I, const char *filename)
-{
-    chmod(filename, S_IREAD | S_IWRITE);
-    return unlink(filename);
-}
-
-int
-PerlLIOUtime(struct IPerlLIO *I, char *filename, struct utimbuf *times)
-{
-    return win32_utime(filename, times);
-}
-
-int
-PerlLIOWrite(struct IPerlLIO *I, int handle, const void *buffer, unsigned int count)
-{
-    return win32_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,
-};
-
-/* IPerlDIR */
-int
-PerlDirMakedir(struct IPerlDir *I, const char *dirname, int mode)
-{
-    return win32_mkdir(dirname, mode);
-}
-
-int
-PerlDirChdir(struct IPerlDir *I, const char *dirname)
-{
-    return win32_chdir(dirname);
-}
-
-int
-PerlDirRmdir(struct IPerlDir *I, const char *dirname)
-{
-    return win32_rmdir(dirname);
-}
-
-int
-PerlDirClose(struct IPerlDir *I, DIR *dirp)
-{
-    return win32_closedir(dirp);
-}
-
-DIR*
-PerlDirOpen(struct IPerlDir *I, char *filename)
-{
-    return win32_opendir(filename);
-}
-
-struct direct *
-PerlDirRead(struct IPerlDir *I, DIR *dirp)
-{
-    return win32_readdir(dirp);
-}
-
-void
-PerlDirRewind(struct IPerlDir *I, DIR *dirp)
-{
-    win32_rewinddir(dirp);
-}
-
-void
-PerlDirSeek(struct IPerlDir *I, DIR *dirp, long loc)
-{
-    win32_seekdir(dirp, loc);
-}
-
-long
-PerlDirTell(struct IPerlDir *I, DIR *dirp)
-{
-    return win32_telldir(dirp);
-}
-
-struct IPerlDir perlDir =
-{
-    PerlDirMakedir,
-    PerlDirChdir,
-    PerlDirRmdir,
-    PerlDirClose,
-    PerlDirOpen,
-    PerlDirRead,
-    PerlDirRewind,
-    PerlDirSeek,
-    PerlDirTell,
-};
-
-
-/* IPerlSock */
-u_long
-PerlSockHtonl(struct IPerlSock *I, u_long hostlong)
-{
-    return win32_htonl(hostlong);
-}
-
-u_short
-PerlSockHtons(struct IPerlSock *I, u_short hostshort)
-{
-    return win32_htons(hostshort);
-}
-
-u_long
-PerlSockNtohl(struct IPerlSock *I, u_long netlong)
-{
-    return win32_ntohl(netlong);
-}
-
-u_short
-PerlSockNtohs(struct IPerlSock *I, u_short netshort)
-{
-    return win32_ntohs(netshort);
-}
-
-SOCKET PerlSockAccept(struct IPerlSock *I, SOCKET s, struct sockaddr* addr, int* addrlen)
-{
-    return win32_accept(s, addr, addrlen);
-}
-
-int
-PerlSockBind(struct IPerlSock *I, SOCKET s, const struct sockaddr* name, int namelen)
-{
-    return win32_bind(s, name, namelen);
-}
-
-int
-PerlSockConnect(struct IPerlSock *I, SOCKET s, const struct sockaddr* name, int namelen)
-{
-    return win32_connect(s, name, namelen);
-}
-
-void
-PerlSockEndhostent(struct IPerlSock *I)
-{
-    win32_endhostent();
-}
-
-void
-PerlSockEndnetent(struct IPerlSock *I)
-{
-    win32_endnetent();
-}
-
-void
-PerlSockEndprotoent(struct IPerlSock *I)
-{
-    win32_endprotoent();
-}
-
-void
-PerlSockEndservent(struct IPerlSock *I)
-{
-    win32_endservent();
-}
-
-struct hostent*
-PerlSockGethostbyaddr(struct IPerlSock *I, const char* addr, int len, int type)
-{
-    return win32_gethostbyaddr(addr, len, type);
-}
-
-struct hostent*
-PerlSockGethostbyname(struct IPerlSock *I, const char* name)
-{
-    return win32_gethostbyname(name);
-}
-
-struct hostent*
-PerlSockGethostent(struct IPerlSock *I)
-{
-    dTHXo;
-    Perl_croak(aTHX_ "gethostent not implemented!\n");
-    return NULL;
-}
-
-int
-PerlSockGethostname(struct IPerlSock *I, char* name, int namelen)
-{
-    return win32_gethostname(name, namelen);
-}
-
-struct netent *
-PerlSockGetnetbyaddr(struct IPerlSock *I, long net, int type)
-{
-    return win32_getnetbyaddr(net, type);
-}
-
-struct netent *
-PerlSockGetnetbyname(struct IPerlSock *I, const char *name)
-{
-    return win32_getnetbyname((char*)name);
-}
-
-struct netent *
-PerlSockGetnetent(struct IPerlSock *I)
-{
-    return win32_getnetent();
-}
-
-int PerlSockGetpeername(struct IPerlSock *I, SOCKET s, struct sockaddr* name, int* namelen)
-{
-    return win32_getpeername(s, name, namelen);
-}
-
-struct protoent*
-PerlSockGetprotobyname(struct IPerlSock *I, const char* name)
-{
-    return win32_getprotobyname(name);
-}
-
-struct protoent*
-PerlSockGetprotobynumber(struct IPerlSock *I, int number)
-{
-    return win32_getprotobynumber(number);
-}
-
-struct protoent*
-PerlSockGetprotoent(struct IPerlSock *I)
-{
-    return win32_getprotoent();
-}
-
-struct servent*
-PerlSockGetservbyname(struct IPerlSock *I, const char* name, const char* proto)
-{
-    return win32_getservbyname(name, proto);
-}
-
-struct servent*
-PerlSockGetservbyport(struct IPerlSock *I, int port, const char* proto)
-{
-    return win32_getservbyport(port, proto);
-}
-
-struct servent*
-PerlSockGetservent(struct IPerlSock *I)
-{
-    return win32_getservent();
-}
-
-int
-PerlSockGetsockname(struct IPerlSock *I, SOCKET s, struct sockaddr* name, int* namelen)
-{
-    return win32_getsockname(s, name, namelen);
-}
-
-int
-PerlSockGetsockopt(struct IPerlSock *I, SOCKET s, int level, int optname, char* optval, int* optlen)
-{
-    return win32_getsockopt(s, level, optname, optval, optlen);
-}
-
-unsigned long
-PerlSockInetAddr(struct IPerlSock *I, const char* cp)
-{
-    return win32_inet_addr(cp);
-}
-
-char*
-PerlSockInetNtoa(struct IPerlSock *I, struct in_addr in)
-{
-    return win32_inet_ntoa(in);
-}
-
-int
-PerlSockListen(struct IPerlSock *I, SOCKET s, int backlog)
-{
-    return win32_listen(s, backlog);
-}
-
-int
-PerlSockRecv(struct IPerlSock *I, SOCKET s, char* buffer, int len, int flags)
-{
-    return win32_recv(s, buffer, len, flags);
-}
-
-int
-PerlSockRecvfrom(struct IPerlSock *I, SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen)
-{
-    return win32_recvfrom(s, buffer, len, flags, from, fromlen);
-}
-
-int
-PerlSockSelect(struct IPerlSock *I, int nfds, char* readfds, char* writefds, char* exceptfds, const struct timeval* timeout)
-{
-    return win32_select(nfds, (Perl_fd_set*)readfds, (Perl_fd_set*)writefds, (Perl_fd_set*)exceptfds, timeout);
-}
-
-int
-PerlSockSend(struct IPerlSock *I, SOCKET s, const char* buffer, int len, int flags)
-{
-    return win32_send(s, buffer, len, flags);
-}
-
-int
-PerlSockSendto(struct IPerlSock *I, SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen)
-{
-    return win32_sendto(s, buffer, len, flags, to, tolen);
-}
-
-void
-PerlSockSethostent(struct IPerlSock *I, int stayopen)
-{
-    win32_sethostent(stayopen);
-}
-
-void
-PerlSockSetnetent(struct IPerlSock *I, int stayopen)
-{
-    win32_setnetent(stayopen);
-}
-
-void
-PerlSockSetprotoent(struct IPerlSock *I, int stayopen)
-{
-    win32_setprotoent(stayopen);
-}
-
-void
-PerlSockSetservent(struct IPerlSock *I, int stayopen)
-{
-    win32_setservent(stayopen);
-}
-
-int
-PerlSockSetsockopt(struct IPerlSock *I, SOCKET s, int level, int optname, const char* optval, int optlen)
-{
-    return win32_setsockopt(s, level, optname, optval, optlen);
-}
-
-int
-PerlSockShutdown(struct IPerlSock *I, SOCKET s, int how)
-{
-    return win32_shutdown(s, how);
-}
-
-SOCKET
-PerlSockSocket(struct IPerlSock *I, int af, int type, int protocol)
-{
-    return win32_socket(af, type, protocol);
-}
-
-int
-PerlSockSocketpair(struct IPerlSock *I, int domain, int type, int protocol, int* fds)
-{
-    dTHXo;
-    Perl_croak(aTHX_ "socketpair not implemented!\n");
-    return 0;
-}
-
-int
-PerlSockClosesocket(struct IPerlSock *I, SOCKET s)
-{
-    return win32_closesocket(s);
-}
-
-int
-PerlSockIoctlsocket(struct IPerlSock *I, SOCKET s, long cmd, u_long *argp)
-{
-    return win32_ioctlsocket(s, cmd, argp);
-}
-
-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,
-    PerlSockClosesocket,
-};
-
-
-/* IPerlProc */
-
-#define EXECF_EXEC 1
-#define EXECF_SPAWN 2
-
-extern char *		g_getlogin(void);
-extern int		do_spawn2(char *cmd, int exectype);
-#ifdef PERL_OBJECT
-extern int		g_do_aspawn(void *vreally, void **vmark, void **vsp);
-#define do_aspawn g_do_aspawn
-#endif
-EXTERN_C PerlInterpreter* perl_alloc_using(struct IPerlMem* pMem,
-			struct IPerlEnv* pEnv, struct IPerlStdIO* pStdIO,
-			struct IPerlLIO* pLIO, struct IPerlDir* pDir,
-			struct IPerlSock* pSock, struct IPerlProc* pProc);
-
-void
-PerlProcAbort(struct IPerlProc *I)
-{
-    win32_abort();
-}
-
-char *
-PerlProcCrypt(struct IPerlProc *I, const char* clear, const char* salt)
-{
-    return win32_crypt(clear, salt);
-}
-
-void
-PerlProcExit(struct IPerlProc *I, int status)
-{
-    exit(status);
-}
-
-void
-PerlProc_Exit(struct IPerlProc *I, int status)
-{
-    _exit(status);
-}
-
-int
-PerlProcExecl(struct IPerlProc *I, const char *cmdname, const char *arg0, const char *arg1, const char *arg2, const char *arg3)
-{
-    return execl(cmdname, arg0, arg1, arg2, arg3);
-}
-
-int
-PerlProcExecv(struct IPerlProc *I, const char *cmdname, const char *const *argv)
-{
-    return win32_execvp(cmdname, argv);
-}
-
-int
-PerlProcExecvp(struct IPerlProc *I, const char *cmdname, const char *const *argv)
-{
-    return win32_execvp(cmdname, argv);
-}
-
-uid_t
-PerlProcGetuid(struct IPerlProc *I)
-{
-    return getuid();
-}
-
-uid_t
-PerlProcGeteuid(struct IPerlProc *I)
-{
-    return geteuid();
-}
-
-gid_t
-PerlProcGetgid(struct IPerlProc *I)
-{
-    return getgid();
-}
-
-gid_t
-PerlProcGetegid(struct IPerlProc *I)
-{
-    return getegid();
-}
-
-char *
-PerlProcGetlogin(struct IPerlProc *I)
-{
-    return g_getlogin();
-}
-
-int
-PerlProcKill(struct IPerlProc *I, int pid, int sig)
-{
-    return win32_kill(pid, sig);
-}
-
-int
-PerlProcKillpg(struct IPerlProc *I, int pid, int sig)
-{
-    dTHXo;
-    Perl_croak(aTHX_ "killpg not implemented!\n");
-    return 0;
-}
-
-int
-PerlProcPauseProc(struct IPerlProc *I)
-{
-    return win32_sleep((32767L << 16) + 32767);
-}
-
-PerlIO*
-PerlProcPopen(struct IPerlProc *I, const char *command, const char *mode)
-{
-    dTHXo;
-    PERL_FLUSHALL_FOR_CHILD;
-    return (PerlIO*)win32_popen(command, mode);
-}
-
-int
-PerlProcPclose(struct IPerlProc *I, PerlIO *stream)
-{
-    return win32_pclose((FILE*)stream);
-}
-
-int
-PerlProcPipe(struct IPerlProc *I, int *phandles)
-{
-    return win32_pipe(phandles, 512, O_BINARY);
-}
-
-int
-PerlProcSetuid(struct IPerlProc *I, uid_t u)
-{
-    return setuid(u);
-}
-
-int
-PerlProcSetgid(struct IPerlProc *I, gid_t g)
-{
-    return setgid(g);
-}
-
-int
-PerlProcSleep(struct IPerlProc *I, unsigned int s)
-{
-    return win32_sleep(s);
-}
-
-int
-PerlProcTimes(struct IPerlProc *I, struct tms *timebuf)
-{
-    return win32_times(timebuf);
-}
-
-int
-PerlProcWait(struct IPerlProc *I, int *status)
-{
-    return win32_wait(status);
-}
-
-int
-PerlProcWaitpid(struct IPerlProc *I, int pid, int *status, int flags)
-{
-    return win32_waitpid(pid, status, flags);
-}
-
-Sighandler_t
-PerlProcSignal(struct IPerlProc *I, int sig, Sighandler_t subcode)
-{
-    return 0;
-}
-
-void*
-PerlProcDynaLoader(struct IPerlProc *I, const char* filename)
-{
-    return win32_dynaload(filename);
-}
-
-void
-PerlProcGetOSError(struct IPerlProc *I, SV* sv, DWORD dwErr)
-{
-    win32_str_os_error(sv, dwErr);
-}
-
-BOOL
-PerlProcDoCmd(struct IPerlProc *I, char *cmd)
-{
-    do_spawn2(cmd, EXECF_EXEC);
-    return FALSE;
-}
-
-int
-PerlProcSpawn(struct IPerlProc *I, char* cmds)
-{
-    return do_spawn2(cmds, EXECF_SPAWN);
-}
-
-int
-PerlProcSpawnvp(struct IPerlProc *I, int mode, const char *cmdname, const char *const *argv)
-{
-    return win32_spawnvp(mode, cmdname, argv);
-}
-
-int
-PerlProcASpawn(struct IPerlProc *I, 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,
-    PerlProcDynaLoader,
-    PerlProcGetOSError,
-    PerlProcDoCmd,
-    PerlProcSpawn,
-    PerlProcSpawnvp,
-    PerlProcASpawn,
-};
-
-/*#include "perlhost.h" */
 
+#include "perlhost.h"
 
 EXTERN_C void
 perl_get_host_info(struct IPerlMemInfo* perlMemInfo,
+		   struct IPerlMemInfo* perlMemSharedInfo,
+		   struct IPerlMemInfo* perlMemParseInfo,
 		   struct IPerlEnvInfo* perlEnvInfo,
 		   struct IPerlStdIOInfo* perlStdIOInfo,
 		   struct IPerlLIOInfo* perlLIOInfo,
@@ -1320,31 +49,39 @@ perl_get_host_info(struct IPerlMemInfo* perlMemInfo,
 		   struct IPerlSockInfo* perlSockInfo,
 		   struct IPerlProcInfo* perlProcInfo)
 {
-    if(perlMemInfo) {
+    if (perlMemInfo) {
 	Copy(&perlMem, &perlMemInfo->perlMemList, perlMemInfo->nCount, void*);
 	perlMemInfo->nCount = (sizeof(struct IPerlMem)/sizeof(void*));
     }
-    if(perlEnvInfo) {
+    if (perlMemSharedInfo) {
+	Copy(&perlMem, &perlMemSharedInfo->perlMemList, perlMemSharedInfo->nCount, void*);
+	perlMemSharedInfo->nCount = (sizeof(struct IPerlMem)/sizeof(void*));
+    }
+    if (perlMemParseInfo) {
+	Copy(&perlMem, &perlMemParseInfo->perlMemList, perlMemParseInfo->nCount, void*);
+	perlMemParseInfo->nCount = (sizeof(struct IPerlMem)/sizeof(void*));
+    }
+    if (perlEnvInfo) {
 	Copy(&perlEnv, &perlEnvInfo->perlEnvList, perlEnvInfo->nCount, void*);
 	perlEnvInfo->nCount = (sizeof(struct IPerlEnv)/sizeof(void*));
     }
-    if(perlStdIOInfo) {
+    if (perlStdIOInfo) {
 	Copy(&perlStdIO, &perlStdIOInfo->perlStdIOList, perlStdIOInfo->nCount, void*);
 	perlStdIOInfo->nCount = (sizeof(struct IPerlStdIO)/sizeof(void*));
     }
-    if(perlLIOInfo) {
+    if (perlLIOInfo) {
 	Copy(&perlLIO, &perlLIOInfo->perlLIOList, perlLIOInfo->nCount, void*);
 	perlLIOInfo->nCount = (sizeof(struct IPerlLIO)/sizeof(void*));
     }
-    if(perlDirInfo) {
+    if (perlDirInfo) {
 	Copy(&perlDir, &perlDirInfo->perlDirList, perlDirInfo->nCount, void*);
 	perlDirInfo->nCount = (sizeof(struct IPerlDir)/sizeof(void*));
     }
-    if(perlSockInfo) {
+    if (perlSockInfo) {
 	Copy(&perlSock, &perlSockInfo->perlSockList, perlSockInfo->nCount, void*);
 	perlSockInfo->nCount = (sizeof(struct IPerlSock)/sizeof(void*));
     }
-    if(perlProcInfo) {
+    if (perlProcInfo) {
 	Copy(&perlProc, &perlProcInfo->perlProcList, perlProcInfo->nCount, void*);
 	perlProcInfo->nCount = (sizeof(struct IPerlProc)/sizeof(void*));
     }
@@ -1352,142 +89,173 @@ perl_get_host_info(struct IPerlMemInfo* perlMemInfo,
 
 #ifdef PERL_OBJECT
 
-EXTERN_C PerlInterpreter* perl_alloc_using(struct IPerlMem* pMem,
-			struct IPerlEnv* pEnv, struct IPerlStdIO* pStdIO,
-			struct IPerlLIO* pLIO, struct IPerlDir* pDir,
-			struct IPerlSock* pSock, struct IPerlProc* pProc)
+EXTERN_C PerlInterpreter*
+perl_alloc_override(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)
 {
-    CPerlObj* pPerl = NULL;
+    PerlInterpreter *my_perl = NULL;
     try
     {
-	pPerl = Perl_alloc(pMem, pEnv, pStdIO, pLIO, pDir, pSock, pProc);
+	CPerlHost* pHost = new CPerlHost(ppMem, ppMemShared, ppMemParse, ppEnv,
+					 ppStdIO, ppLIO, ppDir, ppSock, ppProc);
+
+	if (pHost) {
+	    my_perl = perl_alloc_using(pHost->m_pHostperlMem,
+				       pHost->m_pHostperlMemShared,
+				       pHost->m_pHostperlMemParse,
+				       pHost->m_pHostperlEnv,
+				       pHost->m_pHostperlStdIO,
+				       pHost->m_pHostperlLIO,
+				       pHost->m_pHostperlDir,
+				       pHost->m_pHostperlSock,
+				       pHost->m_pHostperlProc);
+	    if (my_perl) {
+		CPerlObj* pPerl = (CPerlObj*)my_perl;
+		w32_internal_host = pHost;
+	    }
+	}
     }
     catch(...)
     {
 	win32_fprintf(stderr, "%s\n", "Error: Unable to allocate memory");
-	pPerl = NULL;
-    }
-    if(pPerl)
-    {
-	SetPerlInterpreter(pPerl);
-	return (PerlInterpreter*)pPerl;
+	my_perl = NULL;
     }
-    SetPerlInterpreter(NULL);
-    return NULL;
+
+    return my_perl;
 }
 
-#undef perl_alloc
-#undef perl_construct
-#undef perl_destruct
-#undef perl_free
-#undef perl_run
-#undef perl_parse
-EXTERN_C PerlInterpreter* perl_alloc(void)
+EXTERN_C PerlInterpreter*
+perl_alloc(void)
 {
-    CPerlObj* pPerl = NULL;
+    PerlInterpreter* my_perl = NULL;
     try
     {
-	pPerl = Perl_alloc(&perlMem, &perlEnv, &perlStdIO, &perlLIO,
-			   &perlDir, &perlSock, &perlProc);
+	CPerlHost* pHost = new CPerlHost();
+	if (pHost) {
+	    my_perl = perl_alloc_using(pHost->m_pHostperlMem,
+				       pHost->m_pHostperlMemShared,
+				       pHost->m_pHostperlMemParse,
+				       pHost->m_pHostperlEnv,
+				       pHost->m_pHostperlStdIO,
+				       pHost->m_pHostperlLIO,
+				       pHost->m_pHostperlDir,
+				       pHost->m_pHostperlSock,
+				       pHost->m_pHostperlProc);
+	    if (my_perl) {
+		CPerlObj* pPerl = (CPerlObj*)my_perl;
+		w32_internal_host = pHost;
+	    }
+	}
     }
     catch(...)
     {
 	win32_fprintf(stderr, "%s\n", "Error: Unable to allocate memory");
-	pPerl = NULL;
-    }
-    if(pPerl)
-    {
-	SetPerlInterpreter(pPerl);
-	return (PerlInterpreter*)pPerl;
+	my_perl = NULL;
     }
-    SetPerlInterpreter(NULL);
-    return NULL;
+
+    return my_perl;
 }
 
-EXTERN_C void perl_construct(PerlInterpreter* sv_interp)
+EXTERN_C void
+perl_construct(PerlInterpreter* my_perl)
 {
-    CPerlObj* pPerl = (CPerlObj*)sv_interp;
+    CPerlObj* pPerl = (CPerlObj*)my_perl;
     try
     {
-	pPerl->perl_construct();
+	Perl_construct();
     }
     catch(...)
     {
 	win32_fprintf(stderr, "%s\n",
 		      "Error: Unable to construct data structures");
-	pPerl->perl_free();
+	CPerlHost* pHost = (CPerlHost*)w32_internal_host;
+	Perl_free();
+	delete pHost;
 	SetPerlInterpreter(NULL);
     }
 }
 
-EXTERN_C void perl_destruct(PerlInterpreter* sv_interp)
+EXTERN_C void
+perl_destruct(PerlInterpreter* my_perl)
 {
-    CPerlObj* pPerl = (CPerlObj*)sv_interp;
+    CPerlObj* pPerl = (CPerlObj*)my_perl;
+#ifdef DEBUGGING
+    Perl_destruct();
+#else
     try
     {
-	pPerl->perl_destruct();
+	Perl_destruct();
     }
     catch(...)
     {
     }
+#endif
 }
 
-EXTERN_C void perl_free(PerlInterpreter* sv_interp)
+EXTERN_C void
+perl_free(PerlInterpreter* my_perl)
 {
-    CPerlObj* pPerl = (CPerlObj*)sv_interp;
+    CPerlObj* pPerl = (CPerlObj*)my_perl;
+#ifdef DEBUGGING
+    CPerlHost* pHost = (CPerlHost*)w32_internal_host;
+    Perl_free();
+    delete pHost;
+#else
     try
     {
-	pPerl->perl_free();
+	CPerlHost* pHost = (CPerlHost*)w32_internal_host;
+	Perl_free();
+	delete pHost;
     }
     catch(...)
     {
     }
+#endif
     SetPerlInterpreter(NULL);
 }
 
-EXTERN_C int perl_run(PerlInterpreter* sv_interp)
+EXTERN_C int
+perl_run(PerlInterpreter* my_perl)
 {
-    CPerlObj* pPerl = (CPerlObj*)sv_interp;
+    CPerlObj* pPerl = (CPerlObj*)my_perl;
+#ifdef DEBUGGING
+    return Perl_run();
+#else
     int retVal;
     try
     {
-	retVal = pPerl->perl_run();
+	retVal = Perl_run();
     }
-/*
-    catch(int x)
-    {
-	// this is where exit() should arrive
-	retVal = x;
-    }
-*/
     catch(...)
     {
 	win32_fprintf(stderr, "Error: Runtime exception\n");
 	retVal = -1;
     }
     return retVal;
+#endif
 }
 
-EXTERN_C int perl_parse(PerlInterpreter* sv_interp, void (*xsinit)(CPerlObj*), int argc, char** argv, char** env)
+EXTERN_C int
+perl_parse(PerlInterpreter* my_perl, void (*xsinit)(CPerlObj*), int argc, char** argv, char** env)
 {
     int retVal;
-    CPerlObj* pPerl = (CPerlObj*)sv_interp;
+    CPerlObj* pPerl = (CPerlObj*)my_perl;
+#ifdef DEBUGGING
+    retVal = Perl_parse(xsinit, argc, argv, env);
+#else
     try
     {
-	retVal = pPerl->perl_parse(xsinit, argc, argv, env);
+	retVal = Perl_parse(xsinit, argc, argv, env);
     }
-/*
-    catch(int x)
-    {
-	// this is where exit() should arrive
-	retVal = x;
-    }
-*/
     catch(...)
     {
 	win32_fprintf(stderr, "Error: Parse exception\n");
 	retVal = -1;
     }
+#endif
     *win32_errno() = 0;
     return retVal;
 }
@@ -1500,15 +268,31 @@ EXTERN_C int perl_parse(PerlInterpreter* sv_interp, void (*xsinit)(CPerlObj*), i
 EXTERN_C PerlInterpreter*
 perl_alloc(void)
 {
-    return perl_alloc_using(&perlMem, &perlEnv, &perlStdIO, &perlLIO,
-			   &perlDir, &perlSock, &perlProc);
+    PerlInterpreter *my_perl = NULL;
+    CPerlHost* pHost = new CPerlHost();
+    if (pHost) {
+	my_perl = perl_alloc_using(pHost->m_pHostperlMem,
+				   pHost->m_pHostperlMemShared,
+				   pHost->m_pHostperlMemParse,
+				   pHost->m_pHostperlEnv,
+				   pHost->m_pHostperlStdIO,
+				   pHost->m_pHostperlLIO,
+				   pHost->m_pHostperlDir,
+				   pHost->m_pHostperlSock,
+				   pHost->m_pHostperlProc);
+	if (my_perl) {
+	    CPerlObj* pPerl = (CPerlObj*)my_perl;
+	    w32_internal_host = pHost;
+	}
+    }
+    return my_perl;
 }
 
 #endif /* PERL_OBJECT */
-
 #endif /* PERL_IMPLICIT_SYS */
 
-extern HANDLE w32_perldll_handle;
+EXTERN_C HANDLE w32_perldll_handle;
+
 static DWORD g_TlsAllocIndex;
 
 EXTERN_C DllExport bool
@@ -1563,9 +347,24 @@ RunPerl(int argc, char **argv, char **env)
 
     exitstatus = perl_parse(my_perl, xs_init, argc, argv, env);
     if (!exitstatus) {
-#ifdef USE_ITHREADS		/* XXXXXX testing */
-	new_perl = perl_clone(my_perl, 0);
-	Perl_push_scope(new_perl); /* ENTER; (hack in lieu of perl_destruct()) */
+#if defined(TOP_CLONE) && defined(USE_ITHREADS)		/* XXXXXX testing */
+#  ifdef PERL_OBJECT
+	CPerlHost *h = new CPerlHost();
+	new_perl = perl_clone_using(my_perl, 1,
+				    h->m_pHostperlMem,
+				    h->m_pHostperlMemShared,
+				    h->m_pHostperlMemParse,
+				    h->m_pHostperlEnv,
+				    h->m_pHostperlStdIO,
+				    h->m_pHostperlLIO,
+				    h->m_pHostperlDir,
+				    h->m_pHostperlSock,
+				    h->m_pHostperlProc
+				    );
+	CPerlObj *pPerl = (CPerlObj*)new_perl;
+#  else
+	new_perl = perl_clone(my_perl, 1);
+#  endif
 	exitstatus = perl_run( new_perl );
 	SetPerlInterpreter(my_perl);
 #else
@@ -1630,4 +429,3 @@ DllMain(HANDLE hModule,		/* DLL module handle */
     }
     return TRUE;
 }
-
diff --git a/win32/vdir.h b/win32/vdir.h
new file mode 100644
index 0000000000..0d21616df1
--- /dev/null
+++ b/win32/vdir.h
@@ -0,0 +1,467 @@
+/* vdir.h
+ *
+ * (c) 1999 Microsoft Corporation. All rights reserved. 
+ * Portions (c) 1999 ActiveState Tool Corp, http://www.ActiveState.com/
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ */
+
+#ifndef ___VDir_H___
+#define ___VDir_H___
+
+const int driveCount = 30;
+
+class VDir
+{
+public:
+    VDir();
+    ~VDir() {};
+
+    void Init(VDir* pDir, VMem *pMem);
+    void SetDefaultA(char const *pDefault);
+    void SetDefaultW(WCHAR const *pDefault);
+    char* MapPathA(const char *pInName);
+    WCHAR* MapPathW(const WCHAR *pInName);
+    int SetCurrentDirectoryA(char *lpBuffer);
+    int SetCurrentDirectoryW(WCHAR *lpBuffer);
+    inline const char *GetDirA(int index)
+    {
+	return dirTableA[index];
+    };
+    inline const WCHAR *GetDirW(int index)
+    {
+	return dirTableW[index];
+    };
+    inline int GetDefault(void) { return nDefault; };
+
+    inline char* GetCurrentDirectoryA(int dwBufSize, char *lpBuffer)
+    {
+	char* ptr = dirTableA[nDefault];
+	while (dwBufSize--)
+	{
+	    if ((*lpBuffer++ = *ptr++) == '\0')
+		break;
+	}
+	return lpBuffer;
+    };
+    inline WCHAR* GetCurrentDirectoryW(int dwBufSize, WCHAR *lpBuffer)
+    {
+	WCHAR* ptr = dirTableW[nDefault];
+	while (dwBufSize--)
+	{
+	    if ((*lpBuffer++ = *ptr++) == '\0')
+		break;
+	}
+	return lpBuffer;
+    };
+
+
+    DWORD CalculateEnvironmentSpace(void);
+    LPSTR BuildEnvironmentSpace(LPSTR lpStr);
+
+protected:
+    int SetDirA(char const *pPath, int index);
+    void FromEnvA(char *pEnv, int index);
+    inline const char *GetDefaultDirA(void)
+    {
+	return dirTableA[nDefault];
+    };
+
+    inline void SetDefaultDirA(char const *pPath, int index)
+    {
+	SetDirA(pPath, index);
+	nDefault = index;
+    };
+    int SetDirW(WCHAR const *pPath, int index);
+    inline const WCHAR *GetDefaultDirW(void)
+    {
+	return dirTableW[nDefault];
+    };
+
+    inline void SetDefaultDirW(WCHAR const *pPath, int index)
+    {
+	SetDirW(pPath, index);
+	nDefault = index;
+    };
+
+    inline int DriveIndex(char chr)
+    {
+	return (chr | 0x20)-'a';
+    };
+
+    VMem *pMem;
+    int nDefault;
+    char *dirTableA[driveCount];
+    char szLocalBufferA[MAX_PATH+1];
+    WCHAR *dirTableW[driveCount];
+    WCHAR szLocalBufferW[MAX_PATH+1];
+};
+
+
+VDir::VDir()
+{
+    nDefault = 0;
+    memset(dirTableA, 0, sizeof(dirTableA));
+    memset(dirTableW, 0, sizeof(dirTableW));
+}
+
+void VDir::Init(VDir* pDir, VMem *p)
+{
+    int index;
+    DWORD driveBits;
+    char szBuffer[MAX_PATH*driveCount];
+
+    pMem = p;
+    if (pDir) {
+	for (index = 0; index < driveCount; ++index) {
+	    SetDirW(pDir->GetDirW(index), index);
+	}
+	nDefault = pDir->GetDefault();
+    }
+    else {
+	driveBits = GetLogicalDrives();
+	if (GetLogicalDriveStrings(sizeof(szBuffer), szBuffer)) {
+	    char* pEnv = GetEnvironmentStrings();
+	    char* ptr = szBuffer;
+	    for (index = 0; index < driveCount; ++index) {
+		if (driveBits & (1<<index)) {
+		    ptr += SetDirA(ptr, index) + 1;
+		    FromEnvA(pEnv, index);
+		}
+	    }
+	    FreeEnvironmentStrings(pEnv);
+	}
+	SetDefaultA(".");
+    }
+}
+
+int VDir::SetDirA(char const *pPath, int index)
+{
+    char chr, *ptr;
+    int length = 0;
+    WCHAR wBuffer[MAX_PATH+1];
+    if (index < driveCount && pPath != NULL) {
+	length = strlen(pPath);
+	pMem->Free(dirTableA[index]);
+	ptr = dirTableA[index] = (char*)pMem->Malloc(length+2);
+	if (ptr != NULL) {
+	    strcpy(ptr, pPath);
+	    ptr += length-1;
+	    chr = *ptr++;
+	    if (chr != '\\' && chr != '/') {
+		*ptr++ = '\\';
+		*ptr = '\0';
+	    }
+	    MultiByteToWideChar(CP_ACP, 0, dirTableA[index], -1,
+		    wBuffer, (sizeof(wBuffer)/sizeof(WCHAR)));
+	    length = wcslen(wBuffer);
+	    pMem->Free(dirTableW[index]);
+	    dirTableW[index] = (WCHAR*)pMem->Malloc((length+1)*2);
+	    if (dirTableW[index] != NULL) {
+		wcscpy(dirTableW[index], wBuffer);
+	    }
+	}
+    }
+    return length;
+}
+
+void VDir::FromEnvA(char *pEnv, int index)
+{   /* gets the directory for index from the environment variable. */
+    while (*pEnv != '\0') {
+	if ((pEnv[0] == '=') && (DriveIndex(pEnv[1]) == index)) {
+	    SetDirA(&pEnv[4], index);
+	    break;
+	}
+	else
+	    pEnv += strlen(pEnv)+1;
+    }
+}
+
+void VDir::SetDefaultA(char const *pDefault)
+{
+    char szBuffer[MAX_PATH+1];
+    char *pPtr;
+
+    if (GetFullPathNameA(pDefault, sizeof(szBuffer), szBuffer, &pPtr)) {
+        if (*pDefault != '.' && pPtr != NULL)
+	    *pPtr = '\0';
+
+	SetDefaultDirA(szBuffer, DriveIndex(szBuffer[0]));
+    }
+}
+
+int VDir::SetDirW(WCHAR const *pPath, int index)
+{
+    WCHAR chr, *ptr;
+    char szBuffer[MAX_PATH+1];
+    int length = 0;
+    if (index < driveCount && pPath != NULL) {
+	length = wcslen(pPath);
+	pMem->Free(dirTableW[index]);
+	ptr = dirTableW[index] = (WCHAR*)pMem->Malloc((length+2)*2);
+	if (ptr != NULL) {
+	    wcscpy(ptr, pPath);
+	    ptr += length-1;
+	    chr = *ptr++;
+	    if (chr != '\\' && chr != '/') {
+		*ptr++ = '\\';
+		*ptr = '\0';
+	    }
+	    WideCharToMultiByte(CP_ACP, 0, dirTableW[index], -1, szBuffer, sizeof(szBuffer), NULL, NULL);
+	    length = strlen(szBuffer);
+	    pMem->Free(dirTableA[index]);
+	    dirTableA[index] = (char*)pMem->Malloc(length+1);
+	    if (dirTableA[index] != NULL) {
+		strcpy(dirTableA[index], szBuffer);
+	    }
+	}
+    }
+    return length;
+}
+
+void VDir::SetDefaultW(WCHAR const *pDefault)
+{
+    WCHAR szBuffer[MAX_PATH+1];
+    WCHAR *pPtr;
+
+    if (GetFullPathNameW(pDefault, (sizeof(szBuffer)/sizeof(WCHAR)), szBuffer, &pPtr)) {
+        if (*pDefault != '.' && pPtr != NULL)
+	    *pPtr = '\0';
+
+	SetDefaultDirW(szBuffer, DriveIndex((char)szBuffer[0]));
+    }
+}
+
+inline BOOL IsPathSep(char ch)
+{
+    return (ch == '\\' || ch == '/');
+}
+
+inline void DoGetFullPathNameA(char* lpBuffer, DWORD dwSize, char* Dest)
+{
+    char *pPtr;
+
+    /*
+     * On WinNT GetFullPathName does not fail, (or at least always
+     * succeeds when the drive is valid) WinNT does set *Dest to Nullch
+     * On Win98 GetFullPathName will set last error if it fails, but
+     * does not touch *Dest
+     */
+    *Dest = '\0';
+    GetFullPathNameA(lpBuffer, dwSize, Dest, &pPtr);
+}
+
+char *VDir::MapPathA(const char *pInName)
+{   /*
+     * possiblities -- relative path or absolute path with or without drive letter
+     * OR UNC name
+     */
+    char szBuffer[(MAX_PATH+1)*2];
+    char szlBuf[MAX_PATH+1];
+
+    if (strlen(pInName) > MAX_PATH) {
+	strncpy(szlBuf, pInName, MAX_PATH);
+	if (IsPathSep(pInName[0]) && !IsPathSep(pInName[1])) {   
+	    /* absolute path - reduce length by 2 for drive specifier */
+	    szlBuf[MAX_PATH-2] = '\0';
+	}
+	else
+	    szlBuf[MAX_PATH] = '\0';
+	pInName = szlBuf;
+    }
+    /* strlen(pInName) is now <= MAX_PATH */
+
+    if (pInName[1] == ':') {
+	/* has drive letter */
+	if (IsPathSep(pInName[2])) {
+	    /* absolute with drive letter */
+	    strcpy(szLocalBufferA, pInName);
+	}
+	else {
+	    /* relative path with drive letter */
+	    strcpy(szBuffer, GetDirA(DriveIndex(*pInName)));
+	    strcat(szBuffer, &pInName[2]);
+	    if(strlen(szBuffer) > MAX_PATH)
+		szBuffer[MAX_PATH] = '\0';
+
+	    DoGetFullPathNameA(szBuffer, sizeof(szLocalBufferA), szLocalBufferA);
+	}
+    }
+    else {
+	/* no drive letter */
+	if (IsPathSep(pInName[1]) && IsPathSep(pInName[0])) {
+	    /* UNC name */
+	    strcpy(szLocalBufferA, pInName);
+	}
+	else {
+	    strcpy(szBuffer, GetDefaultDirA());
+	    if (IsPathSep(pInName[0])) {
+		/* absolute path */
+		szLocalBufferA[0] = szBuffer[0];
+		szLocalBufferA[1] = szBuffer[1];
+		strcpy(&szLocalBufferA[2], pInName);
+	    }
+	    else {
+		/* relative path */
+		strcat(szBuffer, pInName);
+		if (strlen(szBuffer) > MAX_PATH)
+		    szBuffer[MAX_PATH] = '\0';
+
+		DoGetFullPathNameA(szBuffer, sizeof(szLocalBufferA), szLocalBufferA);
+	    }
+	}
+    }
+
+    return szLocalBufferA;
+}
+
+int VDir::SetCurrentDirectoryA(char *lpBuffer)
+{
+    HANDLE hHandle;
+    WIN32_FIND_DATA win32FD;
+    char szBuffer[MAX_PATH+1], *pPtr;
+    int nRet = -1;
+
+    GetFullPathNameA(MapPathA(lpBuffer), sizeof(szBuffer), szBuffer, &pPtr);
+
+    hHandle = FindFirstFile(szBuffer, &win32FD);
+    if (hHandle != INVALID_HANDLE_VALUE) {
+        FindClose(hHandle);
+	SetDefaultDirA(szBuffer, DriveIndex(szBuffer[0]));
+	nRet = 0;
+    }
+    return nRet;
+}
+
+int VDir::SetCurrentDirectoryW(WCHAR *lpBuffer)
+{
+    HANDLE hHandle;
+    WIN32_FIND_DATAW win32FD;
+    WCHAR szBuffer[MAX_PATH+1], *pPtr;
+    int nRet = -1;
+
+    GetFullPathNameW(MapPathW(lpBuffer), (sizeof(szBuffer)/sizeof(WCHAR)), szBuffer, &pPtr);
+
+    hHandle = FindFirstFileW(szBuffer, &win32FD);
+    if (hHandle != INVALID_HANDLE_VALUE) {
+        FindClose(hHandle);
+	SetDefaultDirW(szBuffer, DriveIndex((char)szBuffer[0]));
+	nRet = 0;
+    }
+    return nRet;
+}
+
+DWORD VDir::CalculateEnvironmentSpace(void)
+{   /* the current directory environment strings are stored as '=d=d:\path' */
+    int index;
+    DWORD dwSize = 0;
+    for (index = 0; index < driveCount; ++index) {
+	if (dirTableA[index] != NULL) {
+	    dwSize += strlen(dirTableA[index]) + 4;  /* add 1 for trailing NULL and 3 for '=d=' */
+	}
+    }
+    return dwSize;
+}
+
+LPSTR VDir::BuildEnvironmentSpace(LPSTR lpStr)
+{   /* store the current directory environment strings as '=d=d:\path' */
+    int index;
+    LPSTR lpDirStr;
+    for (index = 0; index < driveCount; ++index) {
+	lpDirStr = dirTableA[index];
+	if (lpDirStr != NULL) {
+	    lpStr[0] = '=';
+	    lpStr[1] = lpDirStr[0];
+	    lpStr[2] = '=';
+	    strcpy(&lpStr[3], lpDirStr);
+	    lpStr += strlen(lpDirStr) + 4; /* add 1 for trailing NULL and 3 for '=d=' */
+	}
+    }
+    return lpStr;
+}
+
+inline BOOL IsPathSep(WCHAR ch)
+{
+    return (ch == '\\' || ch == '/');
+}
+
+inline void DoGetFullPathNameW(WCHAR* lpBuffer, DWORD dwSize, WCHAR* Dest)
+{
+    WCHAR *pPtr;
+
+    /*
+     * On WinNT GetFullPathName does not fail, (or at least always
+     * succeeds when the drive is valid) WinNT does set *Dest to Nullch
+     * On Win98 GetFullPathName will set last error if it fails, but
+     * does not touch *Dest
+     */
+    *Dest = '\0';
+    GetFullPathNameW(lpBuffer, dwSize, Dest, &pPtr);
+}
+
+WCHAR* VDir::MapPathW(const WCHAR *pInName)
+{   /*
+     * possiblities -- relative path or absolute path with or without drive letter
+     * OR UNC name
+     */
+    WCHAR szBuffer[(MAX_PATH+1)*2];
+    WCHAR szlBuf[MAX_PATH+1];
+
+    if (wcslen(pInName) > MAX_PATH) {
+	wcsncpy(szlBuf, pInName, MAX_PATH);
+	if (IsPathSep(pInName[0]) && !IsPathSep(pInName[1])) {   
+	    /* absolute path - reduce length by 2 for drive specifier */
+	    szlBuf[MAX_PATH-2] = '\0';
+	}
+	else
+	    szlBuf[MAX_PATH] = '\0';
+	pInName = szlBuf;
+    }
+    /* strlen(pInName) is now <= MAX_PATH */
+
+    if (pInName[1] == ':') {
+	/* has drive letter */
+	if (IsPathSep(pInName[2])) {
+	    /* absolute with drive letter */
+	    wcscpy(szLocalBufferW, pInName);
+	}
+	else {
+	    /* relative path with drive letter */
+	    wcscpy(szBuffer, GetDirW(DriveIndex((char)*pInName)));
+	    wcscat(szBuffer, &pInName[2]);
+	    if(wcslen(szBuffer) > MAX_PATH)
+		szBuffer[MAX_PATH] = '\0';
+
+	    DoGetFullPathNameW(szBuffer, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW);
+	}
+    }
+    else {
+	/* no drive letter */
+	if (IsPathSep(pInName[1]) && IsPathSep(pInName[0])) {
+	    /* UNC name */
+	    wcscpy(szLocalBufferW, pInName);
+	}
+	else {
+	    wcscpy(szBuffer, GetDefaultDirW());
+	    if (IsPathSep(pInName[0])) {
+		/* absolute path */
+		szLocalBufferW[0] = szBuffer[0];
+		szLocalBufferW[1] = szBuffer[1];
+		wcscpy(&szLocalBufferW[2], pInName);
+	    }
+	    else {
+		/* relative path */
+		wcscat(szBuffer, pInName);
+		if (wcslen(szBuffer) > MAX_PATH)
+		    szBuffer[MAX_PATH] = '\0';
+
+		DoGetFullPathNameW(szBuffer, (sizeof(szLocalBufferW)/sizeof(WCHAR)), szLocalBufferW);
+	    }
+	}
+    }
+    return szLocalBufferW;
+}
+
+
+#endif	/* ___VDir_H___ */
diff --git a/win32/vmem.h b/win32/vmem.h
new file mode 100644
index 0000000000..cf3f502ca0
--- /dev/null
+++ b/win32/vmem.h
@@ -0,0 +1,703 @@
+/* vmem.h
+ *
+ * (c) 1999 Microsoft Corporation. All rights reserved. 
+ * Portions (c) 1999 ActiveState Tool Corp, http://www.ActiveState.com/
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ *
+ *
+ * Knuth's boundary tag algorithm Vol #1, Page 440.
+ *
+ * Each block in the heap has tag words before and after it,
+ *  TAG
+ *  block
+ *  TAG
+ * The size is stored in these tags as a long word, and includes the 8 bytes
+ * of overhead that the boundary tags consume.  Blocks are allocated on long
+ * word boundaries, so the size is always multiples of long words.  When the
+ * block is allocated, bit 0, (the tag bit), of the size is set to 1.  When 
+ * a block is freed, it is merged with adjacent free blocks, and the tag bit
+ * is set to 0.
+ *
+ * A linked list is used to manage the free list. The first two long words of
+ * the block contain double links.  These links are only valid when the block
+ * is freed, therefore space needs to be reserved for them.  Thus, the minimum
+ * block size (not counting the tags) is 8 bytes.
+ *
+ * Since memory allocation may occur on a single threaded, explict locks are
+ * provided.
+ * 
+ */
+
+#ifndef ___VMEM_H_INC___
+#define ___VMEM_H_INC___
+
+const long lAllocStart = 0x00010000; /* start at 64K */
+const long minBlockSize = sizeof(void*)*2;
+const long sizeofTag = sizeof(long);
+const long blockOverhead = sizeofTag*2;
+const long minAllocSize = minBlockSize+blockOverhead;
+
+typedef BYTE* PBLOCK;	/* pointer to a memory block */
+
+/*
+ * Macros for accessing hidden fields in a memory block:
+ *
+ * SIZE	    size of this block (tag bit 0 is 1 if block is allocated)
+ * PSIZE    size of previous physical block
+ */
+
+#define SIZE(block)	(*(ULONG*)(((PBLOCK)(block))-sizeofTag))
+#define PSIZE(block)	(*(ULONG*)(((PBLOCK)(block))-(sizeofTag*2)))
+inline void SetTags(PBLOCK block, long size)
+{
+    SIZE(block) = size;
+    PSIZE(block+(size&~1)) = size;
+}
+
+/*
+ * Free list pointers
+ * PREV	pointer to previous block
+ * NEXT	pointer to next block
+ */
+
+#define PREV(block)	(*(PBLOCK*)(block))
+#define NEXT(block)	(*(PBLOCK*)((block)+sizeof(PBLOCK)))
+inline void SetLink(PBLOCK block, PBLOCK prev, PBLOCK next)
+{
+    PREV(block) = prev;
+    NEXT(block) = next;
+}
+inline void Unlink(PBLOCK p)
+{
+    PBLOCK next = NEXT(p);
+    PBLOCK prev = PREV(p);
+    NEXT(prev) = next;
+    PREV(next) = prev;
+}
+inline void AddToFreeList(PBLOCK block, PBLOCK pInList)
+{
+    PBLOCK next = NEXT(pInList);
+    NEXT(pInList) = block;
+    SetLink(block, pInList, next);
+    PREV(next) = block;
+}
+
+
+/* Macro for rounding up to the next sizeof(long) */
+#define ROUND_UP(n)	(((ULONG)(n)+sizeof(long)-1)&~(sizeof(long)-1))
+#define ROUND_UP64K(n)	(((ULONG)(n)+0x10000-1)&~(0x10000-1))
+#define ROUND_DOWN(n)	((ULONG)(n)&~(sizeof(long)-1))
+
+/*
+ * HeapRec - a list of all non-contiguous heap areas
+ *
+ * Each record in this array contains information about a non-contiguous heap area.
+ */
+
+const int maxHeaps = 64;
+const long lAllocMax   = 0x80000000; /* max size of allocation */
+
+typedef struct _HeapRec
+{
+    PBLOCK	base;	/* base of heap area */
+    ULONG	len;	/* size of heap area */
+} HeapRec;
+
+
+class VMem
+{
+public:
+    VMem();
+    ~VMem();
+    virtual void* Malloc(size_t size);
+    virtual void* Realloc(void* pMem, size_t size);
+    virtual void Free(void* pMem);
+    virtual void GetLock(void);
+    virtual void FreeLock(void);
+    virtual int IsLocked(void);
+    virtual long Release(void);
+    virtual long AddRef(void);
+
+    inline BOOL CreateOk(void)
+    {
+	return m_hHeap != NULL;
+    };
+
+    void ReInit(void);
+
+protected:
+    void Init(void);
+    int Getmem(size_t size);
+    int HeapAdd(void* ptr, size_t size);
+    void* Expand(void* block, size_t size);
+    void WalkHeap(void);
+
+    HANDLE		m_hHeap;		    // memory heap for this script
+    char		m_FreeDummy[minAllocSize];  // dummy free block
+    PBLOCK		m_pFreeList;		    // pointer to first block on free list
+    PBLOCK		m_pRover;		    // roving pointer into the free list
+    HeapRec		m_heaps[maxHeaps];	    // list of all non-contiguous heap areas 
+    int			m_nHeaps;		    // no. of heaps in m_heaps 
+    long		m_lAllocSize;		    // current alloc size
+    long		m_lRefCount;		    // number of current users
+    CRITICAL_SECTION	m_cs;			    // access lock
+};
+
+// #define _DEBUG_MEM
+#ifdef _DEBUG_MEM
+#define ASSERT(f) if(!(f)) DebugBreak();
+
+inline void MEMODS(char *str)
+{
+    OutputDebugString(str);
+    OutputDebugString("\n");
+}
+
+inline void MEMODSlx(char *str, long x)
+{
+    char szBuffer[512];	
+    sprintf(szBuffer, "%s %lx\n", str, x);
+    OutputDebugString(szBuffer);
+}
+
+#define WALKHEAP() WalkHeap()
+#define WALKHEAPTRACE() m_pRover = NULL; WalkHeap()
+
+#else
+
+#define ASSERT(f)
+#define MEMODS(x)
+#define MEMODSlx(x, y)
+#define WALKHEAP()
+#define WALKHEAPTRACE()
+
+#endif
+
+
+VMem::VMem()
+{
+    m_lRefCount = 1;
+    BOOL bRet = (NULL != (m_hHeap = HeapCreate(HEAP_NO_SERIALIZE,
+				lAllocStart,	/* initial size of heap */
+				0)));		/* no upper limit on size of heap */
+    ASSERT(bRet);
+
+    InitializeCriticalSection(&m_cs);
+
+    Init();
+}
+
+VMem::~VMem(void)
+{
+    ASSERT(HeapValidate(m_hHeap, HEAP_NO_SERIALIZE, NULL));
+    WALKHEAPTRACE();
+    DeleteCriticalSection(&m_cs);
+    BOOL bRet = HeapDestroy(m_hHeap);
+    ASSERT(bRet);
+}
+
+void VMem::ReInit(void)
+{
+    for(int index = 0; index < m_nHeaps; ++index)
+	HeapFree(m_hHeap, HEAP_NO_SERIALIZE, m_heaps[index].base);
+
+    Init();
+}
+
+void VMem::Init(void)
+{   /*
+     * Initialize the free list by placing a dummy zero-length block on it.
+     * Set the number of non-contiguous heaps to zero.
+     */
+    m_pFreeList = m_pRover = (PBLOCK)(&m_FreeDummy[minBlockSize]);
+    PSIZE(m_pFreeList) = SIZE(m_pFreeList) = 0;
+    PREV(m_pFreeList) = NEXT(m_pFreeList) = m_pFreeList;
+
+    m_nHeaps = 0;
+    m_lAllocSize = lAllocStart;
+}
+
+void* VMem::Malloc(size_t size)
+{
+    WALKHEAP();
+
+    /*
+     * Adjust the real size of the block to be a multiple of sizeof(long), and add
+     * the overhead for the boundary tags.  Disallow negative or zero sizes.
+     */
+    size_t realsize = (size < blockOverhead) ? minAllocSize : (size_t)ROUND_UP(size) + minBlockSize;
+    if((int)realsize < minAllocSize || size == 0)
+	return NULL;
+
+    /*
+     * Start searching the free list at the rover.  If we arrive back at rover without
+     * finding anything, allocate some memory from the heap and try again.
+     */
+    PBLOCK ptr = m_pRover;	/* start searching at rover */
+    int loops = 2;		/* allow two times through the loop  */
+    for(;;) {
+	size_t lsize = SIZE(ptr);
+	ASSERT((lsize&1)==0);
+	/* is block big enough? */
+	if(lsize >= realsize) {	
+	    /* if the remainder is too small, don't bother splitting the block. */
+	    size_t rem = lsize - realsize;
+	    if(rem < minAllocSize) {
+		if(m_pRover == ptr)
+		    m_pRover = NEXT(ptr);
+
+		/* Unlink the block from the free list. */
+		Unlink(ptr);
+	    }
+	    else {
+		/*
+		 * split the block
+		 * The remainder is big enough to split off into a new block.
+		 * Use the end of the block, resize the beginning of the block
+		 * no need to change the free list.
+		 */
+		SetTags(ptr, rem);
+		ptr += SIZE(ptr);
+		lsize = realsize;
+	    }
+	    /* Set the boundary tags to mark it as allocated. */
+	    SetTags(ptr, lsize | 1);
+	    return ((void *)ptr);
+	}
+
+	/*
+	 * This block was unsuitable.  If we've gone through this list once already without
+	 * finding anything, allocate some new memory from the heap and try again.
+	 */
+	ptr = NEXT(ptr);
+	if(ptr == m_pRover) {
+	    if(!(loops-- && Getmem(realsize))) {
+		return NULL;
+	    }
+	    ptr = m_pRover;
+	}
+    }
+}
+
+void* VMem::Realloc(void* block, size_t size)
+{
+    WALKHEAP();
+
+    /* if size is zero, free the block. */
+    if(size == 0) {
+	Free(block);
+	return (NULL);
+    }
+
+    /* if block pointer is NULL, do a Malloc(). */
+    if(block == NULL)
+	return Malloc(size);
+
+    /*
+     * Grow or shrink the block in place.
+     * if the block grows then the next block will be used if free
+     */
+    if(Expand(block, size) != NULL)
+	return block;
+
+    /*
+     * adjust the real size of the block to be a multiple of sizeof(long), and add the
+     * overhead for the boundary tags.  Disallow negative or zero sizes.
+     */
+    size_t realsize = (size < blockOverhead) ? minAllocSize : (size_t)ROUND_UP(size) + minBlockSize;
+    if((int)realsize < minAllocSize)
+	return NULL;
+
+    /*
+     * see if the previous block is free, and is it big enough to cover the new size
+     * if merged with the current block.
+     */
+    PBLOCK ptr = (PBLOCK)block;
+    size_t cursize = SIZE(ptr) & ~1;
+    size_t psize = PSIZE(ptr);
+    if((psize&1) == 0 && (psize + cursize) >= realsize) {
+	PBLOCK prev = ptr - psize;
+	if(m_pRover == prev)
+	    m_pRover = NEXT(prev);
+
+	/* Unlink the next block from the free list. */
+	Unlink(prev);
+
+	/* Copy contents of old block to new location, make it the current block. */
+	memmove(prev, ptr, cursize);
+	cursize += psize;	/* combine sizes */
+	ptr = prev;
+
+	size_t rem = cursize - realsize;
+	if(rem >= minAllocSize) {
+	    /*
+	     * The remainder is big enough to be a new block.  Set boundary
+	     * tags for the resized block and the new block.
+	     */
+	    prev = ptr + realsize;
+	    /*
+	     * add the new block to the free list.
+	     * next block cannot be free
+	     */
+	    SetTags(prev, rem);
+	    AddToFreeList(prev, m_pFreeList);
+	    cursize = realsize;
+        }
+	/* Set the boundary tags to mark it as allocated. */
+	SetTags(ptr, cursize | 1);
+        return ((void *)ptr);
+    }
+
+    /* Allocate a new block, copy the old to the new, and free the old. */
+    if((ptr = (PBLOCK)Malloc(size)) != NULL) {
+	memmove(ptr, block, cursize-minBlockSize);
+	Free(block);
+    }
+    return ((void *)ptr);
+}
+
+void VMem::Free(void* p)
+{
+    WALKHEAP();
+
+    /* Ignore null pointer. */
+    if(p == NULL)
+	return;
+
+    PBLOCK ptr = (PBLOCK)p;
+
+    /* Check for attempt to free a block that's already free. */
+    size_t size = SIZE(ptr);
+    if((size&1) == 0) {
+	MEMODSlx("Attempt to free previously freed block", (long)p);
+	return;
+    }
+    size &= ~1;	/* remove allocated tag */
+
+    /* if previous block is free, add this block to it. */
+    int linked = FALSE;
+    size_t psize = PSIZE(ptr);
+    if((psize&1) == 0) {
+	ptr -= psize;	/* point to previous block */
+	size += psize;	/* merge the sizes of the two blocks */
+	linked = TRUE;	/* it's already on the free list */
+    }
+
+    /* if the next physical block is free, merge it with this block. */
+    PBLOCK next = ptr + size;	/* point to next physical block */
+    size_t nsize = SIZE(next);
+    if((nsize&1) == 0) {
+	/* block is free move rover if needed */
+	if(m_pRover == next)
+	    m_pRover = NEXT(next);
+
+	/* unlink the next block from the free list. */
+	Unlink(next);
+
+	/* merge the sizes of this block and the next block. */
+	size += nsize;
+    }
+
+    /* Set the boundary tags for the block; */
+    SetTags(ptr, size);
+
+    /* Link the block to the head of the free list. */
+    if(!linked) {
+	AddToFreeList(ptr, m_pFreeList);
+    }
+}
+
+void VMem::GetLock(void)
+{
+    EnterCriticalSection(&m_cs);
+}
+
+void VMem::FreeLock(void)
+{
+    LeaveCriticalSection(&m_cs);
+}
+
+int VMem::IsLocked(void)
+{
+    BOOL bAccessed = TryEnterCriticalSection(&m_cs);
+    if(bAccessed) {
+	LeaveCriticalSection(&m_cs);
+    }
+    return !bAccessed;
+}
+
+
+long VMem::Release(void)
+{
+    long lCount = InterlockedDecrement(&m_lRefCount);
+    if(!lCount)
+	delete this;
+    return lCount;
+}
+
+long VMem::AddRef(void)
+{
+    long lCount = InterlockedIncrement(&m_lRefCount);
+    return lCount;
+}
+
+
+int VMem::Getmem(size_t requestSize)
+{   /* returns -1 is successful 0 if not */
+    void *ptr;
+
+    /* Round up size to next multiple of 64K. */
+    size_t size = (size_t)ROUND_UP64K(requestSize);
+    
+    /*
+     * if the size requested is smaller than our current allocation size
+     * adjust up
+     */
+    if(size < (unsigned long)m_lAllocSize)
+	size = m_lAllocSize;
+
+    /* Update the size to allocate on the next request */
+    if(m_lAllocSize != lAllocMax)
+	m_lAllocSize <<= 1;
+
+    if(m_nHeaps != 0) {
+	/* Expand the last allocated heap */
+	ptr = HeapReAlloc(m_hHeap, HEAP_REALLOC_IN_PLACE_ONLY|HEAP_ZERO_MEMORY|HEAP_NO_SERIALIZE,
+		m_heaps[m_nHeaps-1].base,
+		m_heaps[m_nHeaps-1].len + size);
+	if(ptr != 0) {
+	    HeapAdd(((char*)ptr) + m_heaps[m_nHeaps-1].len, size);
+	    return -1;
+	}
+    }
+
+    /*
+     * if we didn't expand a block to cover the requested size
+     * allocate a new Heap
+     * the size of this block must include the additional dummy tags at either end
+     * the above ROUND_UP64K may not have added any memory to include this.
+     */
+    if(size == requestSize)
+	size = (size_t)ROUND_UP64K(requestSize+(sizeofTag*2));
+
+    ptr = HeapAlloc(m_hHeap, HEAP_ZERO_MEMORY|HEAP_NO_SERIALIZE, size);
+    if(ptr == 0) {
+	MEMODSlx("HeapAlloc failed on size!!!", size);
+	return 0;
+    }
+
+    HeapAdd(ptr, size);
+    return -1;
+}
+
+int VMem::HeapAdd(void *p, size_t size)
+{   /* if the block can be succesfully added to the heap, returns 0; otherwise -1. */
+    int index;
+
+    /* Check size, then round size down to next long word boundary. */
+    if(size < minAllocSize)
+	return -1;
+
+    size = (size_t)ROUND_DOWN(size);
+    PBLOCK ptr = (PBLOCK)p;
+
+    /*
+     * Search for another heap area that's contiguous with the bottom of this new area.
+     * (It should be extremely unusual to find one that's contiguous with the top).
+     */
+    for(index = 0; index < m_nHeaps; ++index) {
+	if(ptr == m_heaps[index].base + (int)m_heaps[index].len) {
+	    /*
+	     * The new block is contiguous with a previously allocated heap area.  Add its
+	     * length to that of the previous heap.  Merge it with the the dummy end-of-heap
+	     * area marker of the previous heap.
+	     */
+	    m_heaps[index].len += size;
+	    break;
+	}
+    }
+
+    if(index == m_nHeaps) {
+	/* The new block is not contiguous.  Add it to the heap list. */
+	if(m_nHeaps == maxHeaps) {
+	    return -1;	/* too many non-contiguous heaps */
+	}
+	m_heaps[m_nHeaps].base = ptr;
+	m_heaps[m_nHeaps].len = size;
+	m_nHeaps++;
+
+	/*
+	 * Reserve the first LONG in the block for the ending boundary tag of a dummy
+	 * block at the start of the heap area.
+	 */
+	size -= minBlockSize;
+	ptr += minBlockSize;
+	PSIZE(ptr) = 1;	/* mark the dummy previous block as allocated */
+    }
+
+    /*
+     * Convert the heap to one large block.  Set up its boundary tags, and those of
+     * marker block after it.  The marker block before the heap will already have
+     * been set up if this heap is not contiguous with the end of another heap.
+     */
+    SetTags(ptr, size | 1);
+    PBLOCK next = ptr + size;	/* point to dummy end block */
+    SIZE(next) = 1;	/* mark the dummy end block as allocated */
+
+    /*
+     * Link the block to the start of the free list by calling free().
+     * This will merge the block with any adjacent free blocks.
+     */
+    Free(ptr);
+    return 0;
+}
+
+
+void* VMem::Expand(void* block, size_t size)
+{
+    /*
+     * Adjust the size of the block to be a multiple of sizeof(long), and add the
+     * overhead for the boundary tags.  Disallow negative or zero sizes.
+     */
+    size_t realsize = (size < blockOverhead) ? minAllocSize : (size_t)ROUND_UP(size) + minBlockSize;
+    if((int)realsize < minAllocSize || size == 0)
+	return NULL;
+
+    PBLOCK ptr = (PBLOCK)block; 
+
+    /* if the current size is the same as requested, do nothing. */
+    size_t cursize = SIZE(ptr) & ~1;
+    if(cursize == realsize) {
+	return block;
+    }
+
+    /* if the block is being shrunk, convert the remainder of the block into a new free block. */
+    if(realsize <= cursize) {
+	size_t nextsize = cursize - realsize;	/* size of new remainder block */
+	if(nextsize >= minAllocSize) {
+	    /*
+	     * Split the block
+	     * Set boundary tags for the resized block and the new block.
+	     */
+	    SetTags(ptr, realsize | 1);
+	    ptr += realsize;
+
+	    /*
+	     * add the new block to the free list.
+	     * call Free to merge this block with next block if free
+	     */
+	    SetTags(ptr, nextsize | 1);
+	    Free(ptr);
+	}
+
+	return block;
+    }
+
+    PBLOCK next = ptr + cursize;
+    size_t nextsize = SIZE(next);
+
+    /* Check the next block for consistency.*/
+    if((nextsize&1) == 0 && (nextsize + cursize) >= realsize) {
+	/*
+	 * The next block is free and big enough.  Add the part that's needed
+	 * to our block, and split the remainder off into a new block.
+	 */
+	if(m_pRover == next)
+	    m_pRover = NEXT(next);
+
+	/* Unlink the next block from the free list. */
+	Unlink(next);
+	cursize += nextsize;	/* combine sizes */
+
+	size_t rem = cursize - realsize;	/* size of remainder */
+	if(rem >= minAllocSize) {
+	    /*
+	     * The remainder is big enough to be a new block.
+	     * Set boundary tags for the resized block and the new block.
+	     */
+	    next = ptr + realsize;
+	    /*
+	     * add the new block to the free list.
+	     * next block cannot be free
+	     */
+	    SetTags(next, rem);
+	    AddToFreeList(next, m_pFreeList);
+	    cursize = realsize;
+        }
+	/* Set the boundary tags to mark it as allocated. */
+	SetTags(ptr, cursize | 1);
+	return ((void *)ptr);
+    }
+    return NULL;
+}
+
+#ifdef _DEBUG_MEM
+#define LOG_FILENAME "P:\\Apps\\Perl\\Result.txt"
+
+void MemoryUsageMessage(char *str, long x, long y, int c)
+{
+    static FILE* fp = NULL;
+    char szBuffer[512];
+    if(str) {
+	if(!fp)
+	    fp = fopen(LOG_FILENAME, "w");
+	sprintf(szBuffer, str, x, y, c);
+	fputs(szBuffer, fp);
+    }
+    else {
+	fflush(fp);
+	fclose(fp);
+    }
+}
+
+void VMem::WalkHeap(void)
+{
+    if(!m_pRover) {
+	MemoryUsageMessage("VMem heaps used %d\n", m_nHeaps, 0, 0);
+    }
+
+    /* Walk all the heaps - verify structures */
+    for(int index = 0; index < m_nHeaps; ++index) {
+	PBLOCK ptr = m_heaps[index].base;
+	size_t size = m_heaps[index].len;
+	ASSERT(HeapValidate(m_hHeap, HEAP_NO_SERIALIZE, p));
+
+	/* set over reserved header block */
+	size -= minBlockSize;
+	ptr += minBlockSize;
+	PBLOCK pLast = ptr + size;
+	ASSERT(PSIZE(ptr) == 1); /* dummy previous block is allocated */
+	ASSERT(SIZE(pLast) == 1); /* dummy next block is allocated */
+	while(ptr < pLast) {
+	    ASSERT(ptr > m_heaps[index].base);
+	    size_t cursize = SIZE(ptr) & ~1;
+	    ASSERT((PSIZE(ptr+cursize) & ~1) == cursize);
+	    if(!m_pRover) {
+		MemoryUsageMessage("Memory Block %08x: Size %08x %c\n", (long)ptr, cursize, (SIZE(p)&1) ? 'x' : ' ');
+	    }
+	    if(!(SIZE(ptr)&1)) {
+		/* this block is on the free list */
+		PBLOCK tmp = NEXT(ptr);
+		while(tmp != ptr) {
+		    ASSERT((SIZE(tmp)&1)==0);
+		    if(tmp == m_pFreeList)
+			break;
+		    ASSERT(NEXT(tmp));
+		    tmp = NEXT(tmp);
+		}
+		if(tmp == ptr) {
+		    MemoryUsageMessage("Memory Block %08x: Size %08x free but not in free list\n", (long)ptr, cursize, 0);
+		}
+	    }
+	    ptr += cursize;
+	}
+    }
+    if(!m_pRover) {
+	MemoryUsageMessage(NULL, 0, 0, 0);
+    }
+}
+#endif
+
+#endif	/* ___VMEM_H_INC___ */
diff --git a/win32/win32.c b/win32/win32.c
index 6566f9a7f4..4c13d4ae1e 100644
--- a/win32/win32.c
+++ b/win32/win32.c
@@ -95,11 +95,20 @@ static char *		get_emd_part(SV **leading, char *trailing, ...);
 static void		remove_dead_process(long deceased);
 static long		find_pid(int pid);
 static char *		qualified_path(const char *cmd);
+#ifdef USE_ITHREADS
+static void		remove_dead_pseudo_process(long child);
+static long		find_pseudo_pid(int pid);
+#endif
 
+START_EXTERN_C
 HANDLE	w32_perldll_handle = INVALID_HANDLE_VALUE;
 char	w32_module_name[MAX_PATH+1];
+END_EXTERN_C
+
 static DWORD	w32_platform = (DWORD)-1;
 
+#define ONE_K_BUFSIZE	1024
+
 int 
 IsWin95(void)
 {
@@ -349,17 +358,17 @@ PerlIO *
 Perl_my_popen(pTHX_ char *cmd, char *mode)
 {
 #ifdef FIXCMD
-#define fixcmd(x)	{					\
-			    char *pspace = strchr((x),' ');	\
-			    if (pspace) {			\
-				char *p = (x);			\
-				while (p < pspace) {		\
-				    if (*p == '/')		\
-					*p = '\\';		\
-				    p++;			\
-				}				\
-			    }					\
-			}
+#define fixcmd(x)   {					\
+			char *pspace = strchr((x),' ');	\
+			if (pspace) {			\
+			    char *p = (x);		\
+			    while (p < pspace) {	\
+				if (*p == '/')		\
+				    *p = '\\';		\
+				p++;			\
+			    }				\
+			}				\
+		    }
 #else
 #define fixcmd(x)
 #endif
@@ -389,6 +398,17 @@ win32_os_id(void)
     return (unsigned long)w32_platform;
 }
 
+DllExport int
+win32_getpid(void)
+{
+#ifdef USE_ITHREADS
+    dTHXo;
+    if (w32_pseudo_id)
+	return -((int)w32_pseudo_id);
+#endif
+    return _getpid();
+}
+
 /* Tokenize a string.  Words are null-separated, and the list
  * ends with a doubled null.  Any character (except null and
  * including backslash) may be escaped by preceding it with a
@@ -685,10 +705,10 @@ win32_opendir(char *filename)
     /* do the FindFirstFile call */
     if (USING_WIDE()) {
 	A2WHELPER(scanname, wbuffer, sizeof(wbuffer));
-	fh = FindFirstFileW(wbuffer, &wFindData);
+	fh = FindFirstFileW(PerlDir_mapW(wbuffer), &wFindData);
     }
     else {
-	fh = FindFirstFileA(scanname, &aFindData);
+	fh = FindFirstFileA(PerlDir_mapA(scanname), &aFindData);
     }
     dirp->handle = fh;
     if (fh == INVALID_HANDLE_VALUE) {
@@ -911,8 +931,8 @@ static long
 find_pid(int pid)
 {
     dTHXo;
-    long child;
-    for (child = 0 ; child < w32_num_children ; ++child) {
+    long child = w32_num_children;
+    while (--child >= 0) {
 	if (w32_child_pids[child] == pid)
 	    return child;
     }
@@ -933,18 +953,72 @@ remove_dead_process(long child)
     }
 }
 
+#ifdef USE_ITHREADS
+static long
+find_pseudo_pid(int pid)
+{
+    dTHXo;
+    long child = w32_num_pseudo_children;
+    while (--child >= 0) {
+	if (w32_pseudo_child_pids[child] == pid)
+	    return child;
+    }
+    return -1;
+}
+
+static void
+remove_dead_pseudo_process(long child)
+{
+    if (child >= 0) {
+	dTHXo;
+	CloseHandle(w32_pseudo_child_handles[child]);
+	Copy(&w32_pseudo_child_handles[child+1], &w32_pseudo_child_handles[child],
+	     (w32_num_pseudo_children-child-1), HANDLE);
+	Copy(&w32_pseudo_child_pids[child+1], &w32_pseudo_child_pids[child],
+	     (w32_num_pseudo_children-child-1), DWORD);
+	w32_num_pseudo_children--;
+    }
+}
+#endif
+
 DllExport int
 win32_kill(int pid, int sig)
 {
+    dTHXo;
     HANDLE hProcess;
-    hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE, pid);
-    if (hProcess && TerminateProcess(hProcess, sig))
-	CloseHandle(hProcess);
-    else {
-	errno = EINVAL;
-	return -1;
+#ifdef USE_ITHREADS
+    if (pid < 0) {
+	/* it is a pseudo-forked child */
+	long child = find_pseudo_pid(-pid);
+	if (child >= 0) {
+	    hProcess = w32_pseudo_child_handles[child];
+	    if (TerminateThread(hProcess, sig)) {
+		remove_dead_pseudo_process(child);
+		return 0;
+	    }
+	}
     }
-    return 0;
+    else
+#endif
+    {
+	long child = find_pid(pid);
+	if (child >= 0) {
+	    hProcess = w32_child_handles[child];
+	    if (TerminateProcess(hProcess, sig)) {
+		remove_dead_process(child);
+		return 0;
+	    }
+	}
+	else {
+	    hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE, pid);
+	    if (hProcess && TerminateProcess(hProcess, sig)) {
+		CloseHandle(hProcess);
+		return 0;
+	    }
+	}
+    }
+    errno = EINVAL;
+    return -1;
 }
 
 /*
@@ -995,9 +1069,11 @@ win32_stat(const char *path, struct stat *buffer)
     /* This also gives us an opportunity to determine the number of links.    */
     if (USING_WIDE()) {
 	A2WHELPER(path, wbuffer, sizeof(wbuffer));
+	wcscpy(wbuffer, PerlDir_mapW(wbuffer));
 	handle = CreateFileW(wbuffer, 0, 0, NULL, OPEN_EXISTING, 0, NULL);
     }
     else {
+	path = PerlDir_mapA(path);
 	handle = CreateFileA(path, 0, 0, NULL, OPEN_EXISTING, 0, NULL);
     }
     if (handle != INVALID_HANDLE_VALUE) {
@@ -1007,10 +1083,13 @@ win32_stat(const char *path, struct stat *buffer)
 	CloseHandle(handle);
     }
 
-    if (USING_WIDE())
+    /* wbuffer or path will be mapped correctly above */
+    if (USING_WIDE()) {
 	res = _wstat(wbuffer, (struct _stat *)buffer);
-    else
+    }
+    else {
 	res = stat(path, buffer);
+    }
     buffer->st_nlink = nlink;
 
     if (res < 0) {
@@ -1213,9 +1292,9 @@ win32_putenv(const char *name)
 	    New(1309,wCuritem,length,WCHAR);
 	    A2WHELPER(name, wCuritem, length*sizeof(WCHAR));
 	    wVal = wcschr(wCuritem, '=');
-	    if(wVal) {
+	    if (wVal) {
 		*wVal++ = '\0';
-		if(SetEnvironmentVariableW(wCuritem, *wVal ? wVal : NULL))
+		if (SetEnvironmentVariableW(wCuritem, *wVal ? wVal : NULL))
 		    relval = 0;
 	    }
 	    Safefree(wCuritem);
@@ -1224,7 +1303,7 @@ win32_putenv(const char *name)
 	    New(1309,curitem,strlen(name)+1,char);
 	    strcpy(curitem, name);
 	    val = strchr(curitem, '=');
-	    if(val) {
+	    if (val) {
 		/* The sane way to deal with the environment.
 		 * Has these advantages over putenv() & co.:
 		 *  * enables us to store a truly empty value in the
@@ -1240,7 +1319,7 @@ win32_putenv(const char *name)
 		 * GSAR 97-06-07
 		 */
 		*val++ = '\0';
-		if(SetEnvironmentVariableA(curitem, *val ? val : NULL))
+		if (SetEnvironmentVariableA(curitem, *val ? val : NULL))
 		    relval = 0;
 	    }
 	    Safefree(curitem);
@@ -1254,11 +1333,11 @@ win32_putenv(const char *name)
 static long
 filetime_to_clock(PFILETIME ft)
 {
- __int64 qw = ft->dwHighDateTime;
- qw <<= 32;
- qw |= ft->dwLowDateTime;
- qw /= 10000;  /* File time ticks at 0.1uS, clock at 1mS */
- return (long) qw;
+    __int64 qw = ft->dwHighDateTime;
+    qw <<= 32;
+    qw |= ft->dwLowDateTime;
+    qw /= 10000;  /* File time ticks at 0.1uS, clock at 1mS */
+    return (long) qw;
 }
 
 DllExport int
@@ -1309,6 +1388,43 @@ filetime_from_time(PFILETIME pFileTime, time_t Time)
 }
 
 DllExport int
+win32_unlink(const char *filename)
+{
+    dTHXo;
+    int ret;
+    DWORD attrs;
+
+    if (USING_WIDE()) {
+	WCHAR wBuffer[MAX_PATH];
+
+	A2WHELPER(filename, wBuffer, sizeof(wBuffer));
+	wcscpy(wBuffer, PerlDir_mapW(wBuffer));
+	attrs = GetFileAttributesW(wBuffer);
+	if (attrs & FILE_ATTRIBUTE_READONLY) {
+	    (void)SetFileAttributesW(wBuffer, attrs & ~FILE_ATTRIBUTE_READONLY);
+	    ret = _wunlink(wBuffer);
+	    if (ret == -1)
+		(void)SetFileAttributesW(wBuffer, attrs);
+	}
+	else
+	    ret = _wunlink(wBuffer);
+    }
+    else {
+	filename = PerlDir_mapA(filename);
+	attrs = GetFileAttributesA(filename);
+	if (attrs & FILE_ATTRIBUTE_READONLY) {
+	    (void)SetFileAttributesA(filename, attrs & ~FILE_ATTRIBUTE_READONLY);
+	    ret = unlink(filename);
+	    if (ret == -1)
+		(void)SetFileAttributesA(filename, attrs);
+	}
+	else
+	    ret = unlink(filename);
+    }
+    return ret;
+}
+
+DllExport int
 win32_utime(const char *filename, struct utimbuf *times)
 {
     dTHXo;
@@ -1322,9 +1438,11 @@ win32_utime(const char *filename, struct utimbuf *times)
     int rc;
     if (USING_WIDE()) {
 	A2WHELPER(filename, wbuffer, sizeof(wbuffer));
+	wcscpy(wbuffer, PerlDir_mapW(wbuffer));
 	rc = _wutime(wbuffer, (struct _utimbuf*)times);
     }
     else {
+	filename = PerlDir_mapA(filename);
 	rc = utime(filename, times);
     }
     /* EACCES: path specifies directory or readonly file */
@@ -1458,8 +1576,27 @@ win32_waitpid(int pid, int *status, int flags)
 {
     dTHXo;
     int retval = -1;
-    if (pid == -1) 
+    if (pid == -1)				/* XXX threadid == 1 ? */
 	return win32_wait(status);
+#ifdef USE_ITHREADS
+    else if (pid < 0) {
+	long child = find_pseudo_pid(-pid);
+	if (child >= 0) {
+	    HANDLE hThread = w32_pseudo_child_handles[child];
+	    DWORD waitcode = WaitForSingleObject(hThread, INFINITE);
+	    if (waitcode != WAIT_FAILED) {
+		if (GetExitCodeThread(hThread, &waitcode)) {
+		    *status = (int)((waitcode & 0xff) << 8);
+		    retval = (int)w32_pseudo_child_pids[child];
+		    remove_dead_pseudo_process(child);
+		    return retval;
+		}
+	    }
+	    else
+		errno = ECHILD;
+	}
+    }
+#endif
     else {
 	long child = find_pid(pid);
 	if (child >= 0) {
@@ -1498,6 +1635,28 @@ win32_wait(int *status)
     int i, retval;
     DWORD exitcode, waitcode;
 
+#ifdef USE_ITHREADS
+    if (w32_num_pseudo_children) {
+	waitcode = WaitForMultipleObjects(w32_num_pseudo_children,
+					  w32_pseudo_child_handles,
+					  FALSE,
+					  INFINITE);
+	if (waitcode != WAIT_FAILED) {
+	    if (waitcode >= WAIT_ABANDONED_0
+		&& waitcode < WAIT_ABANDONED_0 + w32_num_pseudo_children)
+		i = waitcode - WAIT_ABANDONED_0;
+	    else
+		i = waitcode - WAIT_OBJECT_0;
+	    if (GetExitCodeThread(w32_pseudo_child_handles[i], &exitcode)) {
+		*status = (int)((exitcode & 0xff) << 8);
+		retval = (int)w32_pseudo_child_pids[i];
+		remove_dead_pseudo_process(i);
+		return retval;
+	    }
+	}
+    }
+#endif
+
     if (!w32_num_children) {
 	errno = ECHILD;
 	return -1;
@@ -1903,9 +2062,9 @@ win32_fopen(const char *filename, const char *mode)
     if (USING_WIDE()) {
 	A2WHELPER(mode, wMode, sizeof(wMode));
 	A2WHELPER(filename, wBuffer, sizeof(wBuffer));
-	return _wfopen(wBuffer, wMode);
+	return _wfopen(PerlDir_mapW(wBuffer), wMode);
     }
-    return fopen(filename, mode);
+    return fopen(PerlDir_mapA(filename), mode);
 }
 
 #ifndef USE_SOCKETS_AS_HANDLES
@@ -1936,9 +2095,9 @@ win32_freopen(const char *path, const char *mode, FILE *stream)
     if (USING_WIDE()) {
 	A2WHELPER(mode, wMode, sizeof(wMode));
 	A2WHELPER(path, wBuffer, sizeof(wBuffer));
-	return _wfreopen(wBuffer, wMode, stream);
+	return _wfreopen(PerlDir_mapW(wBuffer), wMode, stream);
     }
-    return freopen(path, mode, stream);
+    return freopen(PerlDir_mapA(path), mode, stream);
 }
 
 DllExport int
@@ -2244,7 +2403,8 @@ win32_link(const char *oldname, const char *newname)
 
     if ((A2WHELPER(oldname, wOldName, sizeof(wOldName))) &&
 	(A2WHELPER(newname, wNewName, sizeof(wNewName))) &&
-	pfnCreateHardLinkW(wNewName, wOldName, NULL))
+	(wcscpy(wOldName, PerlDir_mapW(wOldName)),
+	pfnCreateHardLinkW(PerlDir_mapW(wNewName), wOldName, NULL)))
     {
 	return 0;
     }
@@ -2257,6 +2417,7 @@ win32_rename(const char *oname, const char *newname)
 {
     WCHAR wOldName[MAX_PATH];
     WCHAR wNewName[MAX_PATH];
+    char szOldName[MAX_PATH];
     BOOL bResult;
     /* XXX despite what the documentation says about MoveFileEx(),
      * it doesn't work under Windows95!
@@ -2266,11 +2427,13 @@ win32_rename(const char *oname, const char *newname)
 	if (USING_WIDE()) {
 	    A2WHELPER(oname, wOldName, sizeof(wOldName));
 	    A2WHELPER(newname, wNewName, sizeof(wNewName));
-	    bResult = MoveFileExW(wOldName,wNewName,
+	    wcscpy(wOldName, PerlDir_mapW(wOldName));
+	    bResult = MoveFileExW(wOldName,PerlDir_mapW(wNewName),
 			MOVEFILE_COPY_ALLOWED|MOVEFILE_REPLACE_EXISTING);
 	}
 	else {
-	    bResult = MoveFileExA(oname,newname,
+	    strcpy(szOldName, PerlDir_mapA(szOldName));
+	    bResult = MoveFileExA(szOldName,PerlDir_mapA(newname),
 			MOVEFILE_COPY_ALLOWED|MOVEFILE_REPLACE_EXISTING);
 	}
 	if (!bResult) {
@@ -2401,9 +2564,9 @@ win32_open(const char *path, int flag, ...)
 
     if (USING_WIDE()) {
 	A2WHELPER(path, wBuffer, sizeof(wBuffer));
-	return _wopen(wBuffer, flag, pmode);
+	return _wopen(PerlDir_mapW(wBuffer), flag, pmode);
     }
-    return open(path,flag,pmode);
+    return open(PerlDir_mapA(path), flag, pmode);
 }
 
 DllExport int
@@ -2445,21 +2608,64 @@ win32_write(int fd, const void *buf, unsigned int cnt)
 DllExport int
 win32_mkdir(const char *dir, int mode)
 {
-    return mkdir(dir); /* just ignore mode */
+    dTHXo;
+    if (USING_WIDE()) {
+	WCHAR wBuffer[MAX_PATH];
+	A2WHELPER(dir, wBuffer, sizeof(wBuffer));
+	return _wmkdir(PerlDir_mapW(wBuffer));
+    }
+    return mkdir(PerlDir_mapA(dir)); /* just ignore mode */
 }
 
 DllExport int
 win32_rmdir(const char *dir)
 {
-    return rmdir(dir);
+    dTHXo;
+    if (USING_WIDE()) {
+	WCHAR wBuffer[MAX_PATH];
+	A2WHELPER(dir, wBuffer, sizeof(wBuffer));
+	return _wrmdir(PerlDir_mapW(wBuffer));
+    }
+    return rmdir(PerlDir_mapA(dir));
 }
 
 DllExport int
 win32_chdir(const char *dir)
 {
+    dTHXo;
+    if (USING_WIDE()) {
+	WCHAR wBuffer[MAX_PATH];
+	A2WHELPER(dir, wBuffer, sizeof(wBuffer));
+	return _wchdir(wBuffer);
+    }
     return chdir(dir);
 }
 
+DllExport  int
+win32_access(const char *path, int mode)
+{
+    dTHXo;
+    if (USING_WIDE()) {
+	WCHAR wBuffer[MAX_PATH];
+	A2WHELPER(path, wBuffer, sizeof(wBuffer));
+	return _waccess(PerlDir_mapW(wBuffer), mode);
+    }
+    return access(PerlDir_mapA(path), mode);
+}
+
+DllExport  int
+win32_chmod(const char *path, int mode)
+{
+    dTHXo;
+    if (USING_WIDE()) {
+	WCHAR wBuffer[MAX_PATH];
+	A2WHELPER(path, wBuffer, sizeof(wBuffer));
+	return _wchmod(PerlDir_mapW(wBuffer), mode);
+    }
+    return chmod(PerlDir_mapA(path), mode);
+}
+
+
 static char *
 create_command_line(const char* command, const char * const *args)
 {
@@ -2592,12 +2798,28 @@ free_childenv(void* d)
 char*
 get_childdir(void)
 {
-    return NULL;
+    dTHXo;
+    char* ptr;
+    char szfilename[(MAX_PATH+1)*2];
+    if (USING_WIDE()) {
+	WCHAR wfilename[MAX_PATH+1];
+	GetCurrentDirectoryW(MAX_PATH+1, wfilename);
+	W2AHELPER(wfilename, szfilename, sizeof(szfilename));
+    }
+    else {
+	GetCurrentDirectoryA(MAX_PATH+1, szfilename);
+    }
+
+    New(0, ptr, strlen(szfilename)+1, char);
+    strcpy(ptr, szfilename);
+    return ptr;
 }
 
 void
 free_childdir(char* d)
 {
+    dTHXo;
+    Safefree(d);
 }
 
 
@@ -2722,12 +2944,26 @@ RETVAL:
 DllExport int
 win32_execv(const char *cmdname, const char *const *argv)
 {
+#ifdef USE_ITHREADS
+    dTHXo;
+    /* if this is a pseudo-forked child, we just want to spawn
+     * the new program, and return */
+    if (w32_pseudo_id)
+	return spawnv(P_WAIT, cmdname, (char *const *)argv);
+#endif
     return execv(cmdname, (char *const *)argv);
 }
 
 DllExport int
 win32_execvp(const char *cmdname, const char *const *argv)
 {
+#ifdef USE_ITHREADS
+    dTHXo;
+    /* if this is a pseudo-forked child, we just want to spawn
+     * the new program, and return */
+    if (w32_pseudo_id)
+	return win32_spawnvp(P_WAIT, cmdname, (char *const *)argv);
+#endif
     return execvp(cmdname, (char *const *)argv);
 }
 
@@ -2927,44 +3163,14 @@ win32_dynaload(const char* filename)
     if (USING_WIDE()) {
 	WCHAR wfilename[MAX_PATH];
 	A2WHELPER(filename, wfilename, sizeof(wfilename));
-	hModule = LoadLibraryExW(wfilename, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+	hModule = LoadLibraryExW(PerlDir_mapW(wfilename), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
     }
     else {
-	hModule = LoadLibraryExA(filename, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+	hModule = LoadLibraryExA(PerlDir_mapA(filename), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
     }
     return hModule;
 }
 
-DllExport int
-win32_add_host(char *nameId, void *data)
-{
-    /*
-     * This must be called before the script is parsed,
-     * therefore no locking of threads is needed
-     */
-    dTHXo;
-    struct host_link *link;
-    New(1314, link, 1, struct host_link);
-    link->host_data = data;
-    link->nameId = nameId;
-    link->next = w32_host_link;
-    w32_host_link = link;
-    return 1;
-}
-
-DllExport void *
-win32_get_host_data(char *nameId)
-{
-    dTHXo;
-    struct host_link *link = w32_host_link;
-    while(link) {
-	if(strEQ(link->nameId, nameId))
-	    return link->host_data;
-	link = link->next;
-    }
-    return Nullch;
-}
-
 /*
  * Extras.
  */
@@ -2973,19 +3179,19 @@ static
 XS(w32_GetCwd)
 {
     dXSARGS;
-    SV *sv = sv_newmortal();
-    /* Make one call with zero size - return value is required size */
-    DWORD len = GetCurrentDirectory((DWORD)0,NULL);
-    SvUPGRADE(sv,SVt_PV);
-    SvGROW(sv,len);
-    SvCUR(sv) = GetCurrentDirectory((DWORD) SvLEN(sv), SvPVX(sv));
+    /* Make the host for current directory */
+    char* ptr = PerlEnv_get_childdir();
     /* 
-     * If result != 0 
+     * If ptr != Nullch 
      *   then it worked, set PV valid, 
-     *   else leave it 'undef' 
+     *   else return 'undef' 
      */
-    EXTEND(SP,1);
-    if (SvCUR(sv)) {
+    if (ptr) {
+	SV *sv = sv_newmortal();
+	sv_setpv(sv, ptr);
+	PerlEnv_free_childdir(ptr);
+
+	EXTEND(SP,1);
 	SvPOK_on(sv);
 	ST(0) = sv;
 	XSRETURN(1);
@@ -2999,7 +3205,7 @@ XS(w32_SetCwd)
     dXSARGS;
     if (items != 1)
 	Perl_croak(aTHX_ "usage: Win32::SetCurrentDirectory($cwd)");
-    if (SetCurrentDirectory(SvPV_nolen(ST(0))))
+    if (!PerlDir_chdir(SvPV_nolen(ST(0))))
 	XSRETURN_YES;
 
     XSRETURN_NO;
@@ -3122,7 +3328,7 @@ XS(w32_DomainName)
 	if (hNetApi32)
 	    FreeLibrary(hNetApi32);
 	if (GetUserName(name,&size)) {
-	    char sid[1024];
+	    char sid[ONE_K_BUFSIZE];
 	    DWORD sidlen = sizeof(sid);
 	    char dname[256];
 	    DWORD dnamelen = sizeof(dname);
@@ -3161,19 +3367,34 @@ static
 XS(w32_GetOSVersion)
 {
     dXSARGS;
-    OSVERSIONINFO osver;
+    OSVERSIONINFOA osver;
 
-    osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-    if (GetVersionEx(&osver)) {
+    if (USING_WIDE()) {
+	OSVERSIONINFOW osverw;
+	char szCSDVersion[sizeof(osverw.szCSDVersion)];
+	osverw.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
+	if (!GetVersionExW(&osverw)) {
+	    XSRETURN_EMPTY;
+	}
+	W2AHELPER(osverw.szCSDVersion, szCSDVersion, sizeof(szCSDVersion));
+	XPUSHs(newSVpvn(szCSDVersion, strlen(szCSDVersion)));
+	osver.dwMajorVersion = osverw.dwMajorVersion;
+	osver.dwMinorVersion = osverw.dwMinorVersion;
+	osver.dwBuildNumber = osverw.dwBuildNumber;
+	osver.dwPlatformId = osverw.dwPlatformId;
+    }
+    else {
+	osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
+	if (!GetVersionExA(&osver)) {
+	    XSRETURN_EMPTY;
+	}
 	XPUSHs(newSVpvn(osver.szCSDVersion, strlen(osver.szCSDVersion)));
-	XPUSHs(newSViv(osver.dwMajorVersion));
-	XPUSHs(newSViv(osver.dwMinorVersion));
-	XPUSHs(newSViv(osver.dwBuildNumber));
-	XPUSHs(newSViv(osver.dwPlatformId));
-	PUTBACK;
-	return;
     }
-    XSRETURN_EMPTY;
+    XPUSHs(newSViv(osver.dwMajorVersion));
+    XPUSHs(newSViv(osver.dwMinorVersion));
+    XPUSHs(newSViv(osver.dwBuildNumber));
+    XPUSHs(newSViv(osver.dwPlatformId));
+    PUTBACK;
 }
 
 static
@@ -3197,15 +3418,27 @@ XS(w32_FormatMessage)
 {
     dXSARGS;
     DWORD source = 0;
-    char msgbuf[1024];
+    char msgbuf[ONE_K_BUFSIZE];
 
     if (items != 1)
 	Perl_croak(aTHX_ "usage: Win32::FormatMessage($errno)");
 
-    if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
-		      &source, SvIV(ST(0)), 0,
-		      msgbuf, sizeof(msgbuf)-1, NULL))
-	XSRETURN_PV(msgbuf);
+    if (USING_WIDE()) {
+	WCHAR wmsgbuf[ONE_K_BUFSIZE];
+	if (FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
+			  &source, SvIV(ST(0)), 0,
+			  wmsgbuf, ONE_K_BUFSIZE-1, NULL))
+	{
+	    W2AHELPER(wmsgbuf, msgbuf, sizeof(msgbuf));
+	    XSRETURN_PV(msgbuf);
+	}
+    }
+    else {
+	if (FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM,
+			  &source, SvIV(ST(0)), 0,
+			  msgbuf, sizeof(msgbuf)-1, NULL))
+	    XSRETURN_PV(msgbuf);
+    }
 
     XSRETURN_UNDEF;
 }
@@ -3358,9 +3591,24 @@ static
 XS(w32_CopyFile)
 {
     dXSARGS;
+    BOOL bResult;
     if (items != 3)
 	Perl_croak(aTHX_ "usage: Win32::CopyFile($from, $to, $overwrite)");
-    if (CopyFile(SvPV_nolen(ST(0)), SvPV_nolen(ST(1)), !SvTRUE(ST(2))))
+    if (USING_WIDE()) {
+	WCHAR wSourceFile[MAX_PATH];
+	WCHAR wDestFile[MAX_PATH];
+	A2WHELPER(SvPV_nolen(ST(0)), wSourceFile, sizeof(wSourceFile));
+	wcscpy(wSourceFile, PerlDir_mapW(wSourceFile));
+	A2WHELPER(SvPV_nolen(ST(1)), wDestFile, sizeof(wDestFile));
+	bResult = CopyFileW(wSourceFile, PerlDir_mapW(wDestFile), !SvTRUE(ST(2)));
+    }
+    else {
+	char szSourceFile[MAX_PATH];
+	strcpy(szSourceFile, PerlDir_mapA(SvPV_nolen(ST(0))));
+	bResult = CopyFileA(szSourceFile, PerlDir_mapA(SvPV_nolen(ST(1))), !SvTRUE(ST(2)));
+    }
+
+    if (bResult)
 	XSRETURN_YES;
     XSRETURN_NO;
 }
@@ -3377,6 +3625,12 @@ Perl_init_os_extras(void)
     w32_fdpid = newAV();		/* XXX needs to be in Perl_win32_init()? */
     New(1313, w32_children, 1, child_tab);
     w32_num_children = 0;
+    w32_init_socktype = 0;
+#ifdef USE_ITHREADS
+    w32_pseudo_id = 0;
+    New(1313, w32_pseudo_children, 1, child_tab);
+    w32_num_pseudo_children = 0;
+#endif
 
     /* these names are Activeware compatible */
     newXS("Win32::GetCwd", w32_GetCwd, file);
@@ -3427,21 +3681,6 @@ Perl_win32_init(int *argcp, char ***argvp)
     MALLOC_INIT;
 }
 
-#ifdef USE_ITHREADS
-void
-Perl_sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst)
-{
-    dst->perlshell_tokens	= Nullch;
-    dst->perlshell_vec		= (char**)NULL;
-    dst->perlshell_items	= 0;
-    dst->fdpid			= newAV();
-    New(1313, dst->children, 1, child_tab);
-    dst->children->num		= 0;
-    dst->hostlist		= src->hostlist;	/* XXX */
-    dst->thr_intern.Winit_socktype = src->thr_intern.Winit_socktype;
-}
-#endif
-
 #ifdef USE_BINMODE_SCRIPTS
 
 void
@@ -3466,3 +3705,27 @@ win32_strip_return(SV *sv)
 }
 
 #endif
+
+#ifdef USE_ITHREADS
+
+#  ifdef PERL_OBJECT
+#    undef Perl_sys_intern_dup
+#    define Perl_sys_intern_dup CPerlObj::Perl_sys_intern_dup
+#    define pPerl this
+#  endif
+
+void
+Perl_sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst)
+{
+    dst->perlshell_tokens	= Nullch;
+    dst->perlshell_vec		= (char**)NULL;
+    dst->perlshell_items	= 0;
+    dst->fdpid			= newAV();
+    Newz(1313, dst->children, 1, child_tab);
+    Newz(1313, dst->pseudo_children, 1, child_tab);
+    dst->pseudo_id		= 0;
+    dst->children->num		= 0;
+    dst->thr_intern.Winit_socktype = src->thr_intern.Winit_socktype;
+}
+#endif
+
diff --git a/win32/win32.h b/win32/win32.h
index 9eaf76a2d4..856232ae84 100644
--- a/win32/win32.h
+++ b/win32/win32.h
@@ -378,22 +378,20 @@ struct thread_intern {
 typedef struct {
     long	num;
     DWORD	pids[MAXIMUM_WAIT_OBJECTS];
+    HANDLE	handles[MAXIMUM_WAIT_OBJECTS];
 } child_tab;
 
-struct host_link {
-    char *	nameId;
-    void *	host_data;
-    struct host_link *	next;
-};
-
 struct interp_intern {
     char *	perlshell_tokens;
     char **	perlshell_vec;
     long	perlshell_items;
     struct av *	fdpid;
     child_tab *	children;
-    HANDLE	child_handles[MAXIMUM_WAIT_OBJECTS];
-    struct host_link *	hostlist;
+#ifdef USE_ITHREADS
+    DWORD	pseudo_id;
+    child_tab *	pseudo_children;
+#endif
+    void *	internal_host;
 #ifndef USE_THREADS
     struct thread_intern	thr_intern;
 #endif
@@ -407,8 +405,13 @@ struct interp_intern {
 #define w32_children		(PL_sys_intern.children)
 #define w32_num_children	(w32_children->num)
 #define w32_child_pids		(w32_children->pids)
-#define w32_child_handles	(PL_sys_intern.child_handles)
-#define w32_host_link		(PL_sys_intern.hostlist)
+#define w32_child_handles	(w32_children->handles)
+#define w32_pseudo_id		(PL_sys_intern.pseudo_id)
+#define w32_pseudo_children	(PL_sys_intern.pseudo_children)
+#define w32_num_pseudo_children		(w32_pseudo_children->num)
+#define w32_pseudo_child_pids		(w32_pseudo_children->pids)
+#define w32_pseudo_child_handles	(w32_pseudo_children->handles)
+#define w32_internal_host		(PL_sys_intern.internal_host)
 #ifdef USE_THREADS
 #  define w32_strerror_buffer	(thr->i.Wstrerror_buffer)
 #  define w32_getlogin_buffer	(thr->i.Wgetlogin_buffer)
@@ -435,6 +438,20 @@ struct interp_intern {
 
 #define USING_WIDE()	(PerlEnv_os_id() == VER_PLATFORM_WIN32_NT)
 
+#ifdef USE_ITHREADS
+#  define PERL_WAIT_FOR_CHILDREN \
+    STMT_START {							\
+	if (w32_pseudo_children && w32_num_pseudo_children) {		\
+	    long children = w32_num_pseudo_children;			\
+	    WaitForMultipleObjects(children,				\
+				   w32_pseudo_child_handles,		\
+				   TRUE, INFINITE);			\
+	    while (children)						\
+		CloseHandle(w32_pseudo_child_handles[--children]);	\
+	}								\
+    } STMT_END
+#endif
+
 /*
  * This provides a layer of functions and macros to ensure extensions will
  * get to use the same RTL functions as the core.
diff --git a/win32/win32iop.h b/win32/win32iop.h
index 566ed57d51..d7c2ac4f74 100644
--- a/win32/win32iop.h
+++ b/win32/win32iop.h
@@ -132,6 +132,7 @@ DllExport  int		win32_stat(const char *path, struct stat *buf);
 DllExport  char*	win32_longpath(char *path);
 DllExport  int		win32_ioctl(int i, unsigned int u, char *data);
 DllExport  int          win32_link(const char *oldname, const char *newname);
+DllExport  int		win32_unlink(const char *f);
 DllExport  int		win32_utime(const char *f, struct utimbuf *t);
 DllExport  int		win32_uname(struct utsname *n);
 DllExport  int		win32_wait(int *status);
@@ -139,6 +140,9 @@ DllExport  int		win32_waitpid(int pid, int *status, int flags);
 DllExport  int		win32_kill(int pid, int sig);
 DllExport  unsigned long	win32_os_id(void);
 DllExport  void*	win32_dynaload(const char*filename);
+DllExport  int		win32_access(const char *path, int mode);
+DllExport  int		win32_chmod(const char *path, int mode);
+DllExport  int		win32_getpid(void);
 
 DllExport char *	win32_crypt(const char *txt, const char *salt);
 
@@ -162,6 +166,7 @@ END_EXTERN_C
 #undef times
 #undef alarm
 #undef ioctl
+#undef unlink
 #undef utime
 #undef uname
 #undef wait
@@ -254,6 +259,9 @@ END_EXTERN_C
 #define getchar			win32_getchar
 #undef putchar
 #define putchar			win32_putchar
+#define access(p,m)		win32_access(p,m)
+#define chmod(p,m)		win32_chmod(p,m)
+
 
 #if !defined(MYMALLOC) || !defined(PERL_CORE)
 #undef malloc
@@ -273,6 +281,7 @@ END_EXTERN_C
 #define alarm			win32_alarm
 #define ioctl			win32_ioctl
 #define link			win32_link
+#define unlink			win32_unlink
 #define utime			win32_utime
 #define uname			win32_uname
 #define wait			win32_wait
@@ -286,6 +295,7 @@ END_EXTERN_C
 #define rewinddir		win32_rewinddir
 #define closedir		win32_closedir
 #define os_id			win32_os_id
+#define getpid			win32_getpid
 
 #undef crypt
 #define crypt(t,s)		win32_crypt(t,s)
diff --git a/win32/win32thread.h b/win32/win32thread.h
index 4fa3e2f3bf..d4f8ee409e 100644
--- a/win32/win32thread.h
+++ b/win32/win32thread.h
@@ -1,8 +1,7 @@
 #ifndef _WIN32THREAD_H
 #define _WIN32THREAD_H
 
-#define  WIN32_LEAN_AND_MEAN
-#include <windows.h>
+#include "win32.h"
 
 typedef struct win32_cond { LONG waiters; HANDLE sem; } perl_cond;
 typedef DWORD perl_key;
@@ -193,7 +192,7 @@ END_EXTERN_C
 	if ((WaitForSingleObject((t)->self,INFINITE) == WAIT_FAILED)	\
 	     || (GetExitCodeThread((t)->self,(LPDWORD)(avp)) == 0)	\
 	     || (CloseHandle((t)->self) == 0))				\
-	    Perl_croak(aTHX_ "panic: JOIN");					\
+	    Perl_croak(aTHX_ "panic: JOIN");				\
     } STMT_END
 #endif	/* !USE_RTL_THREAD_API || _MSC_VER */