# define getlogin g_getlogin
#endif
-#if defined(PERL_OBJECT)
-# 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);
static long tokenize(const char *str, char **dest, char ***destv);
int do_spawn2(char *cmd, int exectype);
if (retval == ERROR_SUCCESS
&& (type == REG_SZ || type == REG_EXPAND_SZ))
{
- dTHXo;
+ dTHX;
if (!*svp)
*svp = sv_2mortal(newSVpvn("",0));
SvGROW(*svp, datalen);
/* only add directory if it exists */
if (GetFileAttributes(mod_name) != (DWORD) -1) {
/* directory exists */
- dTHXo;
+ dTHX;
if (!*prev_pathp)
*prev_pathp = sv_2mortal(newSVpvn("",0));
sv_catpvn(*prev_pathp, ";", 1);
char *
win32_get_privlib(const char *pl)
{
- dTHXo;
+ dTHX;
char *stdlib = "lib";
char buffer[MAX_PATH+1];
SV *sv = Nullsv;
static char *
win32_get_xlib(const char *pl, const char *xlib, const char *libname)
{
- dTHXo;
+ dTHX;
char regstr[40];
char pathstr[MAX_PATH+1];
DWORD datalen;
{
int pid;
#ifdef USE_ITHREADS
- dTHXo;
+ dTHX;
if (w32_pseudo_id)
return -((int)w32_pseudo_id);
#endif
char **retvstart = 0;
int items = -1;
if (str) {
- dTHXo;
+ dTHX;
int slen = strlen(str);
register char *ret;
register char **retv;
static void
get_shell(void)
{
- dTHXo;
+ dTHX;
if (!w32_perlshell_tokens) {
/* we don't use COMSPEC here for two reasons:
* 1. the same reason perl on UNIX doesn't use SHELL--rampant and
*/
const char* defaultshell = (IsWinNT()
? "cmd.exe /x/c" : "command.com /c");
- const char *usershell = getenv("PERL5SHELL");
+ const char *usershell = PerlEnv_getenv("PERL5SHELL");
w32_perlshell_items = tokenize(usershell ? usershell : defaultshell,
&w32_perlshell_tokens,
&w32_perlshell_vec);
int
do_aspawn(void *vreally, void **vmark, void **vsp)
{
- dTHXo;
+ dTHX;
SV *really = (SV*)vreally;
SV **mark = (SV**)vmark;
SV **sp = (SV**)vsp;
return (status);
}
+/* returns pointer to the next unquoted space or the end of the string */
+static char*
+find_next_space(const char *s)
+{
+ bool in_quotes = FALSE;
+ while (*s) {
+ /* ignore doubled backslashes, or backslash+quote */
+ if (*s == '\\' && (s[1] == '\\' || s[1] == '"')) {
+ s += 2;
+ }
+ /* keep track of when we're within quotes */
+ else if (*s == '"') {
+ s++;
+ in_quotes = !in_quotes;
+ }
+ /* break it up only at spaces that aren't in quotes */
+ else if (!in_quotes && isSPACE(*s))
+ return (char*)s;
+ else
+ s++;
+ }
+ return (char*)s;
+}
+
int
do_spawn2(char *cmd, int exectype)
{
- dTHXo;
+ dTHX;
char **a;
char *s;
char **argv;
s++;
if (*s)
*(a++) = s;
- while (*s && !isSPACE(*s))
- s++;
+ s = find_next_space(s);
if (*s)
*s++ = '\0';
}
DllExport DIR *
win32_opendir(char *filename)
{
- dTHXo;
+ dTHX;
DIR *dirp;
long len;
long idx;
/* Now set up for the next call to readdir */
dirp->curr += len + 1;
if (dirp->curr >= dirp->end) {
- dTHXo;
+ dTHX;
char* ptr;
BOOL res;
WIN32_FIND_DATAW wFindData;
DllExport int
win32_closedir(DIR *dirp)
{
- dTHXo;
+ dTHX;
if (dirp->handle != INVALID_HANDLE_VALUE)
FindClose(dirp->handle);
Safefree(dirp->start);
char *
getlogin(void)
{
- dTHXo;
+ dTHX;
char *buf = w32_getlogin_buffer;
DWORD size = sizeof(w32_getlogin_buffer);
if (GetUserName(buf,&size))
static long
find_pid(int pid)
{
- dTHXo;
+ dTHX;
long child = w32_num_children;
while (--child >= 0) {
if (w32_child_pids[child] == pid)
remove_dead_process(long child)
{
if (child >= 0) {
- dTHXo;
+ dTHX;
CloseHandle(w32_child_handles[child]);
Move(&w32_child_handles[child+1], &w32_child_handles[child],
(w32_num_children-child-1), HANDLE);
static long
find_pseudo_pid(int pid)
{
- dTHXo;
+ dTHX;
long child = w32_num_pseudo_children;
while (--child >= 0) {
if (w32_pseudo_child_pids[child] == pid)
remove_dead_pseudo_process(long child)
{
if (child >= 0) {
- dTHXo;
+ dTHX;
CloseHandle(w32_pseudo_child_handles[child]);
Move(&w32_pseudo_child_handles[child+1], &w32_pseudo_child_handles[child],
(w32_num_pseudo_children-child-1), HANDLE);
DllExport int
win32_kill(int pid, int sig)
{
- dTHXo;
+ dTHX;
HANDLE hProcess;
long child;
#ifdef USE_ITHREADS
DllExport int
win32_stat(const char *path, struct stat *sbuf)
{
- dTHXo;
+ dTHX;
char buffer[MAX_PATH+1];
int l = strlen(path);
int res;
DllExport char *
win32_getenv(const char *name)
{
- dTHXo;
+ dTHX;
WCHAR wBuffer[MAX_PATH+1];
DWORD needlen;
SV *curitem = Nullsv;
DllExport int
win32_putenv(const char *name)
{
- dTHXo;
+ dTHX;
char* curitem;
char* val;
WCHAR* wCuritem;
DllExport int
win32_unlink(const char *filename)
{
- dTHXo;
+ dTHX;
int ret;
DWORD attrs;
DllExport int
win32_utime(const char *filename, struct utimbuf *times)
{
- dTHXo;
+ dTHX;
HANDLE handle;
FILETIME ftCreate;
FILETIME ftAccess;
char *arch;
GetSystemInfo(&info);
-#if (defined(__BORLANDC__)&&(__BORLANDC__<=0x520)) || defined(__MINGW32__)
+#if (defined(__BORLANDC__)&&(__BORLANDC__<=0x520)) \
+ || (defined(__MINGW32__) && !defined(_ANONYMOUS_UNION))
switch (info.u.s.wProcessorArchitecture) {
#else
switch (info.wProcessorArchitecture) {
DllExport int
win32_waitpid(int pid, int *status, int flags)
{
- dTHXo;
+ dTHX;
DWORD timeout = (flags & WNOHANG) ? 0 : INFINITE;
int retval = -1;
long child;
/* XXX this wait emulation only knows about processes
* spawned via win32_spawnvp(P_NOWAIT, ...).
*/
- dTHXo;
+ dTHX;
int i, retval;
DWORD exitcode, waitcode;
return -1;
}
-#ifndef PERL_OBJECT
+#ifndef PERL_IMPLICIT_CONTEXT
static UINT timerid = 0;
static VOID CALLBACK TimerProc(HWND win, UINT msg, UINT id, DWORD time)
{
- dTHXo;
+ dTHX;
KillTimer(NULL,timerid);
timerid=0;
CALL_FPTR(PL_sighandlerp)(14);
}
-#endif /* !PERL_OBJECT */
+
+#endif /* !PERL_IMPLICIT_CONTEXT */
DllExport unsigned int
win32_alarm(unsigned int sec)
{
-#ifndef PERL_OBJECT
+#ifndef PERL_IMPLICIT_CONTEXT
/*
* the 'obvious' implentation is SetTimer() with a callback
* which does whatever receiving SIGALRM would do
* Snag is unless something is looking at the message queue
* nothing happens :-(
*/
- dTHXo;
+ dTHX;
if (sec)
{
timerid = SetTimer(NULL,timerid,sec*1000,(TIMERPROC)TimerProc);
timerid=0;
}
}
-#endif /* !PERL_OBJECT */
+#endif /* !PERL_IMPLICIT_CONTEXT */
return 0;
}
DllExport char *
win32_crypt(const char *txt, const char *salt)
{
- dTHXo;
+ dTHX;
#ifdef HAVE_DES_FCRYPT
return des_fcrypt(txt, salt, w32_crypt_buffer);
#else
HANDLE fh;
if (!IsWinNT()) {
- dTHXo;
+ dTHX;
Perl_croak_nocontext("flock() unimplemented on this platform");
return -1;
}
DllExport char *
win32_strerror(int e)
{
-#ifndef __BORLANDC__ /* Borland intolerance */
+#if !defined __BORLANDC__ && !defined __MINGW32__ /* compiler intolerance */
extern int sys_nerr;
#endif
DWORD source = 0;
if (e < 0 || e > sys_nerr) {
- dTHXo;
+ dTHX;
if (e < 0)
e = GetLastError();
dwErr, GetLastError());
}
if (sMsg) {
- dTHXo;
+ dTHX;
sv_setpvn((SV*)sv, sMsg, dwLen);
LocalFree(sMsg);
}
DllExport FILE *
win32_fopen(const char *filename, const char *mode)
{
- dTHXo;
+ dTHX;
WCHAR wMode[MODE_SIZE], wBuffer[MAX_PATH+1];
FILE *f;
DllExport FILE *
win32_fdopen(int handle, const char *mode)
{
- dTHXo;
+ dTHX;
WCHAR wMode[MODE_SIZE];
FILE *f;
if (USING_WIDE()) {
DllExport FILE *
win32_freopen(const char *path, const char *mode, FILE *stream)
{
- dTHXo;
+ dTHX;
WCHAR wMode[MODE_SIZE], wBuffer[MAX_PATH+1];
if (stricmp(path, "/dev/null")==0)
path = "NUL";
DllExport FILE*
win32_tmpfile(void)
{
- return tmpfile();
+ dTHX;
+ char prefix[MAX_PATH+1];
+ char filename[MAX_PATH+1];
+ DWORD len = GetTempPath(MAX_PATH, prefix);
+ if (len && len < MAX_PATH) {
+ if (GetTempFileName(prefix, "plx", 0, filename)) {
+ HANDLE fh = CreateFile(filename,
+ DELETE | GENERIC_READ | GENERIC_WRITE,
+ 0,
+ NULL,
+ CREATE_ALWAYS,
+ FILE_ATTRIBUTE_NORMAL
+ | FILE_FLAG_DELETE_ON_CLOSE,
+ NULL);
+ if (fh != INVALID_HANDLE_VALUE) {
+ int fd = win32_open_osfhandle((long)fh, 0);
+ if (fd >= 0) {
+ DEBUG_p(PerlIO_printf(Perl_debug_log,
+ "Created tmpfile=%s\n",filename));
+ return fdopen(fd, "w+b");
+ }
+ }
+ }
+ }
+ return NULL;
}
DllExport void
/* start the child */
{
- dTHXo;
+ dTHX;
if ((childpid = do_spawn_nowait((char*)command)) == -1)
goto cleanup;
#ifdef USE_RTL_POPEN
return _pclose(pf);
#else
- dTHXo;
+ dTHX;
int childpid, status;
SV *sv;
StreamId.dwStreamId = BACKUP_LINK;
StreamId.dwStreamAttributes = 0;
StreamId.dwStreamNameSize = 0;
-#if defined(__BORLANDC__) || defined(__MINGW32__)
+#if defined(__BORLANDC__) \
+ ||(defined(__MINGW32__) && !defined(_ANONYMOUS_UNION))
StreamId.Size.u.HighPart = 0;
StreamId.Size.u.LowPart = dwLen;
#else
DllExport int
win32_link(const char *oldname, const char *newname)
{
- dTHXo;
+ dTHX;
BOOL (__stdcall *pfnCreateHardLinkW)(LPCWSTR,LPCWSTR,LPSECURITY_ATTRIBUTES);
WCHAR wOldName[MAX_PATH+1];
WCHAR wNewName[MAX_PATH+1];
char szOldName[MAX_PATH+1];
char szNewName[MAX_PATH+1];
BOOL bResult;
- dTHXo;
+ dTHX;
/* XXX despite what the documentation says about MoveFileEx(),
* it doesn't work under Windows95!
DllExport int
win32_open(const char *path, int flag, ...)
{
- dTHXo;
+ dTHX;
va_list ap;
int pmode;
WCHAR wBuffer[MAX_PATH+1];
DllExport int
win32_mkdir(const char *dir, int mode)
{
- dTHXo;
+ dTHX;
if (USING_WIDE()) {
WCHAR wBuffer[MAX_PATH+1];
A2WHELPER(dir, wBuffer, sizeof(wBuffer));
DllExport int
win32_rmdir(const char *dir)
{
- dTHXo;
+ dTHX;
if (USING_WIDE()) {
WCHAR wBuffer[MAX_PATH+1];
A2WHELPER(dir, wBuffer, sizeof(wBuffer));
DllExport int
win32_chdir(const char *dir)
{
- dTHXo;
+ dTHX;
+ if (!dir) {
+ errno = ENOENT;
+ return -1;
+ }
if (USING_WIDE()) {
WCHAR wBuffer[MAX_PATH+1];
A2WHELPER(dir, wBuffer, sizeof(wBuffer));
DllExport int
win32_access(const char *path, int mode)
{
- dTHXo;
+ dTHX;
if (USING_WIDE()) {
WCHAR wBuffer[MAX_PATH+1];
A2WHELPER(path, wBuffer, sizeof(wBuffer));
DllExport int
win32_chmod(const char *path, int mode)
{
- dTHXo;
+ dTHX;
if (USING_WIDE()) {
WCHAR wBuffer[MAX_PATH+1];
A2WHELPER(path, wBuffer, sizeof(wBuffer));
static char *
-create_command_line(const char* command, const char * const *args)
+create_command_line(char *cname, STRLEN clen, const char * const *args)
{
- dTHXo;
- int index;
- char *cmd, *ptr, *arg;
- STRLEN len = strlen(command) + 1;
+ dTHX;
+ int index, argc;
+ char *cmd, *ptr;
+ const char *arg;
+ STRLEN len = 0;
+ bool bat_file = FALSE;
+ bool cmd_shell = FALSE;
+ bool dumb_shell = FALSE;
+ bool extra_quotes = FALSE;
+ bool quote_next = FALSE;
+
+ if (!cname)
+ cname = (char*)args[0];
+
+ /* The NT cmd.exe shell has the following peculiarity that needs to be
+ * worked around. It strips a leading and trailing dquote when any
+ * of the following is true:
+ * 1. the /S switch was used
+ * 2. there are more than two dquotes
+ * 3. there is a special character from this set: &<>()@^|
+ * 4. no whitespace characters within the two dquotes
+ * 5. string between two dquotes isn't an executable file
+ * To work around this, we always add a leading and trailing dquote
+ * to the string, if the first argument is either "cmd.exe" or "cmd",
+ * and there were at least two or more arguments passed to cmd.exe
+ * (not including switches).
+ * XXX the above rules (from "cmd /?") don't seem to be applied
+ * always, making for the convolutions below :-(
+ */
+ if (cname) {
+ if (!clen)
+ clen = strlen(cname);
- for (index = 0; (ptr = (char*)args[index]) != NULL; ++index)
- len += strlen(ptr) + 1;
+ if (clen > 4
+ && (stricmp(&cname[clen-4], ".bat") == 0
+ || (IsWinNT() && stricmp(&cname[clen-4], ".cmd") == 0)))
+ {
+ bat_file = TRUE;
+ len += 3;
+ }
+ else {
+ char *exe = strrchr(cname, '/');
+ char *exe2 = strrchr(cname, '\\');
+ if (exe2 > exe)
+ exe = exe2;
+ if (exe)
+ ++exe;
+ else
+ exe = cname;
+ if (stricmp(exe, "cmd.exe") == 0 || stricmp(exe, "cmd") == 0) {
+ cmd_shell = TRUE;
+ len += 3;
+ }
+ else if (stricmp(exe, "command.com") == 0
+ || stricmp(exe, "command") == 0)
+ {
+ dumb_shell = TRUE;
+ }
+ }
+ }
+ DEBUG_p(PerlIO_printf(Perl_debug_log, "Args "));
+ for (index = 0; (arg = (char*)args[index]) != NULL; ++index) {
+ STRLEN curlen = strlen(arg);
+ if (!(arg[0] == '"' && arg[curlen-1] == '"'))
+ len += 2; /* assume quoting needed (worst case) */
+ len += curlen + 1;
+ DEBUG_p(PerlIO_printf(Perl_debug_log, "[%s]",arg));
+ }
+ DEBUG_p(PerlIO_printf(Perl_debug_log, "\n"));
+
+ argc = index;
New(1310, cmd, len, char);
ptr = cmd;
- strcpy(ptr, command);
+
+ if (bat_file) {
+ *ptr++ = '"';
+ extra_quotes = TRUE;
+ }
for (index = 0; (arg = (char*)args[index]) != NULL; ++index) {
- ptr += strlen(ptr);
- *ptr++ = ' ';
+ bool do_quote = 0;
+ STRLEN curlen = strlen(arg);
+
+ /* we want to protect empty arguments and ones with spaces with
+ * dquotes, but only if they aren't already there */
+ if (!dumb_shell) {
+ if (!curlen) {
+ do_quote = 1;
+ }
+ else if (quote_next) {
+ /* see if it really is multiple arguments pretending to
+ * be one and force a set of quotes around it */
+ if (*find_next_space(arg))
+ do_quote = 1;
+ }
+ else if (!(arg[0] == '"' && curlen > 1 && arg[curlen-1] == '"')) {
+ STRLEN i = 0;
+ while (i < curlen) {
+ if (isSPACE(arg[i])) {
+ do_quote = 1;
+ }
+ else if (arg[i] == '"') {
+ do_quote = 0;
+ break;
+ }
+ i++;
+ }
+ }
+ }
+
+ if (do_quote)
+ *ptr++ = '"';
+
strcpy(ptr, arg);
+ ptr += curlen;
+
+ if (do_quote)
+ *ptr++ = '"';
+
+ if (args[index+1])
+ *ptr++ = ' ';
+
+ if (!extra_quotes
+ && cmd_shell
+ && (stricmp(arg, "/x/c") == 0 || stricmp(arg, "/c") == 0))
+ {
+ /* is there a next argument? */
+ if (args[index+1]) {
+ /* are there two or more next arguments? */
+ if (args[index+2]) {
+ *ptr++ = '"';
+ extra_quotes = TRUE;
+ }
+ else {
+ /* single argument, force quoting if it has spaces */
+ quote_next = TRUE;
+ }
+ }
+ }
}
+ if (extra_quotes)
+ *ptr++ = '"';
+
+ *ptr = '\0';
+
return cmd;
}
static char *
qualified_path(const char *cmd)
{
- dTHXo;
+ dTHX;
char *pathstr;
char *fullcmd, *curfullcmd;
STRLEN cmdlen = 0;
}
/* look in PATH */
- pathstr = win32_getenv("PATH");
+ pathstr = PerlEnv_getenv("PATH");
New(0, fullcmd, MAX_PATH+1, char);
curfullcmd = fullcmd;
* environment and the current directory to CreateProcess
*/
-void*
-get_childenv(void)
+DllExport void*
+win32_get_childenv(void)
{
return NULL;
}
-void
-free_childenv(void* d)
+DllExport void
+win32_free_childenv(void* d)
{
}
-char*
-get_childdir(void)
+DllExport void
+win32_clearenv(void)
{
- dTHXo;
+ char *envv = GetEnvironmentStrings();
+ char *cur = envv;
+ STRLEN len;
+ while (*cur) {
+ char *end = strchr(cur,'=');
+ if (end && end != cur) {
+ *end = '\0';
+ SetEnvironmentVariable(cur, NULL);
+ *end = '=';
+ cur = end + strlen(end+1)+2;
+ }
+ else if ((len = strlen(cur)))
+ cur += len+1;
+ }
+ FreeEnvironmentStrings(envv);
+}
+
+DllExport char*
+win32_get_childdir(void)
+{
+ dTHX;
char* ptr;
char szfilename[(MAX_PATH+1)*2];
if (USING_WIDE()) {
return ptr;
}
-void
-free_childdir(char* d)
+DllExport void
+win32_free_childdir(char* d)
{
- dTHXo;
+ dTHX;
Safefree(d);
}
#ifdef USE_RTL_SPAWNVP
return spawnvp(mode, cmdname, (char * const *)argv);
#else
- dTHXo;
+ dTHX;
int ret;
void* env;
char* dir;
STARTUPINFO StartupInfo;
PROCESS_INFORMATION ProcessInformation;
DWORD create = 0;
-
- char *cmd = create_command_line(cmdname, strcmp(cmdname, argv[0]) == 0
- ? &argv[1] : argv);
+ char *cmd;
char *fullcmd = Nullch;
+ char *cname = (char *)cmdname;
+ STRLEN clen = 0;
+
+ if (cname) {
+ clen = strlen(cname);
+ /* if command name contains dquotes, must remove them */
+ if (strchr(cname, '"')) {
+ cmd = cname;
+ New(0,cname,clen+1,char);
+ clen = 0;
+ while (*cmd) {
+ if (*cmd != '"') {
+ cname[clen] = *cmd;
+ ++clen;
+ }
+ ++cmd;
+ }
+ cname[clen] = '\0';
+ }
+ }
+
+ cmd = create_command_line(cname, clen, argv);
env = PerlEnv_get_childenv();
dir = PerlEnv_get_childdir();
create |= CREATE_NEW_CONSOLE;
}
+ DEBUG_p(PerlIO_printf(Perl_debug_log, "Spawning [%s] with [%s]\n",
+ cname,cmd));
RETRY:
- if (!CreateProcess(cmdname, /* search PATH to find executable */
+ if (!CreateProcess(cname, /* search PATH to find executable */
cmd, /* executable, and its arguments */
NULL, /* process attributes */
NULL, /* thread attributes */
* jump through our own hoops by picking out the path
* we really want it to use. */
if (!fullcmd) {
- fullcmd = qualified_path(cmdname);
+ fullcmd = qualified_path(cname);
if (fullcmd) {
- cmdname = fullcmd;
+ if (cname != cmdname)
+ Safefree(cname);
+ cname = fullcmd;
+ DEBUG_p(PerlIO_printf(Perl_debug_log,
+ "Retrying [%s] with same args\n",
+ cname));
goto RETRY;
}
}
PerlEnv_free_childenv(env);
PerlEnv_free_childdir(dir);
Safefree(cmd);
- Safefree(fullcmd);
+ if (cname != cmdname)
+ Safefree(cname);
return ret;
#endif
}
win32_execv(const char *cmdname, const char *const *argv)
{
#ifdef USE_ITHREADS
- dTHXo;
+ dTHX;
/* if this is a pseudo-forked child, we just want to spawn
* the new program, and return */
if (w32_pseudo_id)
win32_execvp(const char *cmdname, const char *const *argv)
{
#ifdef USE_ITHREADS
- dTHXo;
+ dTHX;
/* if this is a pseudo-forked child, we just want to spawn
* the new program, and return */
- if (w32_pseudo_id)
- return my_exit(win32_spawnvp(P_WAIT, cmdname, (char *const *)argv));
+ if (w32_pseudo_id) {
+ int status = win32_spawnvp(P_WAIT, cmdname, (char *const *)argv);
+ if (status != -1) {
+ my_exit(status);
+ return 0;
+ }
+ else
+ return status;
+ }
#endif
return execvp(cmdname, (char *const *)argv);
}
#ifndef USE_PERL_SBRK
-static char *committed = NULL;
-static char *base = NULL;
-static char *reserved = NULL;
-static char *brk = NULL;
-static DWORD pagesize = 0;
-static DWORD allocsize = 0;
+static char *committed = NULL; /* XXX threadead */
+static char *base = NULL; /* XXX threadead */
+static char *reserved = NULL; /* XXX threadead */
+static char *brk = NULL; /* XXX threadead */
+static DWORD pagesize = 0; /* XXX threadead */
+static DWORD allocsize = 0; /* XXX threadead */
void *
sbrk(int need)
DllExport void*
win32_dynaload(const char* filename)
{
- dTHXo;
+ dTHX;
HMODULE hModule;
char buf[MAX_PATH+1];
char *first;
sv_setpv(sv, ptr);
PerlEnv_free_childdir(ptr);
+#ifndef INCOMPLETE_TAINTS
+ SvTAINTED_on(sv);
+#endif
+
EXTEND(SP,1);
SvPOK_on(sv);
ST(0) = sv;
void
Perl_init_os_extras(void)
{
- dTHXo;
+ dTHX;
char *file = __FILE__;
dXSUB_SYS;
#ifdef HAVE_INTERP_INTERN
-# ifdef PERL_OBJECT
-# undef Perl_sys_intern_init
-# define Perl_sys_intern_init CPerlObj::Perl_sys_intern_init
-# undef Perl_sys_intern_dup
-# define Perl_sys_intern_dup CPerlObj::Perl_sys_intern_dup
-# undef Perl_sys_intern_clear
-# define Perl_sys_intern_clear CPerlObj::Perl_sys_intern_clear
-# define pPerl this
-# endif
-
void
Perl_sys_intern_init(pTHX)
{
# endif /* USE_ITHREADS */
#endif /* HAVE_INTERP_INTERN */
-#ifdef PERL_OBJECT
-# undef this
-# define this pPerl
-#endif
-
static void
-win32_free_argvw(pTHXo_ void *ptr)
+win32_free_argvw(pTHX_ void *ptr)
{
char** argv = (char**)ptr;
while(*argv) {
void
win32_argv2utf8(int argc, char** argv)
{
- dTHXo;
+ dTHX;
char* psz;
int length, wargc;
LPWSTR* lpwStr = CommandLineToArgvW(GetCommandLineW(), &wargc);