// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // Common code useful to all crt0 variants. This is kept in the DLL to allow us to

 // change it in future releases.

 // 

 //

 #include <e32std.h>

 #include <e32base.h>

 #include <estlib.h>

 #include <unistd.h>	// for chdir

 #include <stdlib.h>	// for calloc

 #include <string.h>	// for strdup

 const TInt KMaxArgC=25;

 static char* wcstombs_alloc (const wchar_t* aString)

 	{

 	if (aString==NULL)

 		return NULL;

 	size_t size = wcstombs(0, aString, 0);

 	char* buf = (char*)malloc(size * sizeof(char));

 	size = wcstombs(buf, aString, size);

 	if (size == (size_t) -1)

 		{

 		free(buf);

 		return NULL;

 		}

 	buf = (char*)realloc(buf, (size+1) * sizeof(char));

 	return buf;

 	}

 #ifdef EKA2

 static wchar_t* allocCommandLine(const TDesC& aPath)

 	{

     TInt cmdLength = User::CommandLineLength()+1;	// for zero termination

 	TText16* cmdbuf = (TText16*)malloc(cmdLength*sizeof(TText16));

 	if (cmdbuf==0)

 		return (wchar_t*)cmdbuf;		// we are just doomed, so give up now

 	TPtr16 cmdline(cmdbuf, cmdLength);

     User::CommandLine(cmdline);	

 	// The .EXE recogniser supplies a command line which is the name of the file,

 	// followed by a space. This is usually not what's wanted, so remove the

 	// filename if it is an exact match for the start of the command line.

 	if (cmdline.Find(aPath)==0)

 		{

 		cmdline.Delete(0, aPath.Length());

 		}

 	cmdline.ZeroTerminate();

 	return (wchar_t*)cmdbuf;

 	}

 #else//EKA2

 static wchar_t* allocCommandLine(const TDesC& aPath)

 	{

 	RProcess me;

 	TInt cmdLength = me.CommandLineLength()+1;	// for zero termination

 	TText16* cmdbuf = (TText16*)malloc(cmdLength*sizeof(TText16));

 	if (cmdbuf==0)

 		return (wchar_t*)cmdbuf;		// we are just doomed, so give up now

 	TPtr16 cmdline(cmdbuf, cmdLength);

 	me.CommandLine(cmdline);	

 	// The .EXE recogniser supplies a command line which is the name of the file,

 	// followed by a space. This is usually not what's wanted, so remove the

 	// filename if it is an exact match for the start of the command line.

 	if (cmdline.Find(aPath)==0)

 		{

 		cmdline.Delete(0, aPath.Length());

 		}

 	cmdline.ZeroTerminate();

 	return (wchar_t*)cmdbuf;

 	}

 #endif//EKA2

 EXPORT_C void __crt0(int& argc, char**& argv, char**& envp)

 	{     

 	// Find out the filename for argv[0]

 	TBuf16<KMaxFileName+1> exepath(RProcess().FileName());

 	// Sort out argc/argv, creating an array of pointers into a copy of

 	// the commandline.

 	wchar_t* cmdbuf = allocCommandLine(exepath);

 	char* cmd = wcstombs_alloc(cmdbuf);

 	free(cmdbuf);

 	char* filename = wcstombs_alloc((const wchar_t *)exepath.PtrZ());

 	argv = (char**)calloc(KMaxArgC, sizeof(char*));

 	// Check for memory allocation failures.

 	if (argv==0 || cmd==0 || filename== 0)

 		{

 		// Free any memory that could have been allocated before returning.

 		free(cmd);

 		free(filename);

 		return;		// it's basically doomed at this point anyway	

 		}

 	// Split the command line into the separate arguments

 	// Follow the stdarg.c rules in the Win32 runtime, namely

 	// 1. space and tab are whitespace separators, except inside "..." pairs

 	// 2. strings of \ are literal unless followed by " (see below)

 	// 3. a pair of "" in a quoted string is a literal "

 	const char KSpace= ' ';

 	const char KTab  = '\t';

 	const char KQuote= '"';

 	const char KSlash= '\\';

 	argv[0]=filename;

 	argc = 1;

 	char *q = cmd;

 	const char* p = cmd;

 	FOREVER

 		{

 		char c;

 		TInt quoted=0;

 		// skip leading whitespace

 		do	

 			c=*p++;

 		while (c && (c==KSpace || c==KTab));

 		// update the argv,argc

 		if (c=='\0' || argc>=KMaxArgC)

 			break;

 		argv[argc] = q;

 		argc++;

 		// copy the argument from p to q

 		for (;c!='\0';c=*p++)

 			{

 			// The UNC filenames format used, e.g. \\host\dir\file

 			// Hence the rather odd rules: for N>=0

 			// 2N+1 slash + " => N slash + literal "

 			// 2N   slash + " => N slash, start/end quoted substring

 			// N    slash + ? => N slash + ?

 			int slashcount=0;

 			while (c==KSlash)

 				{

 				*q++=c;		// copy the slashes (might be too many)

 				slashcount++;

 				c=*p++;

 				}

 			if (c=='\0')

 				break;

 			if (c==KQuote)

 				{

 				q-=(slashcount-(slashcount/2));	// slashes followed by quote - adjust

 				if (slashcount&1)

 					{

 					*q++=c;		// literal quote

 					continue;

 					}

 				if (quoted && *p==KQuote)

 					{

 					p++;

 					*q++=c;		// "" inside quoted section = literal quote

 					continue;

 					}

 				quoted=!quoted;

 				continue;

 				}

 			if (!quoted && (c==KSpace || c==KTab))

 				break;

 			*q++=c;

 			}

 		*q++='\0';	// terminate the copy

 		if (c=='\0')

 			break;	// end of command line

 		}

 	// sort out the environment

 	envp=0;

 	}

 EXPORT_C void __crt0(int& argc, wchar_t**& wargv, wchar_t**& wenvp)

 	{     

 	// Find out the filename for argv[0]

 	TBuf16<KMaxFileName+1> exepath(RProcess().FileName());

 	// Sort out argc/argv, creating an array of pointers into a copy of

 	// the commandline.

 	wchar_t* cmd = allocCommandLine(exepath);

 	wchar_t* filename = wcsdup((const wchar_t *)exepath.PtrZ());

 	wargv = (wchar_t**)calloc(KMaxArgC, sizeof(wchar_t*));

 	// Check for memory allocation failures.

 	if (wargv==0 || cmd==0 || filename== 0)

 		{

 		// Free any memory that could have been allocated before returning.

 		free(cmd);

 		free(filename);

 		return;		// it's basically doomed at this point anyway	

 		}

 	// Split the command line into the separate arguments

 	// Follow the stdarg.c rules in the Win32 runtime, namely

 	// 1. space and tab are whitespace separators, except inside "..." pairs

 	// 2. strings of \ are literal unless followed by " (see below)

 	// 3. a pair of "" in a quoted string is a literal "

 	const wchar_t KSpace= L' ';

 	const wchar_t KTab  = L'\t';

 	const wchar_t KQuote= L'"';

 	const wchar_t KSlash= L'\\';

 	wargv[0]=filename;

 	argc = 1;

 	wchar_t *q = cmd;

 	wchar_t *p = cmd;

 	FOREVER

 		{

 		wchar_t c;

 		TInt quoted=0;

 		// skip leading whitespace

 		do	

 			c=*p++;

 		while (c && (c==KSpace || c==KTab));

 		// update the argv,argc

 		if (c=='\0' || argc>=KMaxArgC)

 			break;

 		wargv[argc] = q;

 		argc++;

 		// copy the argument from p to q

 		for (;c!=L'\0';c=*p++)

 			{

 			// The UNC filenames format used, e.g. \\host\dir\file

 			// Hence the rather odd rules: for N>=0

 			// 2N+1 slash + " => N slash + literal "

 			// 2N   slash + " => N slash, start/end quoted substring

 			// N    slash + ? => N slash + ?

 			int slashcount=0;

 			while (c==KSlash)

 				{

 				*q++=c;		// copy the slashes (might be too many)

 				slashcount++;

 				c=*p++;

 				}

 			if (c==L'\0')

 				break;

 			if (c==KQuote)

 				{

 				q-=(slashcount-(slashcount/2));	// slashes followed by quote - adjust

 				if (slashcount&1)

 					{

 					*q++=c;		// literal quote

 					continue;

 					}

 				if (quoted && *p==KQuote)

 					{

 					p++;

 					*q++=c;		// "" inside quoted section = literal quote

 					continue;

 					}

 				quoted=!quoted;

 				continue;

 				}

 			if (!quoted && (c==KSpace || c==KTab))

 				break;

 			*q++=c;

 			}

 		*q++=L'\0';	// terminate the copy

 		if (c==L'\0')

 			break;	// end of command line

 		}

 	// sort out the environment

 	wenvp=0;

 	}