/* 

 * tclUtil.c --

 *

 *	This file contains utility procedures that are used by many Tcl

 *	commands.

 *

 * Copyright (c) 1987-1993 The Regents of the University of California.

 * Copyright (c) 1994-1998 Sun Microsystems, Inc.

 * Copyright (c) 2001 by Kevin B. Kenny.  All rights reserved.

 * Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.  

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 *  RCS: @(#) $Id: tclUtil.c,v 1.36.2.8 2007/05/10 18:23:58 dgp Exp $

 */

#include "tclInt.h"

#include "tclPort.h"

#if defined(__SYMBIAN32__) 

#include "tclSymbianGlobals.h"

#endif 

/*

 * The following variable holds the full path name of the binary

 * from which this application was executed, or NULL if it isn't

 * know.  The value of the variable is set by the procedure

 * Tcl_FindExecutable.  The storage space is dynamically allocated.

 */

#if !defined(__SYMBIAN32__) || !defined(__WINSCW__)

char *tclExecutableName = NULL;

char *tclNativeExecutableName = NULL;

#endif

/*

 * The following values are used in the flags returned by Tcl_ScanElement

 * and used by Tcl_ConvertElement.  The value TCL_DONT_USE_BRACES is also

 * defined in tcl.h;  make sure its value doesn't overlap with any of the

 * values below.

 *

 * TCL_DONT_USE_BRACES -	1 means the string mustn't be enclosed in

 *				braces (e.g. it contains unmatched braces,

 *				or ends in a backslash character, or user

 *				just doesn't want braces);  handle all

 *				special characters by adding backslashes.

 * USE_BRACES -			1 means the string contains a special

 *				character that can be handled simply by

 *				enclosing the entire argument in braces.

 * BRACES_UNMATCHED -		1 means that braces aren't properly matched

 *				in the argument.

 */

#define USE_BRACES		2

#define BRACES_UNMATCHED	4

/*

 * The following values determine the precision used when converting

 * floating-point values to strings.  This information is linked to all

 * of the tcl_precision variables in all interpreters via the procedure

 * TclPrecTraceProc.

 */

static char precisionString[10] = "12";

				/* The string value of all the tcl_precision

				 * variables. */

static char precisionFormat[10] = "%.12g";

				/* The format string actually used in calls

				 * to sprintf. */

TCL_DECLARE_MUTEX(precisionMutex)

/*

 * Prototypes for procedures defined later in this file.

 */

static void UpdateStringOfEndOffset _ANSI_ARGS_((Tcl_Obj* objPtr));

static int SetEndOffsetFromAny _ANSI_ARGS_((Tcl_Interp* interp,

					    Tcl_Obj* objPtr));

/*

 * The following is the Tcl object type definition for an object

 * that represents a list index in the form, "end-offset".  It is

 * used as a performance optimization in TclGetIntForIndex.  The

 * internal rep is an integer, so no memory management is required

 * for it.

 */

Tcl_ObjType tclEndOffsetType = {

    "end-offset",			/* name */

    (Tcl_FreeInternalRepProc*) NULL,    /* freeIntRepProc */

    (Tcl_DupInternalRepProc*) NULL,     /* dupIntRepProc */

    UpdateStringOfEndOffset,		/* updateStringProc */

    SetEndOffsetFromAny    

};

/*

 *----------------------------------------------------------------------

 *

 * TclFindElement --

 *

 *	Given a pointer into a Tcl list, locate the first (or next)

 *	element in the list.

 *

 * Results:

 *	The return value is normally TCL_OK, which means that the

 *	element was successfully located.  If TCL_ERROR is returned

 *	it means that list didn't have proper list structure;

 *	the interp's result contains a more detailed error message.

 *

 *	If TCL_OK is returned, then *elementPtr will be set to point to the

 *	first element of list, and *nextPtr will be set to point to the

 *	character just after any white space following the last character

 *	that's part of the element. If this is the last argument in the

 *	list, then *nextPtr will point just after the last character in the

 *	list (i.e., at the character at list+listLength). If sizePtr is

 *	non-NULL, *sizePtr is filled in with the number of characters in the

 *	element.  If the element is in braces, then *elementPtr will point

 *	to the character after the opening brace and *sizePtr will not

 *	include either of the braces. If there isn't an element in the list,

 *	*sizePtr will be zero, and both *elementPtr and *termPtr will point

 *	just after the last character in the list. Note: this procedure does

 *	NOT collapse backslash sequences.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

int

TclFindElement(interp, list, listLength, elementPtr, nextPtr, sizePtr,

	       bracePtr)

    Tcl_Interp *interp;		/* Interpreter to use for error reporting. 

				 * If NULL, then no error message is left

				 * after errors. */

    CONST char *list;		/* Points to the first byte of a string

				 * containing a Tcl list with zero or more

				 * elements (possibly in braces). */

    int listLength;		/* Number of bytes in the list's string. */

    CONST char **elementPtr;	/* Where to put address of first significant

				 * character in first element of list. */

    CONST char **nextPtr;	/* Fill in with location of character just

				 * after all white space following end of

				 * argument (next arg or end of list). */

    int *sizePtr;		/* If non-zero, fill in with size of

				 * element. */

    int *bracePtr;		/* If non-zero, fill in with non-zero/zero

				 * to indicate that arg was/wasn't

				 * in braces. */

{

    CONST char *p = list;

    CONST char *elemStart;	/* Points to first byte of first element. */

    CONST char *limit;		/* Points just after list's last byte. */

    int openBraces = 0;		/* Brace nesting level during parse. */

    int inQuotes = 0;

    int size = 0;		/* lint. */

    int numChars;

    CONST char *p2;

    /*

     * Skim off leading white space and check for an opening brace or

     * quote. We treat embedded NULLs in the list as bytes belonging to

     * a list element.

     */

    limit = (list + listLength);

    while ((p < limit) && (isspace(UCHAR(*p)))) { /* INTL: ISO space. */

	p++;

    }

    if (p == limit) {		/* no element found */

	elemStart = limit;

	goto done;

    }

    if (*p == '{') {

	openBraces = 1;

	p++;

    } else if (*p == '"') {

	inQuotes = 1;

	p++;

    }

    elemStart = p;

    if (bracePtr != 0) {

	*bracePtr = openBraces;

    }

    /*

     * Find element's end (a space, close brace, or the end of the string).

     */

    while (p < limit) {

	switch (*p) {

	    /*

	     * Open brace: don't treat specially unless the element is in

	     * braces. In this case, keep a nesting count.

	     */

	    case '{':

		if (openBraces != 0) {

		    openBraces++;

		}

		break;

	    /*

	     * Close brace: if element is in braces, keep nesting count and

	     * quit when the last close brace is seen.

	     */

	    case '}':

		if (openBraces > 1) {

		    openBraces--;

		} else if (openBraces == 1) {

		    size = (p - elemStart);

		    p++;

		    if ((p >= limit)

			    || isspace(UCHAR(*p))) { /* INTL: ISO space. */

			goto done;

		    }

		    /*

		     * Garbage after the closing brace; return an error.

		     */

		    if (interp != NULL) {

			char buf[100];

			p2 = p;

			while ((p2 < limit)

				&& (!isspace(UCHAR(*p2))) /* INTL: ISO space. */

			        && (p2 < p+20)) {

			    p2++;

			}

			sprintf(buf,

				"list element in braces followed by \"%.*s\" instead of space",

				(int) (p2-p), p);

			Tcl_SetResult(interp, buf, TCL_VOLATILE);

		    }

		    return TCL_ERROR;

		}

		break;

	    /*

	     * Backslash:  skip over everything up to the end of the

	     * backslash sequence.

	     */

	    case '\\': {

		Tcl_UtfBackslash(p, &numChars, NULL);

		p += (numChars - 1);

		break;

	    }

	    /*

	     * Space: ignore if element is in braces or quotes; otherwise

	     * terminate element.

	     */

	    case ' ':

	    case '\f':

	    case '\n':

	    case '\r':

	    case '\t':

	    case '\v':

		if ((openBraces == 0) && !inQuotes) {

		    size = (p - elemStart);

		    goto done;

		}

		break;

	    /*

	     * Double-quote: if element is in quotes then terminate it.

	     */

	    case '"':

		if (inQuotes) {

		    size = (p - elemStart);

		    p++;

		    if ((p >= limit)

			    || isspace(UCHAR(*p))) { /* INTL: ISO space */

			goto done;

		    }

		    /*

		     * Garbage after the closing quote; return an error.

		     */

		    if (interp != NULL) {

			char buf[100];

			p2 = p;

			while ((p2 < limit)

				&& (!isspace(UCHAR(*p2))) /* INTL: ISO space */

				 && (p2 < p+20)) {

			    p2++;

			}

			sprintf(buf,

				"list element in quotes followed by \"%.*s\" %s",

				(int) (p2-p), p, "instead of space");

			Tcl_SetResult(interp, buf, TCL_VOLATILE);

		    }

		    return TCL_ERROR;

		}

		break;

	}

	p++;

    }

    /*

     * End of list: terminate element.

     */

    if (p == limit) {

	if (openBraces != 0) {

	    if (interp != NULL) {

		Tcl_SetResult(interp, "unmatched open brace in list",

			TCL_STATIC);

	    }

	    return TCL_ERROR;

	} else if (inQuotes) {

	    if (interp != NULL) {

		Tcl_SetResult(interp, "unmatched open quote in list",

			TCL_STATIC);

	    }

	    return TCL_ERROR;

	}

	size = (p - elemStart);

    }

    done:

    while ((p < limit) && (isspace(UCHAR(*p)))) { /* INTL: ISO space. */

	p++;

    }

    *elementPtr = elemStart;

    *nextPtr = p;

    if (sizePtr != 0) {

	*sizePtr = size;

    }

    return TCL_OK;

}

/*

 *----------------------------------------------------------------------

 *

 * TclCopyAndCollapse --

 *

 *	Copy a string and eliminate any backslashes that aren't in braces.

 *

 * Results:

 *	Count characters get copied from src to	dst. Along the way, if

 *	backslash sequences are found outside braces, the backslashes are

 *	eliminated in the copy. After scanning count chars from source, a

 *	null character is placed at the end of dst.  Returns the number

 *	of characters that got copied.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

int

TclCopyAndCollapse(count, src, dst)

    int count;			/* Number of characters to copy from src. */

    CONST char *src;		/* Copy from here... */

    char *dst;			/* ... to here. */

{

    register char c;

    int numRead;

    int newCount = 0;

    int backslashCount;

    for (c = *src;  count > 0;  src++, c = *src, count--) {

	if (c == '\\') {

	    backslashCount = Tcl_UtfBackslash(src, &numRead, dst);

	    dst += backslashCount;

	    newCount += backslashCount;

	    src += numRead-1;

	    count -= numRead-1;

	} else {

	    *dst = c;

	    dst++;

	    newCount++;

	}

    }

    *dst = 0;

    return newCount;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_SplitList --

 *

 *	Splits a list up into its constituent fields.

 *

 * Results

 *	The return value is normally TCL_OK, which means that

 *	the list was successfully split up.  If TCL_ERROR is

 *	returned, it means that "list" didn't have proper list

 *	structure;  the interp's result will contain a more detailed

 *	error message.

 *

 *	*argvPtr will be filled in with the address of an array

 *	whose elements point to the elements of list, in order.

 *	*argcPtr will get filled in with the number of valid elements

 *	in the array.  A single block of memory is dynamically allocated

 *	to hold both the argv array and a copy of the list (with

 *	backslashes and braces removed in the standard way).

 *	The caller must eventually free this memory by calling free()

 *	on *argvPtr.  Note:  *argvPtr and *argcPtr are only modified

 *	if the procedure returns normally.

 *

 * Side effects:

 *	Memory is allocated.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C int

Tcl_SplitList(interp, list, argcPtr, argvPtr)

    Tcl_Interp *interp;		/* Interpreter to use for error reporting. 

				 * If NULL, no error message is left. */

    CONST char *list;		/* Pointer to string with list structure. */

    int *argcPtr;		/* Pointer to location to fill in with

				 * the number of elements in the list. */

    CONST char ***argvPtr;	/* Pointer to place to store pointer to

				 * array of pointers to list elements. */

{

    CONST char **argv;

    CONST char *l;

    char *p;

    int length, size, i, result, elSize, brace;

    CONST char *element;

    /*

     * Figure out how much space to allocate.  There must be enough

     * space for both the array of pointers and also for a copy of

     * the list.  To estimate the number of pointers needed, count

     * the number of space characters in the list.

     */

    for (size = 2, l = list; *l != 0; l++) {

	if (isspace(UCHAR(*l))) { /* INTL: ISO space. */

	    size++;

	    /* Consecutive space can only count as a single list delimiter */

	    while (1) {

		char next = *(l + 1);

		if (next == '\0') {

		    break;

		}

		++l;

		if (isspace(UCHAR(next))) {

		    continue;

		}

		break;

	    }

	}

    }

    length = l - list;

    argv = (CONST char **) ckalloc((unsigned)

	    ((size * sizeof(char *)) + length + 1));

    for (i = 0, p = ((char *) argv) + size*sizeof(char *);

	    *list != 0;  i++) {

	CONST char *prevList = list;

	result = TclFindElement(interp, list, length, &element,

				&list, &elSize, &brace);

	length -= (list - prevList);

	if (result != TCL_OK) {

	    ckfree((char *) argv);

	    return result;

	}

	if (*element == 0) {

	    break;

	}

	if (i >= size) {

	    ckfree((char *) argv);

	    if (interp != NULL) {

		Tcl_SetResult(interp, "internal error in Tcl_SplitList",

			TCL_STATIC);

	    }

	    return TCL_ERROR;

	}

	argv[i] = p;

	if (brace) {

	    memcpy((VOID *) p, (VOID *) element, (size_t) elSize);

	    p += elSize;

	    *p = 0;

	    p++;

	} else {

	    TclCopyAndCollapse(elSize, element, p);

	    p += elSize+1;

	}

    }

    argv[i] = NULL;

    *argvPtr = argv;

    *argcPtr = i;

    return TCL_OK;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ScanElement --

 *

 *	This procedure is a companion procedure to Tcl_ConvertElement.

 *	It scans a string to see what needs to be done to it (e.g. add

 *	backslashes or enclosing braces) to make the string into a

 *	valid Tcl list element.

 *

 * Results:

 *	The return value is an overestimate of the number of characters

 *	that will be needed by Tcl_ConvertElement to produce a valid

 *	list element from string.  The word at *flagPtr is filled in

 *	with a value needed by Tcl_ConvertElement when doing the actual

 *	conversion.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C int

Tcl_ScanElement(string, flagPtr)

    register CONST char *string; /* String to convert to list element. */

    register int *flagPtr;	 /* Where to store information to guide

				  * Tcl_ConvertCountedElement. */

{

    return Tcl_ScanCountedElement(string, -1, flagPtr);

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ScanCountedElement --

 *

 *	This procedure is a companion procedure to

 *	Tcl_ConvertCountedElement.  It scans a string to see what

 *	needs to be done to it (e.g. add backslashes or enclosing

 *	braces) to make the string into a valid Tcl list element.

 *	If length is -1, then the string is scanned up to the first

 *	null byte.

 *

 * Results:

 *	The return value is an overestimate of the number of characters

 *	that will be needed by Tcl_ConvertCountedElement to produce a

 *	valid list element from string.  The word at *flagPtr is

 *	filled in with a value needed by Tcl_ConvertCountedElement

 *	when doing the actual conversion.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C int

Tcl_ScanCountedElement(string, length, flagPtr)

    CONST char *string;		/* String to convert to Tcl list element. */

    int length;			/* Number of bytes in string, or -1. */

    int *flagPtr;		/* Where to store information to guide

				 * Tcl_ConvertElement. */

{

    int flags, nestingLevel;

    register CONST char *p, *lastChar;

    /*

     * This procedure and Tcl_ConvertElement together do two things:

     *

     * 1. They produce a proper list, one that will yield back the

     * argument strings when evaluated or when disassembled with

     * Tcl_SplitList.  This is the most important thing.

     * 

     * 2. They try to produce legible output, which means minimizing the

     * use of backslashes (using braces instead).  However, there are

     * some situations where backslashes must be used (e.g. an element

     * like "{abc": the leading brace will have to be backslashed.

     * For each element, one of three things must be done:

     *

     * (a) Use the element as-is (it doesn't contain any special

     * characters).  This is the most desirable option.

     *

     * (b) Enclose the element in braces, but leave the contents alone.

     * This happens if the element contains embedded space, or if it

     * contains characters with special interpretation ($, [, ;, or \),

     * or if it starts with a brace or double-quote, or if there are

     * no characters in the element.

     *

     * (c) Don't enclose the element in braces, but add backslashes to

     * prevent special interpretation of special characters.  This is a

     * last resort used when the argument would normally fall under case

     * (b) but contains unmatched braces.  It also occurs if the last

     * character of the argument is a backslash or if the element contains

     * a backslash followed by newline.

     *

     * The procedure figures out how many bytes will be needed to store

     * the result (actually, it overestimates). It also collects information

     * about the element in the form of a flags word.

     *

     * Note: list elements produced by this procedure and

     * Tcl_ConvertCountedElement must have the property that they can be

     * enclosing in curly braces to make sub-lists.  This means, for

     * example, that we must not leave unmatched curly braces in the

     * resulting list element.  This property is necessary in order for

     * procedures like Tcl_DStringStartSublist to work.

     */

    nestingLevel = 0;

    flags = 0;

    if (string == NULL) {

	string = "";

    }

    if (length == -1) {

	length = strlen(string);

    }

    lastChar = string + length;

    p = string;

    if ((p == lastChar) || (*p == '{') || (*p == '"')) {

	flags |= USE_BRACES;

    }

    for ( ; p < lastChar; p++) {

	switch (*p) {

	    case '{':

		nestingLevel++;

		break;

	    case '}':

		nestingLevel--;

		if (nestingLevel < 0) {

		    flags |= TCL_DONT_USE_BRACES|BRACES_UNMATCHED;

		}

		break;

	    case '[':

	    case '$':

	    case ';':

	    case ' ':

	    case '\f':

	    case '\n':

	    case '\r':

	    case '\t':

	    case '\v':

		flags |= USE_BRACES;

		break;

	    case '\\':

		if ((p+1 == lastChar) || (p[1] == '\n')) {

		    flags = TCL_DONT_USE_BRACES | BRACES_UNMATCHED;

		} else {

		    int size;

		    Tcl_UtfBackslash(p, &size, NULL);

		    p += size-1;

		    flags |= USE_BRACES;

		}

		break;

	}

    }

    if (nestingLevel != 0) {

	flags = TCL_DONT_USE_BRACES | BRACES_UNMATCHED;

    }

    *flagPtr = flags;

    /*

     * Allow enough space to backslash every character plus leave

     * two spaces for braces.

     */

    return 2*(p-string) + 2;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ConvertElement --

 *

 *	This is a companion procedure to Tcl_ScanElement.  Given

 *	the information produced by Tcl_ScanElement, this procedure

 *	converts a string to a list element equal to that string.

 *

 * Results:

 *	Information is copied to *dst in the form of a list element

 *	identical to src (i.e. if Tcl_SplitList is applied to dst it

 *	will produce a string identical to src).  The return value is

 *	a count of the number of characters copied (not including the

 *	terminating NULL character).

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C int

Tcl_ConvertElement(src, dst, flags)

    register CONST char *src;	/* Source information for list element. */

    register char *dst;		/* Place to put list-ified element. */

    register int flags;		/* Flags produced by Tcl_ScanElement. */

{

    return Tcl_ConvertCountedElement(src, -1, dst, flags);

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ConvertCountedElement --

 *

 *	This is a companion procedure to Tcl_ScanCountedElement.  Given

 *	the information produced by Tcl_ScanCountedElement, this

 *	procedure converts a string to a list element equal to that

 *	string.

 *

 * Results:

 *	Information is copied to *dst in the form of a list element

 *	identical to src (i.e. if Tcl_SplitList is applied to dst it

 *	will produce a string identical to src).  The return value is

 *	a count of the number of characters copied (not including the

 *	terminating NULL character).

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C int

Tcl_ConvertCountedElement(src, length, dst, flags)

    register CONST char *src;	/* Source information for list element. */

    int length;			/* Number of bytes in src, or -1. */

    char *dst;			/* Place to put list-ified element. */

    int flags;			/* Flags produced by Tcl_ScanElement. */

{

    register char *p = dst;

    register CONST char *lastChar;

    /*

     * See the comment block at the beginning of the Tcl_ScanElement

     * code for details of how this works.

     */

    if (src && length == -1) {

	length = strlen(src);

    }

    if ((src == NULL) || (length == 0)) {

	p[0] = '{';

	p[1] = '}';

	p[2] = 0;

	return 2;

    }

    lastChar = src + length;

    if ((flags & USE_BRACES) && !(flags & TCL_DONT_USE_BRACES)) {

	*p = '{';

	p++;

	for ( ; src != lastChar; src++, p++) {

	    *p = *src;

	}

	*p = '}';

	p++;

    } else {

	if (*src == '{') {

	    /*

	     * Can't have a leading brace unless the whole element is

	     * enclosed in braces.  Add a backslash before the brace.

	     * Furthermore, this may destroy the balance between open

	     * and close braces, so set BRACES_UNMATCHED.

	     */

	    p[0] = '\\';

	    p[1] = '{';

	    p += 2;

	    src++;

	    flags |= BRACES_UNMATCHED;

	}

	for (; src != lastChar; src++) {

	    switch (*src) {

		case ']':

		case '[':

		case '$':

		case ';':

		case ' ':

		case '\\':

		case '"':

		    *p = '\\';

		    p++;

		    break;

		case '{':

		case '}':

		    /*

		     * It may not seem necessary to backslash braces, but

		     * it is.  The reason for this is that the resulting

		     * list element may actually be an element of a sub-list

		     * enclosed in braces (e.g. if Tcl_DStringStartSublist

		     * has been invoked), so there may be a brace mismatch

		     * if the braces aren't backslashed.

		     */

		    if (flags & BRACES_UNMATCHED) {

			*p = '\\';

			p++;

		    }

		    break;

		case '\f':

		    *p = '\\';

		    p++;

		    *p = 'f';

		    p++;

		    continue;

		case '\n':

		    *p = '\\';

		    p++;

		    *p = 'n';

		    p++;

		    continue;

		case '\r':

		    *p = '\\';

		    p++;

		    *p = 'r';

		    p++;

		    continue;

		case '\t':

		    *p = '\\';

		    p++;

		    *p = 't';

		    p++;

		    continue;

		case '\v':

		    *p = '\\';

		    p++;

		    *p = 'v';

		    p++;

		    continue;

	    }

	    *p = *src;

	    p++;

	}

    }

    *p = '\0';

    return p-dst;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_Merge --

 *

 *	Given a collection of strings, merge them together into a

 *	single string that has proper Tcl list structured (i.e.

 *	Tcl_SplitList may be used to retrieve strings equal to the

 *	original elements, and Tcl_Eval will parse the string back

 *	into its original elements).

 *

 * Results:

 *	The return value is the address of a dynamically-allocated

 *	string containing the merged list.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C char *

Tcl_Merge(argc, argv)

    int argc;			/* How many strings to merge. */

    CONST char * CONST *argv;	/* Array of string values. */

{

#   define LOCAL_SIZE 20

    int localFlags[LOCAL_SIZE], *flagPtr;

    int numChars;

    char *result;

    char *dst;

    int i;

    /*

     * Pass 1: estimate space, gather flags.

     */

    if (argc <= LOCAL_SIZE) {

	flagPtr = localFlags;

    } else {

	flagPtr = (int *) ckalloc((unsigned) argc*sizeof(int));

    }

    numChars = 1;

    for (i = 0; i < argc; i++) {

	numChars += Tcl_ScanElement(argv[i], &flagPtr[i]) + 1;

    }

    /*

     * Pass two: copy into the result area.

     */

    result = (char *) ckalloc((unsigned) numChars);

    dst = result;

    for (i = 0; i < argc; i++) {

	numChars = Tcl_ConvertElement(argv[i], dst, flagPtr[i]);

	dst += numChars;

	*dst = ' ';

	dst++;

    }

    if (dst == result) {

	*dst = 0;

    } else {

	dst[-1] = 0;

    }

    if (flagPtr != localFlags) {

	ckfree((char *) flagPtr);

    }

    return result;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_Backslash --

 *

 *	Figure out how to handle a backslash sequence.

 *

 * Results:

 *	The return value is the character that should be substituted

 *	in place of the backslash sequence that starts at src.  If

 *	readPtr isn't NULL then it is filled in with a count of the

 *	number of characters in the backslash sequence.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C char

Tcl_Backslash(src, readPtr)

    CONST char *src;		/* Points to the backslash character of

				 * a backslash sequence. */

    int *readPtr;		/* Fill in with number of characters read

				 * from src, unless NULL. */

{

    char buf[TCL_UTF_MAX];

    Tcl_UniChar ch;

    Tcl_UtfBackslash(src, readPtr, buf);

    TclUtfToUniChar(buf, &ch);

    return (char) ch;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_Concat --

 *

 *	Concatenate a set of strings into a single large string.

 *

 * Results:

 *	The return value is dynamically-allocated string containing

 *	a concatenation of all the strings in argv, with spaces between

 *	the original argv elements.

 *

 * Side effects:

 *	Memory is allocated for the result;  the caller is responsible

 *	for freeing the memory.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C char *

Tcl_Concat(argc, argv)

    int argc;			/* Number of strings to concatenate. */

    CONST char * CONST *argv;	/* Array of strings to concatenate. */

{

    int totalSize, i;

    char *p;

    char *result;

    for (totalSize = 1, i = 0; i < argc; i++) {

	totalSize += strlen(argv[i]) + 1;

    }

    result = (char *) ckalloc((unsigned) totalSize);

    if (argc == 0) {

	*result = '\0';

	return result;

    }

    for (p = result, i = 0; i < argc; i++) {

	CONST char *element;

	int length;

	/*

	 * Clip white space off the front and back of the string

	 * to generate a neater result, and ignore any empty

	 * elements.

	 */

	element = argv[i];