support PERL_IMPLICIT_SYS with MULTIPLICITY/USE_THREADS on

windows

p4raw-id: //depot/perl@4402

11 files changed, 292 insertions, 237 deletions

diff --git a/XSUB.h b/XSUB.h
index ae746a6925..c2e621cc9a 100644
--- a/XSUB.h
+++ b/XSUB.h
@@ -128,7 +128,7 @@
 #  define aTHX_		aTHX,
 #endif
 
-#if defined(PERL_CAPI)
+#if (defined(PERL_CAPI) || defined(PERL_IMPLICIT_SYS)) && !defined(PERL_CORE)
 #  ifndef NO_XSLOCKS
 #    undef closedir
 #    undef opendir
diff --git a/ext/POSIX/POSIX.xs b/ext/POSIX/POSIX.xs
index 59adb2eecb..dbf2621669 100644
--- a/ext/POSIX/POSIX.xs
+++ b/ext/POSIX/POSIX.xs
@@ -8,7 +8,7 @@
 #define PERLIO_NOT_STDIO 1
 #include "perl.h"
 #include "XSUB.h"
-#if defined(PERL_OBJECT) || defined(PERL_CAPI)
+#if defined(PERL_OBJECT) || defined(PERL_CAPI) || defined(PERL_IMPLICIT_SYS)
 #  undef signal
 #  undef open
 #  undef setmode
diff --git a/intrpvar.h b/intrpvar.h
index b9a3a3d20c..1a8b1bfe1f 100644
--- a/intrpvar.h
+++ b/intrpvar.h
@@ -389,11 +389,11 @@ PERLVAR(Icred_mutex,	perl_mutex)	/* altered credentials in effect */
 #endif /* USE_THREADS */
 
 #if defined(PERL_IMPLICIT_SYS)
-PERLVARI(IMem,		struct IPerlMem*,  NULL)
-PERLVARI(IEnv,		struct IPerlEnv*,  NULL)
-PERLVARI(IStdIO,	struct IPerlStdIO*, NULL)
-PERLVARI(ILIO,		struct IPerlLIO*,  NULL)
-PERLVARI(IDir,		struct IPerlDir*,  NULL)
-PERLVARI(ISock,		struct IPerlSock*, NULL)
-PERLVARI(IProc,		struct IPerlProc*, NULL)
+PERLVAR(IMem,		struct IPerlMem*)
+PERLVAR(IEnv,		struct IPerlEnv*)
+PERLVAR(IStdIO,		struct IPerlStdIO*)
+PERLVAR(ILIO,		struct IPerlLIO*)
+PERLVAR(IDir,		struct IPerlDir*)
+PERLVAR(ISock,		struct IPerlSock*)
+PERLVAR(IProc,		struct IPerlProc*)
 #endif
diff --git a/makedef.pl b/makedef.pl
index d87029377d..a5878ff671 100644
--- a/makedef.pl
+++ b/makedef.pl
@@ -215,6 +215,11 @@ Perl_my_memset
 PL_cshlen
 PL_cshname
 PL_opsave
+
+Perl_do_exec
+Perl_getenv_len
+Perl_my_pclose
+Perl_my_popen
 )];
 } elsif ($PLATFORM eq 'aix') {
     skip_symbols([qw(
diff --git a/malloc.c b/malloc.c
index f35a4f23e4..3bbbe1c1ea 100644
--- a/malloc.c
+++ b/malloc.c
@@ -947,6 +947,7 @@ static	u_int goodsbrk;
 static void
 botch(char *diag, char *s)
 {
+	dTHXo;
 	PerlIO_printf(PerlIO_stderr(), "assertion botched (%s?): %s\n", diag, s);
 	PerlProc_abort();
 }
@@ -1030,9 +1031,11 @@ Perl_malloc(register size_t nbytes)
 
 	/* remove from linked list */
 #if defined(RCHECK)
-	if ((PTR2UV(p)) & (MEM_ALIGNBYTES - 1))
+	if ((PTR2UV(p)) & (MEM_ALIGNBYTES - 1)) {
+	    dTHXo;
 	    PerlIO_printf(PerlIO_stderr(), "Corrupt malloc ptr 0x%lx at 0x%lx\n",
 		(unsigned long)*((int*)p),(unsigned long)p);
+	}
 #endif
   	nextf[bucket] = p->ov_next;
 
@@ -1491,6 +1494,7 @@ Perl_mfree(void *mp)
 	    {
 		static int bad_free_warn = -1;
 		if (bad_free_warn == -1) {
+		    dTHXo;
 		    char *pbf = PerlEnv_getenv("PERL_BADFREE");
 		    bad_free_warn = (pbf) ? atoi(pbf) : 1;
 		}
@@ -1572,6 +1576,7 @@ Perl_realloc(void *mp, size_t nbytes)
 	    {
 		static int bad_free_warn = -1;
 		if (bad_free_warn == -1) {
+		    dTHXo;
 		    char *pbf = PerlEnv_getenv("PERL_BADFREE");
 		    bad_free_warn = (pbf) ? atoi(pbf) : 1;
 		}
diff --git a/perl.c b/perl.c
index 2d4115451e..6e9ffaab4e 100644
--- a/perl.c
+++ b/perl.c
@@ -47,16 +47,43 @@ static I32 read_e_script(pTHXo_ int idx, SV *buf_sv, int maxlen);
 #endif
 
 #ifdef PERL_OBJECT
-CPerlObj* perl_alloc(IPerlMem* ipM, IPerlEnv* ipE, IPerlStdIO* ipStd,
-		     IPerlLIO* ipLIO, IPerlDir* ipD, IPerlSock* ipS, IPerlProc* ipP)
+CPerlObj*
+perl_alloc(struct IPerlMem* ipM, struct IPerlEnv* ipE,
+		 struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO,
+		 struct IPerlDir* ipD, struct IPerlSock* ipS,
+		 struct IPerlProc* ipP)
 {
     CPerlObj* pPerl = new(ipM) CPerlObj(ipM, ipE, ipStd, ipLIO, ipD, ipS, ipP);
-    if(pPerl != NULL)
+    if (pPerl != NULL)
 	pPerl->Init();
 
     return pPerl;
 }
 #else
+
+#ifdef PERL_IMPLICIT_SYS
+PerlInterpreter *
+perl_alloc_using(struct IPerlMem* ipM, struct IPerlEnv* ipE,
+		 struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO,
+		 struct IPerlDir* ipD, struct IPerlSock* ipS,
+		 struct IPerlProc* ipP)
+{
+    PerlInterpreter *my_perl;
+
+    /* New() needs interpreter, so call malloc() instead */
+    my_perl = (PerlInterpreter*)(*ipM->pMalloc)(ipM, sizeof(PerlInterpreter));
+    PERL_SET_INTERP(my_perl);
+    Zero(my_perl, 1, PerlInterpreter);
+    PL_Mem = ipM;
+    PL_Env = ipE;
+    PL_StdIO = ipStd;
+    PL_LIO = ipLIO;
+    PL_Dir = ipD;
+    PL_Sock = ipS;
+    PL_Proc = ipP;
+    return my_perl;
+}
+#else
 PerlInterpreter *
 perl_alloc(void)
 {
@@ -67,6 +94,7 @@ perl_alloc(void)
     PERL_SET_INTERP(my_perl);
     return my_perl;
 }
+#endif /* PERL_IMPLICIT_SYS */
 #endif /* PERL_OBJECT */
 
 void
@@ -80,10 +108,6 @@ perl_construct(pTHXx)
 #endif /* USE_THREADS */
     
 #ifdef MULTIPLICITY
-    Zero(my_perl, 1, PerlInterpreter);
-#endif
-
-#ifdef MULTIPLICITY
     init_interp();
     PL_perl_destruct_level = 1; 
 #else
diff --git a/perl.h b/perl.h
index 5baf49a93c..eb88c39116 100644
--- a/perl.h
+++ b/perl.h
@@ -31,7 +31,9 @@
 #    define PERL_IMPLICIT_CONTEXT
 #  endif
 #  ifndef PERL_IMPLICIT_SYS
-/*#    define PERL_IMPLICIT_SYS*/		/* XXX not done yet */
+#    ifdef WIN32
+#      define PERL_IMPLICIT_SYS		/* XXX not implemented everywhere yet */
+#    endif
 #  endif
 #endif
 
@@ -40,7 +42,9 @@
 #    define PERL_IMPLICIT_CONTEXT
 #  endif
 #  ifndef PERL_IMPLICIT_SYS
-/*#    define PERL_IMPLICIT_SYS*/		/* XXX not done yet */
+#    ifdef WIN32
+#      define PERL_IMPLICIT_SYS		/* XXX not implemented everywhere yet */
+#    endif
 #  endif
 #endif
 
@@ -86,8 +90,8 @@ the perl interpreter.
 | Perl Host |
 +-----------+
       ^
-	  |
-	  v
+      |
+      v
 +-----------+   +-----------+
 | Perl Core |<->| Extension |
 +-----------+   +-----------+ ...
@@ -1388,9 +1392,6 @@ typedef struct loop LOOP;
 
 typedef struct Outrec Outrec;
 typedef struct interpreter PerlInterpreter;
-#ifndef __BORLANDC__
-typedef struct ff FF;		/* XXX not defined anywhere, should go? */
-#endif
 typedef struct sv SV;
 typedef struct av AV;
 typedef struct hv HV;
@@ -1684,7 +1685,6 @@ typedef pthread_key_t	perl_key;
 
 /* This defines a way to flush all output buffers.  This may be a
  * performance issue, so we allow people to disable it.
- * XXX the default needs a Configure test, as it may not work everywhere.
  */
 #ifndef PERL_FLUSHALL_FOR_CHILD
 # if defined(FFLUSH_NULL) || defined(USE_SFIO)
diff --git a/perlio.c b/perlio.c
index 81f7d678ff..2ad8b4e77a 100644
--- a/perlio.c
+++ b/perlio.c
@@ -7,7 +7,6 @@
  *
  */
 
-#if !defined(PERL_IMPLICIT_SYS)
 
 #define VOIDUSED 1
 #include "config.h"
@@ -26,6 +25,8 @@
 #define PERL_IN_PERLIO_C
 #include "perl.h"
 
+#if !defined(PERL_IMPLICIT_SYS)
+
 #ifdef PERLIO_IS_STDIO 
 
 void
diff --git a/win32/perllib.c b/win32/perllib.c
index 10b252a8db..f6cc6322bf 100644
--- a/win32/perllib.c
+++ b/win32/perllib.c
@@ -12,7 +12,7 @@
 
 #include "XSUB.h"
 
-#ifdef PERL_OBJECT
+#ifdef PERL_IMPLICIT_SYS
 #include "win32iop.h"
 #include <fcntl.h>
 #endif
@@ -34,20 +34,20 @@ xs_init(pTHXo)
     newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
 }
 
-#ifdef PERL_OBJECT
-// IPerlMem
+#ifdef PERL_IMPLICIT_SYS
+/* IPerlMem */
 void*
-PerlMemMalloc(struct IPerlMem*, size_t size)
+PerlMemMalloc(struct IPerlMem *I, size_t size)
 {
     return win32_malloc(size);
 }
 void*
-PerlMemRealloc(struct IPerlMem*, void* ptr, size_t size)
+PerlMemRealloc(struct IPerlMem *I, void* ptr, size_t size)
 {
     return win32_realloc(ptr, size);
 }
 void
-PerlMemFree(struct IPerlMem*, void* ptr)
+PerlMemFree(struct IPerlMem *I, void* ptr)
 {
     win32_free(ptr);
 }
@@ -60,24 +60,24 @@ struct IPerlMem perlMem =
 };
 
 
-// IPerlEnv
+/* IPerlEnv */
 extern char *		g_win32_get_privlib(char *pl);
 extern char *		g_win32_get_sitelib(char *pl);
 
 
 char*
-PerlEnvGetenv(struct IPerlEnv*, const char *varname)
+PerlEnvGetenv(struct IPerlEnv *I, const char *varname)
 {
     return win32_getenv(varname);
 };
 int
-PerlEnvPutenv(struct IPerlEnv*, const char *envstring)
+PerlEnvPutenv(struct IPerlEnv *I, const char *envstring)
 {
     return win32_putenv(envstring);
 };
 
 char*
-PerlEnvGetenv_len(struct IPerlEnv*, const char* varname, unsigned long* len)
+PerlEnvGetenv_len(struct IPerlEnv *I, const char* varname, unsigned long* len)
 {
     char *e = win32_getenv(varname);
     if (e)
@@ -86,13 +86,13 @@ PerlEnvGetenv_len(struct IPerlEnv*, const char* varname, unsigned long* len)
 }
 
 int
-PerlEnvUname(struct IPerlEnv*, struct utsname *name)
+PerlEnvUname(struct IPerlEnv *I, struct utsname *name)
 {
     return win32_uname(name);
 }
 
 void
-PerlEnvClearenv(struct IPerlEnv*)
+PerlEnvClearenv(struct IPerlEnv *I)
 {
     dTHXo;
     char *envv = GetEnvironmentStrings();
@@ -113,41 +113,41 @@ PerlEnvClearenv(struct IPerlEnv*)
 }
 
 void*
-PerlEnvGetChildEnv(struct IPerlEnv*)
+PerlEnvGetChildEnv(struct IPerlEnv *I)
 {
     return NULL;
 }
 
 void
-PerlEnvFreeChildEnv(struct IPerlEnv*, void* env)
+PerlEnvFreeChildEnv(struct IPerlEnv *I, void* env)
 {
 }
 
 char*
-PerlEnvGetChildDir(struct IPerlEnv*)
+PerlEnvGetChildDir(struct IPerlEnv *I)
 {
     return NULL;
 }
 
 void
-PerlEnvFreeChildDir(struct IPerlEnv*, char* dir)
+PerlEnvFreeChildDir(struct IPerlEnv *I, char* dir)
 {
 }
 
 unsigned long
-PerlEnvOsId(struct IPerlEnv*)
+PerlEnvOsId(struct IPerlEnv *I)
 {
     return win32_os_id();
 }
 
 char*
-PerlEnvLibPath(struct IPerlEnv*, char *pl)
+PerlEnvLibPath(struct IPerlEnv *I, char *pl)
 {
     return g_win32_get_privlib(pl);
 }
 
 char*
-PerlEnvSiteLibPath(struct IPerlEnv*, char *pl)
+PerlEnvSiteLibPath(struct IPerlEnv *I, char *pl)
 {
     return g_win32_get_sitelib(pl);
 }
@@ -169,63 +169,63 @@ struct IPerlEnv perlEnv =
 };
 
 
-// PerlStdIO
+/* PerlStdIO */
 PerlIO*
-PerlStdIOStdin(struct IPerlStdIO*)
+PerlStdIOStdin(struct IPerlStdIO *I)
 {
     return (PerlIO*)win32_stdin();
 }
 
 PerlIO*
-PerlStdIOStdout(struct IPerlStdIO*)
+PerlStdIOStdout(struct IPerlStdIO *I)
 {
     return (PerlIO*)win32_stdout();
 }
 
 PerlIO*
-PerlStdIOStderr(struct IPerlStdIO*)
+PerlStdIOStderr(struct IPerlStdIO *I)
 {
     return (PerlIO*)win32_stderr();
 }
 
 PerlIO*
-PerlStdIOOpen(struct IPerlStdIO*, const char *path, const char *mode)
+PerlStdIOOpen(struct IPerlStdIO *I, const char *path, const char *mode)
 {
     return (PerlIO*)win32_fopen(path, mode);
 }
 
 int
-PerlStdIOClose(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOClose(struct IPerlStdIO *I, PerlIO* pf)
 {
     return win32_fclose(((FILE*)pf));
 }
 
 int
-PerlStdIOEof(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOEof(struct IPerlStdIO *I, PerlIO* pf)
 {
     return win32_feof((FILE*)pf);
 }
 
 int
-PerlStdIOError(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOError(struct IPerlStdIO *I, PerlIO* pf)
 {
     return win32_ferror((FILE*)pf);
 }
 
 void
-PerlStdIOClearerr(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOClearerr(struct IPerlStdIO *I, PerlIO* pf)
 {
     win32_clearerr((FILE*)pf);
 }
 
 int
-PerlStdIOGetc(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOGetc(struct IPerlStdIO *I, PerlIO* pf)
 {
     return win32_getc((FILE*)pf);
 }
 
 char*
-PerlStdIOGetBase(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOGetBase(struct IPerlStdIO *I, PerlIO* pf)
 {
 #ifdef FILE_base
     FILE *f = (FILE*)pf;
@@ -236,7 +236,7 @@ PerlStdIOGetBase(struct IPerlStdIO*, PerlIO* pf)
 }
 
 int
-PerlStdIOGetBufsiz(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOGetBufsiz(struct IPerlStdIO *I, PerlIO* pf)
 {
 #ifdef FILE_bufsiz
     FILE *f = (FILE*)pf;
@@ -247,7 +247,7 @@ PerlStdIOGetBufsiz(struct IPerlStdIO*, PerlIO* pf)
 }
 
 int
-PerlStdIOGetCnt(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOGetCnt(struct IPerlStdIO *I, PerlIO* pf)
 {
 #ifdef USE_STDIO_PTR
     FILE *f = (FILE*)pf;
@@ -258,7 +258,7 @@ PerlStdIOGetCnt(struct IPerlStdIO*, PerlIO* pf)
 }
 
 char*
-PerlStdIOGetPtr(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOGetPtr(struct IPerlStdIO *I, PerlIO* pf)
 {
 #ifdef USE_STDIO_PTR
     FILE *f = (FILE*)pf;
@@ -269,79 +269,79 @@ PerlStdIOGetPtr(struct IPerlStdIO*, PerlIO* pf)
 }
 
 char*
-PerlStdIOGets(struct IPerlStdIO*, PerlIO* pf, char* s, int n)
+PerlStdIOGets(struct IPerlStdIO *I, PerlIO* pf, char* s, int n)
 {
     return win32_fgets(s, n, (FILE*)pf);
 }
 
 int
-PerlStdIOPutc(struct IPerlStdIO*, PerlIO* pf, int c)
+PerlStdIOPutc(struct IPerlStdIO *I, PerlIO* pf, int c)
 {
     return win32_fputc(c, (FILE*)pf);
 }
 
 int
-PerlStdIOPuts(struct IPerlStdIO*, PerlIO* pf, const char *s)
+PerlStdIOPuts(struct IPerlStdIO *I, PerlIO* pf, const char *s)
 {
     return win32_fputs(s, (FILE*)pf);
 }
 
 int
-PerlStdIOFlush(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOFlush(struct IPerlStdIO *I, PerlIO* pf)
 {
     return win32_fflush((FILE*)pf);
 }
 
 int
-PerlStdIOUngetc(struct IPerlStdIO*, PerlIO* pf,int c)
+PerlStdIOUngetc(struct IPerlStdIO *I, PerlIO* pf,int c)
 {
     return win32_ungetc(c, (FILE*)pf);
 }
 
 int
-PerlStdIOFileno(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOFileno(struct IPerlStdIO *I, PerlIO* pf)
 {
     return win32_fileno((FILE*)pf);
 }
 
 PerlIO*
-PerlStdIOFdopen(struct IPerlStdIO*, int fd, const char *mode)
+PerlStdIOFdopen(struct IPerlStdIO *I, int fd, const char *mode)
 {
     return (PerlIO*)win32_fdopen(fd, mode);
 }
 
 PerlIO*
-PerlStdIOReopen(struct IPerlStdIO*, const char*path, const char*mode, PerlIO* pf)
+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*, PerlIO* pf, void *buffer, Size_t size)
+PerlStdIORead(struct IPerlStdIO *I, PerlIO* pf, void *buffer, Size_t size)
 {
     return win32_fread(buffer, 1, size, (FILE*)pf);
 }
 
 SSize_t
-PerlStdIOWrite(struct IPerlStdIO*, PerlIO* pf, const void *buffer, Size_t size)
+PerlStdIOWrite(struct IPerlStdIO *I, PerlIO* pf, const void *buffer, Size_t size)
 {
     return win32_fwrite(buffer, 1, size, (FILE*)pf);
 }
 
 void
-PerlStdIOSetBuf(struct IPerlStdIO*, PerlIO* pf, char* buffer)
+PerlStdIOSetBuf(struct IPerlStdIO *I, PerlIO* pf, char* buffer)
 {
     win32_setbuf((FILE*)pf, buffer);
 }
 
 int
-PerlStdIOSetVBuf(struct IPerlStdIO*, PerlIO* pf, char* buffer, int type, Size_t size)
+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*, PerlIO* pf, int n)
+PerlStdIOSetCnt(struct IPerlStdIO *I, PerlIO* pf, int n)
 {
 #ifdef STDIO_CNT_LVALUE
     FILE *f = (FILE*)pf;
@@ -350,7 +350,7 @@ PerlStdIOSetCnt(struct IPerlStdIO*, PerlIO* pf, int n)
 }
 
 void
-PerlStdIOSetPtrCnt(struct IPerlStdIO*, PerlIO* pf, char * ptr, int n)
+PerlStdIOSetPtrCnt(struct IPerlStdIO *I, PerlIO* pf, char * ptr, int n)
 {
 #ifdef STDIO_PTR_LVALUE
     FILE *f = (FILE*)pf;
@@ -360,13 +360,13 @@ PerlStdIOSetPtrCnt(struct IPerlStdIO*, PerlIO* pf, char * ptr, int n)
 }
 
 void
-PerlStdIOSetlinebuf(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOSetlinebuf(struct IPerlStdIO *I, PerlIO* pf)
 {
     win32_setvbuf((FILE*)pf, NULL, _IOLBF, 0);
 }
 
 int
-PerlStdIOPrintf(struct IPerlStdIO*, PerlIO* pf, const char *format,...)
+PerlStdIOPrintf(struct IPerlStdIO *I, PerlIO* pf, const char *format,...)
 {
     va_list(arglist);
     va_start(arglist, format);
@@ -374,67 +374,65 @@ PerlStdIOPrintf(struct IPerlStdIO*, PerlIO* pf, const char *format,...)
 }
 
 int
-PerlStdIOVprintf(struct IPerlStdIO*, PerlIO* pf, const char *format, va_list arglist)
+PerlStdIOVprintf(struct IPerlStdIO *I, PerlIO* pf, const char *format, va_list arglist)
 {
     return win32_vfprintf((FILE*)pf, format, arglist);
 }
 
 long
-PerlStdIOTell(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIOTell(struct IPerlStdIO *I, PerlIO* pf)
 {
     return win32_ftell((FILE*)pf);
 }
 
 int
-PerlStdIOSeek(struct IPerlStdIO*, PerlIO* pf, off_t offset, int origin)
+PerlStdIOSeek(struct IPerlStdIO *I, PerlIO* pf, off_t offset, int origin)
 {
     return win32_fseek((FILE*)pf, offset, origin);
 }
 
 void
-PerlStdIORewind(struct IPerlStdIO*, PerlIO* pf)
+PerlStdIORewind(struct IPerlStdIO *I, PerlIO* pf)
 {
     win32_rewind((FILE*)pf);
 }
 
 PerlIO*
-PerlStdIOTmpfile(struct IPerlStdIO*)
+PerlStdIOTmpfile(struct IPerlStdIO *I)
 {
     return (PerlIO*)win32_tmpfile();
 }
 
 int
-PerlStdIOGetpos(struct IPerlStdIO*, PerlIO* pf, Fpos_t *p)
+PerlStdIOGetpos(struct IPerlStdIO *I, PerlIO* pf, Fpos_t *p)
 {
     return win32_fgetpos((FILE*)pf, p);
 }
 
 int
-PerlStdIOSetpos(struct IPerlStdIO*, PerlIO* pf, const Fpos_t *p)
+PerlStdIOSetpos(struct IPerlStdIO *I, PerlIO* pf, const Fpos_t *p)
 {
     return win32_fsetpos((FILE*)pf, p);
 }
 void
-PerlStdIOInit(struct IPerlStdIO*)
+PerlStdIOInit(struct IPerlStdIO *I)
 {
 }
 
 void
-PerlStdIOInitOSExtras(struct IPerlStdIO*)
+PerlStdIOInitOSExtras(struct IPerlStdIO *I)
 {
-    dTHXo;
-    xs_init(pPerl);
     Perl_init_os_extras();
 }
 
 int
-PerlStdIOOpenOSfhandle(struct IPerlStdIO*, long osfhandle, int flags)
+PerlStdIOOpenOSfhandle(struct IPerlStdIO *I, long osfhandle, int flags)
 {
     return win32_open_osfhandle(osfhandle, flags);
 }
 
 int
-PerlStdIOGetOSfhandle(struct IPerlStdIO*, int filenum)
+PerlStdIOGetOSfhandle(struct IPerlStdIO *I, int filenum)
 {
     return win32_get_osfhandle(filenum);
 }
@@ -483,75 +481,75 @@ struct IPerlStdIO perlStdIO =
 };
 
 
-// IPerlLIO
+/* IPerlLIO */
 int
-PerlLIOAccess(struct IPerlLIO*, const char *path, int mode)
+PerlLIOAccess(struct IPerlLIO *I, const char *path, int mode)
 {
     return access(path, mode);
 }
 
 int
-PerlLIOChmod(struct IPerlLIO*, const char *filename, int pmode)
+PerlLIOChmod(struct IPerlLIO *I, const char *filename, int pmode)
 {
     return chmod(filename, pmode);
 }
 
 int
-PerlLIOChown(struct IPerlLIO*, const char *filename, uid_t owner, gid_t group)
+PerlLIOChown(struct IPerlLIO *I, const char *filename, uid_t owner, gid_t group)
 {
     return chown(filename, owner, group);
 }
 
 int
-PerlLIOChsize(struct IPerlLIO*, int handle, long size)
+PerlLIOChsize(struct IPerlLIO *I, int handle, long size)
 {
     return chsize(handle, size);
 }
 
 int
-PerlLIOClose(struct IPerlLIO*, int handle)
+PerlLIOClose(struct IPerlLIO *I, int handle)
 {
     return win32_close(handle);
 }
 
 int
-PerlLIODup(struct IPerlLIO*, int handle)
+PerlLIODup(struct IPerlLIO *I, int handle)
 {
     return win32_dup(handle);
 }
 
 int
-PerlLIODup2(struct IPerlLIO*, int handle1, int handle2)
+PerlLIODup2(struct IPerlLIO *I, int handle1, int handle2)
 {
     return win32_dup2(handle1, handle2);
 }
 
 int
-PerlLIOFlock(struct IPerlLIO*, int fd, int oper)
+PerlLIOFlock(struct IPerlLIO *I, int fd, int oper)
 {
     return win32_flock(fd, oper);
 }
 
 int
-PerlLIOFileStat(struct IPerlLIO*, int handle, struct stat *buffer)
+PerlLIOFileStat(struct IPerlLIO *I, int handle, struct stat *buffer)
 {
     return fstat(handle, buffer);
 }
 
 int
-PerlLIOIOCtl(struct IPerlLIO*, int i, unsigned int u, char *data)
+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*, int fd)
+PerlLIOIsatty(struct IPerlLIO *I, int fd)
 {
     return isatty(fd);
 }
 
 long
-PerlLIOLseek(struct IPerlLIO*, int handle, long offset, int origin)
+PerlLIOLseek(struct IPerlLIO *I, int handle, long offset, int origin)
 {
     return win32_lseek(handle, offset, origin);
 }
@@ -563,19 +561,19 @@ PerlLIOLstat(struct IPerlLIO* p, const char *path, struct stat *buffer)
 }
 
 char*
-PerlLIOMktemp(struct IPerlLIO*, char *Template)
+PerlLIOMktemp(struct IPerlLIO *I, char *Template)
 {
     return mktemp(Template);
 }
 
 int
-PerlLIOOpen(struct IPerlLIO*, const char *filename, int oflag)
+PerlLIOOpen(struct IPerlLIO *I, const char *filename, int oflag)
 {
     return win32_open(filename, oflag);
 }
 
 int
-PerlLIOOpen3(struct IPerlLIO*, const char *filename, int oflag, int pmode)
+PerlLIOOpen3(struct IPerlLIO *I, const char *filename, int oflag, int pmode)
 {
     int ret;
     if(stricmp(filename, "/dev/null") == 0)
@@ -587,56 +585,56 @@ PerlLIOOpen3(struct IPerlLIO*, const char *filename, int oflag, int pmode)
 }
 
 int
-PerlLIORead(struct IPerlLIO*, int handle, void *buffer, unsigned int count)
+PerlLIORead(struct IPerlLIO *I, int handle, void *buffer, unsigned int count)
 {
     return win32_read(handle, buffer, count);
 }
 
 int
-PerlLIORename(struct IPerlLIO*, const char *OldFileName, const char *newname)
+PerlLIORename(struct IPerlLIO *I, const char *OldFileName, const char *newname)
 {
     return win32_rename(OldFileName, newname);
 }
 
 int
-PerlLIOSetmode(struct IPerlLIO*, int handle, int mode)
+PerlLIOSetmode(struct IPerlLIO *I, int handle, int mode)
 {
     return win32_setmode(handle, mode);
 }
 
 int
-PerlLIONameStat(struct IPerlLIO*, const char *path, struct stat *buffer)
+PerlLIONameStat(struct IPerlLIO *I, const char *path, struct stat *buffer)
 {
     return win32_stat(path, buffer);
 }
 
 char*
-PerlLIOTmpnam(struct IPerlLIO*, char *string)
+PerlLIOTmpnam(struct IPerlLIO *I, char *string)
 {
     return tmpnam(string);
 }
 
 int
-PerlLIOUmask(struct IPerlLIO*, int pmode)
+PerlLIOUmask(struct IPerlLIO *I, int pmode)
 {
     return umask(pmode);
 }
 
 int
-PerlLIOUnlink(struct IPerlLIO*, const char *filename)
+PerlLIOUnlink(struct IPerlLIO *I, const char *filename)
 {
     chmod(filename, S_IREAD | S_IWRITE);
     return unlink(filename);
 }
 
 int
-PerlLIOUtime(struct IPerlLIO*, char *filename, struct utimbuf *times)
+PerlLIOUtime(struct IPerlLIO *I, char *filename, struct utimbuf *times)
 {
     return win32_utime(filename, times);
 }
 
 int
-PerlLIOWrite(struct IPerlLIO*, int handle, const void *buffer, unsigned int count)
+PerlLIOWrite(struct IPerlLIO *I, int handle, const void *buffer, unsigned int count)
 {
     return win32_write(handle, buffer, count);
 }
@@ -670,57 +668,57 @@ struct IPerlLIO perlLIO =
     PerlLIOWrite,
 };
 
-// IPerlDIR
+/* IPerlDIR */
 int
-PerlDirMakedir(struct IPerlDir*, const char *dirname, int mode)
+PerlDirMakedir(struct IPerlDir *I, const char *dirname, int mode)
 {
     return win32_mkdir(dirname, mode);
 }
 
 int
-PerlDirChdir(struct IPerlDir*, const char *dirname)
+PerlDirChdir(struct IPerlDir *I, const char *dirname)
 {
     return win32_chdir(dirname);
 }
 
 int
-PerlDirRmdir(struct IPerlDir*, const char *dirname)
+PerlDirRmdir(struct IPerlDir *I, const char *dirname)
 {
     return win32_rmdir(dirname);
 }
 
 int
-PerlDirClose(struct IPerlDir*, DIR *dirp)
+PerlDirClose(struct IPerlDir *I, DIR *dirp)
 {
     return win32_closedir(dirp);
 }
 
 DIR*
-PerlDirOpen(struct IPerlDir*, char *filename)
+PerlDirOpen(struct IPerlDir *I, char *filename)
 {
     return win32_opendir(filename);
 }
 
 struct direct *
-PerlDirRead(struct IPerlDir*, DIR *dirp)
+PerlDirRead(struct IPerlDir *I, DIR *dirp)
 {
     return win32_readdir(dirp);
 }
 
 void
-PerlDirRewind(struct IPerlDir*, DIR *dirp)
+PerlDirRewind(struct IPerlDir *I, DIR *dirp)
 {
     win32_rewinddir(dirp);
 }
 
 void
-PerlDirSeek(struct IPerlDir*, DIR *dirp, long loc)
+PerlDirSeek(struct IPerlDir *I, DIR *dirp, long loc)
 {
     win32_seekdir(dirp, loc);
 }
 
 long
-PerlDirTell(struct IPerlDir*, DIR *dirp)
+PerlDirTell(struct IPerlDir *I, DIR *dirp)
 {
     return win32_telldir(dirp);
 }
@@ -739,275 +737,275 @@ struct IPerlDir perlDir =
 };
 
 
-// IPerlSock
+/* IPerlSock */
 u_long
-PerlSockHtonl(struct IPerlSock*, u_long hostlong)
+PerlSockHtonl(struct IPerlSock *I, u_long hostlong)
 {
     return win32_htonl(hostlong);
 }
 
 u_short
-PerlSockHtons(struct IPerlSock*, u_short hostshort)
+PerlSockHtons(struct IPerlSock *I, u_short hostshort)
 {
     return win32_htons(hostshort);
 }
 
 u_long
-PerlSockNtohl(struct IPerlSock*, u_long netlong)
+PerlSockNtohl(struct IPerlSock *I, u_long netlong)
 {
     return win32_ntohl(netlong);
 }
 
 u_short
-PerlSockNtohs(struct IPerlSock*, u_short netshort)
+PerlSockNtohs(struct IPerlSock *I, u_short netshort)
 {
     return win32_ntohs(netshort);
 }
 
-SOCKET PerlSockAccept(struct IPerlSock*, SOCKET s, struct sockaddr* addr, int* addrlen)
+SOCKET PerlSockAccept(struct IPerlSock *I, SOCKET s, struct sockaddr* addr, int* addrlen)
 {
     return win32_accept(s, addr, addrlen);
 }
 
 int
-PerlSockBind(struct IPerlSock*, SOCKET s, const struct sockaddr* name, int namelen)
+PerlSockBind(struct IPerlSock *I, SOCKET s, const struct sockaddr* name, int namelen)
 {
     return win32_bind(s, name, namelen);
 }
 
 int
-PerlSockConnect(struct IPerlSock*, SOCKET s, const struct sockaddr* name, int namelen)
+PerlSockConnect(struct IPerlSock *I, SOCKET s, const struct sockaddr* name, int namelen)
 {
     return win32_connect(s, name, namelen);
 }
 
 void
-PerlSockEndhostent(struct IPerlSock*)
+PerlSockEndhostent(struct IPerlSock *I)
 {
     win32_endhostent();
 }
 
 void
-PerlSockEndnetent(struct IPerlSock*)
+PerlSockEndnetent(struct IPerlSock *I)
 {
     win32_endnetent();
 }
 
 void
-PerlSockEndprotoent(struct IPerlSock*)
+PerlSockEndprotoent(struct IPerlSock *I)
 {
     win32_endprotoent();
 }
 
 void
-PerlSockEndservent(struct IPerlSock*)
+PerlSockEndservent(struct IPerlSock *I)
 {
     win32_endservent();
 }
 
 struct hostent*
-PerlSockGethostbyaddr(struct IPerlSock*, const char* addr, int len, int type)
+PerlSockGethostbyaddr(struct IPerlSock *I, const char* addr, int len, int type)
 {
     return win32_gethostbyaddr(addr, len, type);
 }
 
 struct hostent*
-PerlSockGethostbyname(struct IPerlSock*, const char* name)
+PerlSockGethostbyname(struct IPerlSock *I, const char* name)
 {
     return win32_gethostbyname(name);
 }
 
 struct hostent*
-PerlSockGethostent(struct IPerlSock*)
+PerlSockGethostent(struct IPerlSock *I)
 {
     dTHXo;
-    croak("gethostent not implemented!\n");
+    Perl_croak(aTHX_ "gethostent not implemented!\n");
     return NULL;
 }
 
 int
-PerlSockGethostname(struct IPerlSock*, char* name, int namelen)
+PerlSockGethostname(struct IPerlSock *I, char* name, int namelen)
 {
     return win32_gethostname(name, namelen);
 }
 
 struct netent *
-PerlSockGetnetbyaddr(struct IPerlSock*, long net, int type)
+PerlSockGetnetbyaddr(struct IPerlSock *I, long net, int type)
 {
     return win32_getnetbyaddr(net, type);
 }
 
 struct netent *
-PerlSockGetnetbyname(struct IPerlSock*, const char *name)
+PerlSockGetnetbyname(struct IPerlSock *I, const char *name)
 {
     return win32_getnetbyname((char*)name);
 }
 
 struct netent *
-PerlSockGetnetent(struct IPerlSock*)
+PerlSockGetnetent(struct IPerlSock *I)
 {
     return win32_getnetent();
 }
 
-int PerlSockGetpeername(struct IPerlSock*, SOCKET s, struct sockaddr* name, int* namelen)
+int PerlSockGetpeername(struct IPerlSock *I, SOCKET s, struct sockaddr* name, int* namelen)
 {
     return win32_getpeername(s, name, namelen);
 }
 
 struct protoent*
-PerlSockGetprotobyname(struct IPerlSock*, const char* name)
+PerlSockGetprotobyname(struct IPerlSock *I, const char* name)
 {
     return win32_getprotobyname(name);
 }
 
 struct protoent*
-PerlSockGetprotobynumber(struct IPerlSock*, int number)
+PerlSockGetprotobynumber(struct IPerlSock *I, int number)
 {
     return win32_getprotobynumber(number);
 }
 
 struct protoent*
-PerlSockGetprotoent(struct IPerlSock*)
+PerlSockGetprotoent(struct IPerlSock *I)
 {
     return win32_getprotoent();
 }
 
 struct servent*
-PerlSockGetservbyname(struct IPerlSock*, const char* name, const char* proto)
+PerlSockGetservbyname(struct IPerlSock *I, const char* name, const char* proto)
 {
     return win32_getservbyname(name, proto);
 }
 
 struct servent*
-PerlSockGetservbyport(struct IPerlSock*, int port, const char* proto)
+PerlSockGetservbyport(struct IPerlSock *I, int port, const char* proto)
 {
     return win32_getservbyport(port, proto);
 }
 
 struct servent*
-PerlSockGetservent(struct IPerlSock*)
+PerlSockGetservent(struct IPerlSock *I)
 {
     return win32_getservent();
 }
 
 int
-PerlSockGetsockname(struct IPerlSock*, SOCKET s, struct sockaddr* name, int* namelen)
+PerlSockGetsockname(struct IPerlSock *I, SOCKET s, struct sockaddr* name, int* namelen)
 {
     return win32_getsockname(s, name, namelen);
 }
 
 int
-PerlSockGetsockopt(struct IPerlSock*, SOCKET s, int level, int optname, char* optval, int* optlen)
+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*, const char* cp)
+PerlSockInetAddr(struct IPerlSock *I, const char* cp)
 {
     return win32_inet_addr(cp);
 }
 
 char*
-PerlSockInetNtoa(struct IPerlSock*, struct in_addr in)
+PerlSockInetNtoa(struct IPerlSock *I, struct in_addr in)
 {
     return win32_inet_ntoa(in);
 }
 
 int
-PerlSockListen(struct IPerlSock*, SOCKET s, int backlog)
+PerlSockListen(struct IPerlSock *I, SOCKET s, int backlog)
 {
     return win32_listen(s, backlog);
 }
 
 int
-PerlSockRecv(struct IPerlSock*, SOCKET s, char* buffer, int len, int flags)
+PerlSockRecv(struct IPerlSock *I, SOCKET s, char* buffer, int len, int flags)
 {
     return win32_recv(s, buffer, len, flags);
 }
 
 int
-PerlSockRecvfrom(struct IPerlSock*, SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen)
+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*, int nfds, char* readfds, char* writefds, char* exceptfds, const struct timeval* timeout)
+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*, SOCKET s, const char* buffer, int len, int flags)
+PerlSockSend(struct IPerlSock *I, SOCKET s, const char* buffer, int len, int flags)
 {
     return win32_send(s, buffer, len, flags);
 }
 
 int
-PerlSockSendto(struct IPerlSock*, SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen)
+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*, int stayopen)
+PerlSockSethostent(struct IPerlSock *I, int stayopen)
 {
     win32_sethostent(stayopen);
 }
 
 void
-PerlSockSetnetent(struct IPerlSock*, int stayopen)
+PerlSockSetnetent(struct IPerlSock *I, int stayopen)
 {
     win32_setnetent(stayopen);
 }
 
 void
-PerlSockSetprotoent(struct IPerlSock*, int stayopen)
+PerlSockSetprotoent(struct IPerlSock *I, int stayopen)
 {
     win32_setprotoent(stayopen);
 }
 
 void
-PerlSockSetservent(struct IPerlSock*, int stayopen)
+PerlSockSetservent(struct IPerlSock *I, int stayopen)
 {
     win32_setservent(stayopen);
 }
 
 int
-PerlSockSetsockopt(struct IPerlSock*, SOCKET s, int level, int optname, const char* optval, int optlen)
+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*, SOCKET s, int how)
+PerlSockShutdown(struct IPerlSock *I, SOCKET s, int how)
 {
     return win32_shutdown(s, how);
 }
 
 SOCKET
-PerlSockSocket(struct IPerlSock*, int af, int type, int protocol)
+PerlSockSocket(struct IPerlSock *I, int af, int type, int protocol)
 {
     return win32_socket(af, type, protocol);
 }
 
 int
-PerlSockSocketpair(struct IPerlSock*, int domain, int type, int protocol, int* fds)
+PerlSockSocketpair(struct IPerlSock *I, int domain, int type, int protocol, int* fds)
 {
     dTHXo;
-    croak("socketpair not implemented!\n");
+    Perl_croak(aTHX_ "socketpair not implemented!\n");
     return 0;
 }
 
 int
-PerlSockClosesocket(struct IPerlSock*, SOCKET s)
+PerlSockClosesocket(struct IPerlSock *I, SOCKET s)
 {
     return win32_closesocket(s);
 }
 
 int
-PerlSockIoctlsocket(struct IPerlSock*, SOCKET s, long cmd, u_long *argp)
+PerlSockIoctlsocket(struct IPerlSock *I, SOCKET s, long cmd, u_long *argp)
 {
     return win32_ioctlsocket(s, cmd, argp);
 }
@@ -1061,204 +1059,210 @@ struct IPerlSock perlSock =
 };
 
 
-// IPerlProc
+/* 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*)
+PerlProcAbort(struct IPerlProc *I)
 {
     win32_abort();
 }
 
 char *
-PerlProcCrypt(struct IPerlProc*, const char* clear, const char* salt)
+PerlProcCrypt(struct IPerlProc *I, const char* clear, const char* salt)
 {
     return win32_crypt(clear, salt);
 }
 
 void
-PerlProcExit(struct IPerlProc*, int status)
+PerlProcExit(struct IPerlProc *I, int status)
 {
     exit(status);
 }
 
 void
-PerlProc_Exit(struct IPerlProc*, int status)
+PerlProc_Exit(struct IPerlProc *I, int status)
 {
     _exit(status);
 }
 
 int
-PerlProcExecl(struct IPerlProc*, const char *cmdname, const char *arg0, const char *arg1, const char *arg2, const char *arg3)
+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*, const char *cmdname, const char *const *argv)
+PerlProcExecv(struct IPerlProc *I, const char *cmdname, const char *const *argv)
 {
     return win32_execvp(cmdname, argv);
 }
 
 int
-PerlProcExecvp(struct IPerlProc*, const char *cmdname, const char *const *argv)
+PerlProcExecvp(struct IPerlProc *I, const char *cmdname, const char *const *argv)
 {
     return win32_execvp(cmdname, argv);
 }
 
 uid_t
-PerlProcGetuid(struct IPerlProc*)
+PerlProcGetuid(struct IPerlProc *I)
 {
     return getuid();
 }
 
 uid_t
-PerlProcGeteuid(struct IPerlProc*)
+PerlProcGeteuid(struct IPerlProc *I)
 {
     return geteuid();
 }
 
 gid_t
-PerlProcGetgid(struct IPerlProc*)
+PerlProcGetgid(struct IPerlProc *I)
 {
     return getgid();
 }
 
 gid_t
-PerlProcGetegid(struct IPerlProc*)
+PerlProcGetegid(struct IPerlProc *I)
 {
     return getegid();
 }
 
 char *
-PerlProcGetlogin(struct IPerlProc*)
+PerlProcGetlogin(struct IPerlProc *I)
 {
     return g_getlogin();
 }
 
 int
-PerlProcKill(struct IPerlProc*, int pid, int sig)
+PerlProcKill(struct IPerlProc *I, int pid, int sig)
 {
     return win32_kill(pid, sig);
 }
 
 int
-PerlProcKillpg(struct IPerlProc*, int pid, int sig)
+PerlProcKillpg(struct IPerlProc *I, int pid, int sig)
 {
     dTHXo;
-    croak("killpg not implemented!\n");
+    Perl_croak(aTHX_ "killpg not implemented!\n");
     return 0;
 }
 
 int
-PerlProcPauseProc(struct IPerlProc*)
+PerlProcPauseProc(struct IPerlProc *I)
 {
     return win32_sleep((32767L << 16) + 32767);
 }
 
 PerlIO*
-PerlProcPopen(struct IPerlProc*, const char *command, const char *mode)
+PerlProcPopen(struct IPerlProc *I, const char *command, const char *mode)
 {
-    win32_fflush(stdout);
-    win32_fflush(stderr);
+    PERL_FLUSHALL_FOR_CHILD;
     return (PerlIO*)win32_popen(command, mode);
 }
 
 int
-PerlProcPclose(struct IPerlProc*, PerlIO *stream)
+PerlProcPclose(struct IPerlProc *I, PerlIO *stream)
 {
     return win32_pclose((FILE*)stream);
 }
 
 int
-PerlProcPipe(struct IPerlProc*, int *phandles)
+PerlProcPipe(struct IPerlProc *I, int *phandles)
 {
     return win32_pipe(phandles, 512, O_BINARY);
 }
 
 int
-PerlProcSetuid(struct IPerlProc*, uid_t u)
+PerlProcSetuid(struct IPerlProc *I, uid_t u)
 {
     return setuid(u);
 }
 
 int
-PerlProcSetgid(struct IPerlProc*, gid_t g)
+PerlProcSetgid(struct IPerlProc *I, gid_t g)
 {
     return setgid(g);
 }
 
 int
-PerlProcSleep(struct IPerlProc*, unsigned int s)
+PerlProcSleep(struct IPerlProc *I, unsigned int s)
 {
     return win32_sleep(s);
 }
 
 int
-PerlProcTimes(struct IPerlProc*, struct tms *timebuf)
+PerlProcTimes(struct IPerlProc *I, struct tms *timebuf)
 {
     return win32_times(timebuf);
 }
 
 int
-PerlProcWait(struct IPerlProc*, int *status)
+PerlProcWait(struct IPerlProc *I, int *status)
 {
     return win32_wait(status);
 }
 
 int
-PerlProcWaitpid(struct IPerlProc*, int pid, int *status, int flags)
+PerlProcWaitpid(struct IPerlProc *I, int pid, int *status, int flags)
 {
     return win32_waitpid(pid, status, flags);
 }
 
 Sighandler_t
-PerlProcSignal(struct IPerlProc*, int sig, Sighandler_t subcode)
+PerlProcSignal(struct IPerlProc *I, int sig, Sighandler_t subcode)
 {
     return 0;
 }
 
 void*
-PerlProcDynaLoader(struct IPerlProc*, const char* filename)
+PerlProcDynaLoader(struct IPerlProc *I, const char* filename)
 {
     return win32_dynaload(filename);
 }
 
 void
-PerlProcGetOSError(struct IPerlProc*, SV* sv, DWORD dwErr)
+PerlProcGetOSError(struct IPerlProc *I, SV* sv, DWORD dwErr)
 {
-    win32_str_os_error(aTHX_ sv, dwErr);
+    win32_str_os_error(sv, dwErr);
 }
 
 BOOL
-PerlProcDoCmd(struct IPerlProc*, char *cmd)
+PerlProcDoCmd(struct IPerlProc *I, char *cmd)
 {
     do_spawn2(cmd, EXECF_EXEC);
     return FALSE;
 }
 
 int
-PerlProcSpawn(struct IPerlProc*, char* cmds)
+PerlProcSpawn(struct IPerlProc *I, char* cmds)
 {
     return do_spawn2(cmds, EXECF_SPAWN);
 }
 
 int
-PerlProcSpawnvp(struct IPerlProc*, int mode, const char *cmdname, const char *const *argv)
+PerlProcSpawnvp(struct IPerlProc *I, int mode, const char *cmdname, const char *const *argv)
 {
     return win32_spawnvp(mode, cmdname, argv);
 }
 
 int
-PerlProcASpawn(struct IPerlProc*, void *vreally, void **vmark, void **vsp)
+PerlProcASpawn(struct IPerlProc *I, void *vreally, void **vmark, void **vsp)
 {
-    return g_do_aspawn(vreally, vmark, vsp);
+    return do_aspawn(vreally, vmark, vsp);
 }
 
 struct IPerlProc perlProc =
@@ -1296,13 +1300,17 @@ struct IPerlProc perlProc =
     PerlProcASpawn,
 };
 
-//#include "perlhost.h"
+/*#include "perlhost.h" */
 
 
-EXTERN_C void perl_get_host_info(IPerlMemInfo* perlMemInfo,
-			IPerlEnvInfo* perlEnvInfo, IPerlStdIOInfo* perlStdIOInfo,
-			IPerlLIOInfo* perlLIOInfo, IPerlDirInfo* perlDirInfo,
-			IPerlSockInfo* perlSockInfo, IPerlProcInfo* perlProcInfo)
+EXTERN_C void
+perl_get_host_info(struct IPerlMemInfo* perlMemInfo,
+		   struct IPerlEnvInfo* perlEnvInfo,
+		   struct IPerlStdIOInfo* perlStdIOInfo,
+		   struct IPerlLIOInfo* perlLIOInfo,
+		   struct IPerlDirInfo* perlDirInfo,
+		   struct IPerlSockInfo* perlSockInfo,
+		   struct IPerlProcInfo* perlProcInfo)
 {
     if(perlMemInfo) {
 	Copy(&perlMem, &perlMemInfo->perlMemList, perlMemInfo->nCount, void*);
@@ -1334,10 +1342,12 @@ EXTERN_C void perl_get_host_info(IPerlMemInfo* perlMemInfo,
     }
 }
 
-EXTERN_C PerlInterpreter* perl_alloc_using(IPerlMem* pMem,
-			IPerlEnv* pEnv, IPerlStdIO* pStdIO,
-			IPerlLIO* pLIO, IPerlDir* pDir,
-			IPerlSock* pSock, IPerlProc* pProc)
+#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)
 {
     CPerlObj* pPerl = NULL;
     try
@@ -1476,8 +1486,20 @@ EXTERN_C int perl_parse(PerlInterpreter* sv_interp, void (*xsinit)(CPerlObj*), i
 
 #undef PL_perl_destruct_level
 #define PL_perl_destruct_level int dummy
+
+#else /* !PERL_OBJECT */
+
+EXTERN_C PerlInterpreter*
+perl_alloc(void)
+{
+    return perl_alloc_using(&perlMem, &perlEnv, &perlStdIO, &perlLIO,
+			   &perlDir, &perlSock, &perlProc);
+}
+
 #endif /* PERL_OBJECT */
 
+#endif /* PERL_IMPLICIT_SYS */
+
 extern HANDLE w32_perldll_handle;
 static DWORD g_TlsAllocIndex;
 
@@ -1531,12 +1553,7 @@ RunPerl(int argc, char **argv, char **env)
     perl_construct( my_perl );
     PL_perl_destruct_level = 0;
 
-#ifdef PERL_OBJECT
-    /* PERL_OBJECT build sets Dynaloader in PerlStdIOInitOSExtras */
-    exitstatus = perl_parse(my_perl, NULL, argc, argv, env);
-#else
     exitstatus = perl_parse(my_perl, xs_init, argc, argv, env);
-#endif
     if (!exitstatus) {
 	exitstatus = perl_run( my_perl );
     }
diff --git a/win32/win32.c b/win32/win32.c
index bbf85e6967..4f0d7f8cd6 100644
--- a/win32/win32.c
+++ b/win32/win32.c
@@ -75,19 +75,22 @@ int _CRT_glob = 0;
 #define EXECF_SPAWN 2
 #define EXECF_SPAWN_NOWAIT 3
 
+#if defined(PERL_IMPLICIT_SYS)
+#  undef win32_get_privlib
+#  define win32_get_privlib g_win32_get_privlib
+#  undef win32_get_sitelib
+#  define win32_get_sitelib g_win32_get_sitelib
+#  undef do_spawn
+#  define do_spawn g_do_spawn
+#  undef getlogin
+#  define getlogin g_getlogin
+#endif
+
 #if defined(PERL_OBJECT)
-#undef win32_get_privlib
-#define win32_get_privlib g_win32_get_privlib
-#undef win32_get_sitelib
-#define win32_get_sitelib g_win32_get_sitelib
-#undef do_aspawn
-#define do_aspawn g_do_aspawn
-#undef do_spawn
-#define do_spawn g_do_spawn
-#undef Perl_do_exec
-#define Perl_do_exec g_do_exec
-#undef getlogin
-#define getlogin g_getlogin
+#  undef do_aspawn
+#  define do_aspawn g_do_aspawn
+#  undef Perl_do_exec
+#  define Perl_do_exec g_do_exec
 #endif
 
 static void		get_shell(void);
@@ -369,7 +372,7 @@ has_shell_metachars(char *ptr)
     return FALSE;
 }
 
-#if !defined(PERL_OBJECT)
+#if !defined(PERL_IMPLICIT_SYS)
 /* since the current process environment is being updated in util.c
  * the library functions will get the correct environment
  */
diff --git a/win32/win32.h b/win32/win32.h
index fa9b127518..0f6f7081fa 100644
--- a/win32/win32.h
+++ b/win32/win32.h
@@ -9,7 +9,7 @@
 #ifndef  _INC_WIN32_PERL5
 #define  _INC_WIN32_PERL5
 
-#if defined(PERL_OBJECT) || defined(PERL_CAPI)
+#if defined(PERL_OBJECT) || defined(PERL_IMPLICIT_SYS) || defined(PERL_CAPI)
 #  define DYNAMIC_ENV_FETCH
 #  define ENV_HV_NAME "___ENV_HV_NAME___"
 #  define HAS_GETENV_LEN
@@ -17,7 +17,7 @@
 #  define WIN32IO_IS_STDIO		/* don't pull in custom stdio layer */
 #  define WIN32SCK_IS_STDSCK		/* don't pull in custom wsock layer */
 #  ifdef PERL_GLOBAL_STRUCT
-#    error PERL_GLOBAL_STRUCT cannot be defined with PERL_OBJECT
+#    error PERL_GLOBAL_STRUCT cannot be defined with PERL_IMPLICIT_SYS
 #  endif
 #  define win32_get_privlib PerlEnv_lib_path
 #  define win32_get_sitelib PerlEnv_sitelib_path