/* amigaio.c mixes amigaos and perl APIs,
 * as opposed to amigaos.c which is pure amigaos */

#include "EXTERN.h"
#include "perl.h"

#include "amigaos4/amigaio.h"
#include "amigaos.h"

#ifdef WORD
#  undef WORD
#  define WORD int16
#endif

#include <stdio.h>

#include <exec/semaphores.h>
#include <exec/exectags.h>
#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/utility.h>
#include <dos/dos.h>

extern struct SignalSemaphore popen_sema;
extern unsigned int  pipenum;

extern int32 myruncommand(BPTR seglist, int stack, char *command, int length, char **envp);

void amigaos_stdio_get(pTHX_ StdioStore *store)
{
	store->astdin =
	    amigaos_get_file(PerlIO_fileno(IoIFP(GvIO(PL_stdingv))));
	store->astderr =
	    amigaos_get_file(PerlIO_fileno(IoIFP(GvIO(PL_stderrgv))));
	store->astdout = amigaos_get_file(
	                     PerlIO_fileno(IoIFP(GvIO(gv_fetchpv("STDOUT", TRUE, SVt_PVIO)))));
}

void amigaos_stdio_save(pTHX_ StdioStore *store)
{
	amigaos_stdio_get(aTHX_ store);
	store->oldstdin = IDOS->SelectInput(store->astdin);
	store->oldstderr = IDOS->SelectErrorOutput(store->astderr);
	store->oldstdout = IDOS->SelectOutput(store->astdout);
}

void amigaos_stdio_restore(pTHX_ const StdioStore *store)
{
	IDOS->SelectInput(store->oldstdin);
	IDOS->SelectErrorOutput(store->oldstderr);
	IDOS->SelectOutput(store->oldstdout);
}

void amigaos_post_exec(int fd, int do_report)
{
	/* We *must* write something to our pipe or else
	 * the other end hangs */
	if (do_report)
	{
		int e = errno;
		PerlLIO_write(fd, (void *)&e, sizeof(e));
		PerlLIO_close(fd);
	}
}


struct popen_data
{
	struct Task *parent;
	STRPTR command;
};

static int popen_result = 0;

int popen_child()
{
	struct Task *thisTask = IExec->FindTask(0);
	struct popen_data *pd = (struct popen_data *)thisTask->tc_UserData;
	const char *argv[4];

	argv[0] = "sh";
	argv[1] = "-c";
	argv[2] = pd->command ? pd->command : NULL;
	argv[3] = NULL;

	// adebug("%s %ld  %s\n",__FUNCTION__,__LINE__,command?command:"NULL");

	/* We need to give this to sh via execvp, execvp expects filename,
	 * argv[]
	 */
	IExec->ObtainSemaphore(&popen_sema);

	IExec->Signal(pd->parent,SIGBREAKF_CTRL_F);

	popen_result = myexecvp(FALSE, argv[0], (char **)argv);
	if (pd->command)
		IExec->FreeVec(pd->command);
	IExec->FreeVec(pd);

	IExec->ReleaseSemaphore(&popen_sema);
	IExec->Forbid();
	return 0;
}


PerlIO *Perl_my_popen(pTHX_ const char *cmd, const char *mode)
{

	PERL_FLUSHALL_FOR_CHILD;
	PerlIO *result = NULL;
	char pipe_name[50];
	char unix_pipe[50];
	char ami_pipe[50];
	BPTR input = 0;
	BPTR output = 0;
	struct Process *proc = NULL;
	struct Task *thisTask = IExec->FindTask(0);
	struct popen_data * pd = NULL;

	/* First we need to check the mode
	 * We can only have unidirectional pipes
	 */
	//    adebug("%s %ld cmd %s mode %s \n",__FUNCTION__,__LINE__,cmd,
	//    mode);

	switch (mode[0])
	{
	case 'r':
	case 'w':
		break;

	default:

		errno = EINVAL;
		return result;
	}

	/* Make a unique pipe name
	 * we need a unix one and an amigaos version (of the same pipe!)
	 * as were linking with libunix.
	 */

	sprintf(pipe_name, "%x%08lx/4096/0", pipenum++,
	        IUtility->GetUniqueID());
	sprintf(unix_pipe, "/PIPE/%s", pipe_name);
	sprintf(ami_pipe, "PIPE:%s", pipe_name);

	/* Now we open the AmigaOs Filehandles That we wil pass to our
	 * Sub process
	 */

	if (mode[0] == 'r')
	{
		/* A read mode pipe: Output from pipe input from Output() or NIL:*/
		/* First attempt to DUP Output() */
		input = IDOS->DupFileHandle(IDOS->Input());
		if(input == 0)
		{
			input = IDOS->Open("NIL:", MODE_READWRITE);
		}
		if (input != 0)
		{
			output = IDOS->Open(ami_pipe, MODE_NEWFILE);
		}
		result = PerlIO_open(unix_pipe, mode);
	}
	else
	{
		/* Open the write end first! */

		result = PerlIO_open(unix_pipe, mode);

		input = IDOS->Open(ami_pipe, MODE_OLDFILE);
		if (input != 0)
		{
			output = IDOS->DupFileHandle(IDOS->Output());
			if(output == 0)
			{
				output = IDOS->Open("NIL:", MODE_READWRITE);
			}
		}
	}
	if ((input == 0) || (output == 0) || (result == NULL))
	{
		/* Ouch stream opening failed */
		/* Close and bail */
		if (input)
			IDOS->Close(input);
		if (output)
			IDOS->Close(output);
		if(result)
		{
			PerlIO_close(result);
			result = NULL;
		}
		return result;
	}

	/* We have our streams now start our new process
	 * We're using a new process so that execve can modify the environment
	 * with messing things up for the shell that launched perl
	 * Copy cmd before we launch the subprocess as perl seems to waste
	 * no time in overwriting it! The subprocess will free the copy.
	 */

	if((pd = (struct popen_data*)IExec->AllocVecTags(sizeof(struct popen_data),AVT_Type,MEMF_SHARED,TAG_DONE)))
	{
		pd->parent = thisTask;
		if ((pd->command  = mystrdup(cmd)))
		{
			// adebug("%s %ld
			// %s\n",__FUNCTION__,__LINE__,cmd_copy?cmd_copy:"NULL");
			proc = IDOS->CreateNewProcTags(
			           NP_Entry, popen_child, NP_Child, TRUE, NP_StackSize,
			           ((struct Process *)thisTask)->pr_StackSize, NP_Input, input,
			           NP_Output, output, NP_Error, IDOS->ErrorOutput(),
			           NP_CloseError, FALSE, NP_Cli, TRUE, NP_Name,
			           "Perl: popen process", NP_UserData, (int)pd,
			           TAG_DONE);
		}
	}
	if(proc)
	{
		/* wait for the child be setup right */
		IExec->Wait(SIGBREAKF_CTRL_F);
	}
	if (!proc)
	{
		/* New Process Failed to start
		 * Close and bail out
		 */
		if(pd)
		{
			if(pd->command)
			{
				IExec->FreeVec(pd->command);
			}
			IExec->FreeVec(pd);
		}
		if (input)
			IDOS->Close(input);
		if (output)
			IDOS->Close(output);
		if(result)
		{
			PerlIO_close(result);
			result = NULL;
		}
	}

	/* Our new process is running and will close it streams etc
	 * once its done. All we need to is open the pipe via stdio
	 */

	return result;
}

I32
Perl_my_pclose(pTHX_ PerlIO *ptr)
{
	int result = -1;
	/* close the file before obtaining the semaphore else we might end up
	   hanging waiting for the child to read the last bit from the pipe */
	PerlIO_close(ptr);
	IExec->ObtainSemaphore(&popen_sema);
	result = popen_result;
	IExec->ReleaseSemaphore(&popen_sema);
	return result;
}


#ifdef USE_ITHREADS

/* An arbitrary number to start with, should work out what the real max should
 * be */

#ifndef MAX_THREADS
#  define MAX_THREADS 64
#endif

#define REAPED 0
#define ACTIVE 1
#define EXITED -1

struct thread_info
{
	pthread_t ti_pid;
	int ti_children;
	pthread_t ti_parent;
	struct MsgPort *ti_port;
	struct Process *ti_Process;
};

static struct thread_info pseudo_children[MAX_THREADS];
static int num_pseudo_children = 0;
static struct SignalSemaphore fork_array_sema;

void amigaos4_init_fork_array()
{
	IExec->InitSemaphore(&fork_array_sema);
	pseudo_children[0].ti_pid = (pthread_t)IExec->FindTask(0);
	pseudo_children[0].ti_parent = -1;
	pseudo_children[0].ti_port =
	    (struct MsgPort *)IExec->AllocSysObjectTags(ASOT_PORT, TAG_DONE);
}

void amigaos4_dispose_fork_array()
{
	while (pseudo_children[0].ti_children > 0)
	{
		void *msg;
		IExec->WaitPort(pseudo_children[0].ti_port);
		msg = IExec->GetMsg(pseudo_children[0].ti_port);
		if (msg)
			IExec->FreeSysObject(ASOT_MESSAGE, msg);
		pseudo_children[0].ti_children--;
	}
	IExec->FreeSysObject(ASOT_PORT, pseudo_children[0].ti_port);
}

struct thread_exit_message
{
	struct Message tem_Message;
	pthread_t tem_pid;
	int tem_status;
};

int getnextchild()
{
	int i;
	for (i = 0; i < MAX_THREADS; i++)
	{
		if (pseudo_children[i].ti_pid == 0)
			return i;
	}
	return -1;
}

int findparent(pthread_t pid)
{
	int i;
	for (i = 0; i < MAX_THREADS; i++)
	{
		if (pseudo_children[i].ti_pid == pid)
			return i;
	}
	return -1;
}

struct child_arg
{
	struct Task *ca_parent_task;
	pthread_t ca_parent;
	PerlInterpreter *ca_interp;
};

#undef kill

/* FIXME: Is here's a chance, albeit it small of a clash between our pseudo pid */
/* derived from the pthread API  and the dos.library pid that newlib kill uses? */
/* clib2 used the Process address so there was no issue */

int amigaos_kill(Pid_t pid, int signal)
{
	int i;
	BOOL thistask = FALSE;
	Pid_t realpid = pid; // Perhaps we have a real pid from else where?
	/* Look for our DOS pid */
	IExec->ObtainSemaphore(&fork_array_sema);
	for (i = 0; i < MAX_THREADS; i++)
	{
		if (pseudo_children[i].ti_pid == pid)
		{
			realpid = (Pid_t)IDOS->GetPID(pseudo_children[i].ti_Process,GPID_PROCESS);
			if(pseudo_children[i].ti_Process == (struct Process *)IExec->FindTask(NULL))
			{
				thistask = TRUE;
			}
			break;
		}
	}
	IExec->ReleaseSemaphore(&fork_array_sema);
	/* Allow the C library to work out which signals are realy valid */
	if(thistask)
	{
		/* A quirk in newlib kill handling means it's better to call raise() rather than kill on out own task. */
		return raise(signal);
	}
	else
	{
		return kill(realpid,signal);
	}
}

static THREAD_RET_TYPE amigaos4_start_child(void *arg)
{

	PerlInterpreter *my_perl =
	    (PerlInterpreter *)((struct child_arg *)arg)->ca_interp;
	;

	GV *tmpgv;
	int status;
	int parent;
	int nextchild;
	pthread_t pseudo_id = pthread_self();

#ifdef PERL_SYNC_FORK
	static long sync_fork_id = 0;
	long id = ++sync_fork_id;
#endif

	/* before we do anything set up our process semaphore and add
	   a new entry to the pseudochildren */

	/* get next available slot */
	/* should not fail here! */

	IExec->ObtainSemaphore(&fork_array_sema);

	nextchild = getnextchild();

	pseudo_children[nextchild].ti_pid = pseudo_id;
	pseudo_children[nextchild].ti_Process = (struct Process *)IExec->FindTask(NULL);
	pseudo_children[nextchild].ti_parent =
	    ((struct child_arg *)arg)->ca_parent;
	pseudo_children[nextchild].ti_port =
	    (struct MsgPort *)IExec->AllocSysObjectTags(ASOT_PORT, TAG_DONE);

	num_pseudo_children++;
	IExec->ReleaseSemaphore(&fork_array_sema);

	/* We're set up let the parent continue */

	IExec->Signal(((struct child_arg *)arg)->ca_parent_task,
	              SIGBREAKF_CTRL_F);

	PERL_SET_THX(my_perl);
	if ((tmpgv = gv_fetchpv("$", TRUE, SVt_PV)))
	{
		SV *sv = GvSV(tmpgv);
		SvREADONLY_off(sv);
		sv_setiv(sv, (IV)pseudo_id);
		SvREADONLY_on(sv);
	}
	hv_clear(PL_pidstatus);

	/* push a zero on the stack (we are the child) */
	{
		dSP;
		dTARGET;
		PUSHi(0);
		PUTBACK;
	}

	/* continue from next op */
	PL_op = PL_op->op_next;

	{
		dJMPENV;
		volatile int 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_EXIT;
			break;
		case 3:
			if (PL_restartop)
			{
				POPSTACK_TO(PL_mainstack);
				PL_op = PL_restartop;
				PL_restartop = (OP *)NULL;
				;
				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 = (OP *)NULL;
	}

	{
		do_close(PL_stdingv, FALSE);
		do_close(gv_fetchpv("STDOUT", TRUE, SVt_PVIO),
		         FALSE); /* PL_stdoutgv - ISAGN */
		do_close(PL_stderrgv, FALSE);
	}

	/* destroy everything (waits for any pseudo-forked children) */

	/* wait for any remaining children */

	while (pseudo_children[nextchild].ti_children > 0)
	{
		if (IExec->WaitPort(pseudo_children[nextchild].ti_port))
		{
			void *msg =
			    IExec->GetMsg(pseudo_children[nextchild].ti_port);
			IExec->FreeSysObject(ASOT_MESSAGE, msg);
			pseudo_children[nextchild].ti_children--;
		}
	}
	if (PL_scopestack_ix <= 1)
	{
		perl_destruct(my_perl);
	}
	perl_free(my_perl);

	IExec->ObtainSemaphore(&fork_array_sema);
	parent = findparent(pseudo_children[nextchild].ti_parent);
	pseudo_children[nextchild].ti_pid = 0;
	pseudo_children[nextchild].ti_parent = 0;
	IExec->FreeSysObject(ASOT_PORT, pseudo_children[nextchild].ti_port);
	pseudo_children[nextchild].ti_port = NULL;

	IExec->ReleaseSemaphore(&fork_array_sema);

	{
		if (parent >= 0)
		{
			struct thread_exit_message *tem =
			    (struct thread_exit_message *)
			    IExec->AllocSysObjectTags(
			        ASOT_MESSAGE, ASOMSG_Size,
			        sizeof(struct thread_exit_message),
			        ASOMSG_Length,
			        sizeof(struct thread_exit_message));
			if (tem)
			{
				tem->tem_pid = pseudo_id;
				tem->tem_status = status;
				IExec->PutMsg(pseudo_children[parent].ti_port,
				              (struct Message *)tem);
			}
		}
	}
#ifdef PERL_SYNC_FORK
	return id;
#else
	return (void *)status;
#endif
}

#endif /* USE_ITHREADS */

Pid_t amigaos_fork()
{
	dTHX;
	pthread_t id;
	int handle;
	struct child_arg arg;
	if (num_pseudo_children >= MAX_THREADS)
	{
		errno = EAGAIN;
		return -1;
	}
	arg.ca_interp = perl_clone((PerlInterpreter *)aTHX, CLONEf_COPY_STACKS);
	arg.ca_parent_task = IExec->FindTask(NULL);
	arg.ca_parent =
	    pthread_self() ? pthread_self() : (pthread_t)IExec->FindTask(0);

	handle = pthread_create(&id, NULL, amigaos4_start_child, (void *)&arg);
	pseudo_children[findparent(arg.ca_parent)].ti_children++;

	IExec->Wait(SIGBREAKF_CTRL_F);

	PERL_SET_THX(aTHX); /* XXX perl_clone*() set TLS */
	if (handle)
	{
		errno = EAGAIN;
		return -1;
	}
	return id;
}

Pid_t amigaos_waitpid(pTHX_ int optype, Pid_t pid, void *argflags)
{
	int result;
	if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
	{
		result = pthread_join(pid, (void **)argflags);
	}
	else
	{
		while ((result = pthread_join(pid, (void **)argflags)) == -1 &&
		        errno == EINTR)
		{
			//          PERL_ASYNC_CHECK();
		}
	}
	return result;
}

void amigaos_fork_set_userdata(
    pTHX_ struct UserData *userdata, I32 did_pipes, int pp, SV **sp, SV **mark)
{
	userdata->parent = IExec->FindTask(0);
	userdata->did_pipes = did_pipes;
	userdata->pp = pp;
	userdata->sp = sp;
	userdata->mark = mark;
	userdata->my_perl = aTHX;
}

/* AmigaOS specific versions of #?exec#? solely for use in amigaos_system_child
 */

static void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report)
{
	const int e = errno;
//    PERL_ARGS_ASSERT_EXEC_FAILED;
	if (e)
	{
		if (ckWARN(WARN_EXEC))
			Perl_warner(aTHX_ packWARN(WARN_EXEC),
			            "Can't exec \"%s\": %s", cmd, Strerror(e));
	}
	if (do_report)
	{
		/* XXX silently ignore failures */
		PERL_UNUSED_RESULT(PerlLIO_write(fd, (void *)&e, sizeof(int)));
		PerlLIO_close(fd);
	}
}

static I32 S_do_amigaos_exec3(pTHX_ const char *incmd, int fd, int do_report)
{
	dVAR;
	const char **a;
	char *s;
	char *buf;
	char *cmd;
	/* Make a copy so we can change it */
	const Size_t cmdlen = strlen(incmd) + 1;
	I32 result = -1;

	PERL_ARGS_ASSERT_DO_EXEC3;

	Newx(buf, cmdlen, char);
	cmd = buf;
	memcpy(cmd, incmd, cmdlen);

	while (*cmd && isSPACE(*cmd))
		cmd++;

	/* see if there are shell metacharacters in it */

	if (*cmd == '.' && isSPACE(cmd[1]))
		goto doshell;

	if (strEQs(cmd, "exec") && isSPACE(cmd[4]))
		goto doshell;

	s = cmd;
	while (isWORDCHAR(*s))
		s++; /* catch VAR=val gizmo */
	if (*s == '=')
		goto doshell;

	for (s = cmd; *s; s++)
	{
		if (*s != ' ' && !isALPHA(*s) &&
		        strchr("$&*(){}[]'\";\\|?<>~`\n", *s))
		{
			if (*s == '\n' && !s[1])
			{
				*s = '\0';
				break;
			}
			/* handle the 2>&1 construct at the end */
			if (*s == '>' && s[1] == '&' && s[2] == '1' &&
			        s > cmd + 1 && s[-1] == '2' && isSPACE(s[-2]) &&
			        (!s[3] || isSPACE(s[3])))
			{
				const char *t = s + 3;

				while (*t && isSPACE(*t))
					++t;
				if (!*t && (PerlLIO_dup2(1, 2) != -1))
				{
					s[-2] = '\0';
					break;
				}
			}
doshell:
			PERL_FPU_PRE_EXEC
			result = myexecl(FALSE, PL_sh_path, "sh", "-c", cmd,
			                 (char *)NULL);
			PERL_FPU_POST_EXEC
			S_exec_failed(aTHX_ PL_sh_path, fd, do_report);
			amigaos_post_exec(fd, do_report);
			Safefree(buf);
			return result;
		}
	}

	Newx(PL_Argv, (s - cmd) / 2 + 2, const char *);
	PL_Cmd = savepvn(cmd, s - cmd);
	a = PL_Argv;
	for (s = PL_Cmd; *s;)
	{
		while (isSPACE(*s))
			s++;
		if (*s)
			*(a++) = s;
		while (*s && !isSPACE(*s))
			s++;
		if (*s)
			*s++ = '\0';
	}
	*a = NULL;
	if (PL_Argv[0])
	{
		PERL_FPU_PRE_EXEC
		result = myexecvp(FALSE, PL_Argv[0], EXEC_ARGV_CAST(PL_Argv));
		PERL_FPU_POST_EXEC
		if (errno == ENOEXEC)
		{
			/* for system V NIH syndrome */
			do_execfree();
			goto doshell;
		}
		S_exec_failed(aTHX_ PL_Argv[0], fd, do_report);
		amigaos_post_exec(fd, do_report);
	}
	do_execfree();
	Safefree(buf);
	return result;
}

I32 S_do_amigaos_aexec5(
    pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report)
{
	dVAR;
	I32 result = -1;
	PERL_ARGS_ASSERT_DO_AEXEC5;
	if (sp > mark)
	{
		const char **a;
		const char *tmps = NULL;
		Newx(PL_Argv, sp - mark + 1, const char *);
		a = PL_Argv;

		while (++mark <= sp)
		{
			if (*mark)
				*a++ = SvPV_nolen_const(*mark);
			else
				*a++ = "";
		}
		*a = NULL;
		if (really)
			tmps = SvPV_nolen_const(really);
		if ((!really && *PL_Argv[0] != '/') ||
		        (really && *tmps != '/')) /* will execvp use PATH? */
			TAINT_ENV(); /* testing IFS here is overkill, probably
                                        */
		PERL_FPU_PRE_EXEC
		if (really && *tmps)
		{
			result = myexecvp(FALSE, tmps, EXEC_ARGV_CAST(PL_Argv));
		}
		else
		{
			result = myexecvp(FALSE, PL_Argv[0],
			                  EXEC_ARGV_CAST(PL_Argv));
		}
		PERL_FPU_POST_EXEC
		S_exec_failed(aTHX_(really ? tmps : PL_Argv[0]), fd, do_report);
	}
	amigaos_post_exec(fd, do_report);
	do_execfree();
	return result;
}

void *amigaos_system_child(void *userdata)
{
	struct Task *parent;
	I32 did_pipes;
	int pp;
	I32 value;
	STRLEN n_a;
	/* these next are declared by macros else where but I may be
	 * passing modified values here so declare them explictly but
	 * still referred to by macro below */

	register SV **sp;
	register SV **mark;
	register PerlInterpreter *my_perl;

	StdioStore store;

	struct UserData *ud = (struct UserData *)userdata;

	did_pipes = ud->did_pipes;
	parent = ud->parent;
	pp = ud->pp;
	SP = ud->sp;
	MARK = ud->mark;
	my_perl = ud->my_perl;
	PERL_SET_THX(my_perl);

	amigaos_stdio_save(aTHX_ & store);

	if (did_pipes)
	{
		//    PerlLIO_close(pp[0]);
	}
	if (PL_op->op_flags & OPf_STACKED)
	{
		SV *really = *++MARK;
		value = (I32)S_do_amigaos_aexec5(aTHX_ really, MARK, SP, pp,
		                                 did_pipes);
	}
	else if (SP - MARK != 1)
	{
		value = (I32)S_do_amigaos_aexec5(aTHX_ NULL, MARK, SP, pp,
		                                 did_pipes);
	}
	else
	{
		value = (I32)S_do_amigaos_exec3(
		            aTHX_ SvPVx(sv_mortalcopy(*SP), n_a), pp, did_pipes);
	}

	//    Forbid();
	//    Signal(parent, SIGBREAKF_CTRL_F);

	amigaos_stdio_restore(aTHX_ & store);

	return (void *)value;
}

static BOOL contains_whitespace(char *string)
{

	if (string)
	{

		if (strchr(string, ' '))
			return TRUE;
		if (strchr(string, '\t'))
			return TRUE;
		if (strchr(string, '\n'))
			return TRUE;
		if (strchr(string, 0xA0))
			return TRUE;
		if (strchr(string, '"'))
			return TRUE;
	}
	return FALSE;
}

static int no_of_escapes(char *string)
{
	int cnt = 0;
	char *p;
	for (p = string; p < string + strlen(string); p++)
	{
		if (*p == '"')
			cnt++;
		if (*p == '*')
			cnt++;
		if (*p == '\n')
			cnt++;
		if (*p == '\t')
			cnt++;
	}
	return cnt;
}

struct command_data
{
	STRPTR args;
	BPTR seglist;
	struct Task *parent;
};

#undef fopen
#undef fgetc
#undef fgets
#undef fclose

#define __USE_RUNCOMMAND__

int myexecve(bool isperlthread,
             const char *filename,
             char *argv[],
             char *envp[])
{
	FILE *fh;
	char buffer[1000];
	int size = 0;
	char **cur;
	char *interpreter = 0;
	char *interpreter_args = 0;
	char *full = 0;
	char *filename_conv = 0;
	char *interpreter_conv = 0;
	//        char *tmp = 0;
	char *fname;
	//        int tmpint;
	//        struct Task *thisTask = IExec->FindTask(0);
	int result = -1;

	StdioStore store;

	pTHX = NULL;

	if (isperlthread)
	{
		aTHX = PERL_GET_THX;
		/* Save away our stdio */
		amigaos_stdio_save(aTHX_ & store);
	}

	// adebug("%s %ld %s\n",__FUNCTION__,__LINE__,filename?filename:"NULL");

	/* Calculate the size of filename and all args, including spaces and
	 * quotes */
	size = 0; // strlen(filename) + 1;
	for (cur = (char **)argv /* +1 */; *cur; cur++)
	{
		size +=
		    strlen(*cur) + 1 +
		    (contains_whitespace(*cur) ? (2 + no_of_escapes(*cur)) : 0);
	}
	/* Check if it's a script file */
	IExec->DebugPrintF("%s %ld %08lx %c %c\n",__FILE__,__LINE__,filename,filename[0],filename[1]);
	fh = fopen(filename, "r");
	if (fh)
	{
		if (fgetc(fh) == '#' && fgetc(fh) == '!')
		{
			char *p;
			char *q;
			fgets(buffer, 999, fh);
			p = buffer;
			while (*p == ' ' || *p == '\t')
				p++;
			if (buffer[strlen(buffer) - 1] == '\n')
				buffer[strlen(buffer) - 1] = '\0';
			if ((q = strchr(p, ' ')))
			{
				*q++ = '\0';
				if (*q != '\0')
				{
					interpreter_args = mystrdup(q);
				}
			}
			else
				interpreter_args = mystrdup("");

			interpreter = mystrdup(p);
			size += strlen(interpreter) + 1;
			size += strlen(interpreter_args) + 1;
		}

		fclose(fh);
	}
	else
	{
		/* We couldn't open this why not? */
		if (errno == ENOENT)
		{
			/* file didn't exist! */
			goto out;
		}
	}

	/* Allocate the command line */
	filename_conv = convert_path_u2a(filename);

	if (filename_conv)
		size += strlen(filename_conv);
	size += 1;
	full = (char *)IExec->AllocVecTags(size + 10, AVT_ClearWithValue, 0 ,TAG_DONE);
	if (full)
	{
		if (interpreter)
		{
			interpreter_conv = convert_path_u2a(interpreter);
#if !defined(__USE_RUNCOMMAND__)
#warning(using system!)
			sprintf(full, "%s %s %s ", interpreter_conv,
			        interpreter_args, filename_conv);
#else
			sprintf(full, "%s %s ", interpreter_args,
			        filename_conv);
#endif
			IExec->FreeVec(interpreter);
			IExec->FreeVec(interpreter_args);

			if (filename_conv)
				IExec->FreeVec(filename_conv);
			fname = mystrdup(interpreter_conv);

			if (interpreter_conv)
				IExec->FreeVec(interpreter_conv);
		}
		else
		{
#ifndef __USE_RUNCOMMAND__
			sprintf(full, "%s ", filename_conv);
#else
			sprintf(full, "");
#endif
			fname = mystrdup(filename_conv);
			if (filename_conv)
				IExec->FreeVec(filename_conv);
		}

		for (cur = (char **)(argv + 1); *cur != 0; cur++)
		{
			if (contains_whitespace(*cur))
			{
				int esc = no_of_escapes(*cur);

				if (esc > 0)
				{
					char *buff = (char *)IExec->AllocVecTags(
					                 strlen(*cur) + 4 + esc,
					                 AVT_ClearWithValue,0,
					                 TAG_DONE);
					char *p = *cur;
					char *q = buff;

					*q++ = '"';
					while (*p != '\0')
					{

						if (*p == '\n')
						{
							*q++ = '*';
							*q++ = 'N';
							p++;
							continue;
						}
						else if (*p == '"')
						{
							*q++ = '*';
							*q++ = '"';
							p++;
							continue;
						}
						else if (*p == '*')
						{
							*q++ = '*';
						}
						*q++ = *p++;
					}
					*q++ = '"';
					*q++ = ' ';
					*q = '\0';
					strcat(full, buff);
					IExec->FreeVec(buff);
				}
				else
				{
					strcat(full, "\"");
					strcat(full, *cur);
					strcat(full, "\" ");
				}
			}
			else
			{
				strcat(full, *cur);
				strcat(full, " ");
			}
		}
		strcat(full, "\n");

//            if(envp)
//                 createvars(envp);

#ifndef __USE_RUNCOMMAND__
		result = IDOS->SystemTags(
		             full, SYS_UserShell, TRUE, NP_StackSize,
		             ((struct Process *)thisTask)->pr_StackSize, SYS_Input,
		             ((struct Process *)thisTask)->pr_CIS, SYS_Output,
		             ((struct Process *)thisTask)->pr_COS, SYS_Error,
		             ((struct Process *)thisTask)->pr_CES, TAG_DONE);
#else

		if (fname)
		{
			BPTR seglist = IDOS->LoadSeg(fname);
			if (seglist)
			{
				/* check if we have an executable! */
				struct PseudoSegList *ps = NULL;
				if (!IDOS->GetSegListInfoTags(
				            seglist, GSLI_Native, &ps, TAG_DONE))
				{
					IDOS->GetSegListInfoTags(
					    seglist, GSLI_68KPS, &ps, TAG_DONE);
				}
				if (ps != NULL)
				{
					//                    adebug("%s %ld %s
					//                    %s\n",__FUNCTION__,__LINE__,fname,full);
					IDOS->SetCliProgramName(fname);
					//                        result=RunCommand(seglist,8*1024,full,strlen(full));
					//                        result=myruncommand(seglist,8*1024,full,strlen(full),envp);
					result = myruncommand(seglist, 8 * 1024,
					                      full, -1, envp);
					errno = 0;
				}
				else
				{
					errno = ENOEXEC;
				}
				IDOS->UnLoadSeg(seglist);
			}
			else
			{
				errno = ENOEXEC;
			}
			IExec->FreeVec(fname);
		}

#endif /* USE_RUNCOMMAND */

		IExec->FreeVec(full);
		if (errno == ENOEXEC)
		{
			result = -1;
		}
		goto out;
	}

	if (interpreter)
		IExec->FreeVec(interpreter);
	if (filename_conv)
		IExec->FreeVec(filename_conv);

	errno = ENOMEM;

out:
	if (isperlthread)
	{
		amigaos_stdio_restore(aTHX_ & store);
		STATUS_NATIVE_CHILD_SET(result);
		PL_exit_flags |= PERL_EXIT_EXPECTED;
		if (result != -1)
			my_exit(result);
	}
	return (result);
}