(*p)--;
			// Have to check for this here - other unescaped control chars are handled by the < 0x1F
			// test, but 0x00 is transformed to 0xC0 0x80 by Tcl (MUTF-8 rather than UTF-8)
			return CHAR_ADVANCE_UNESCAPED_NULL;
		}
		if (first < 0xe0 /* 0b11100000 */) {
			eat = 1;
#if TCL_UTF_MAX == 3
		} else {
			eat = 2;
#else
		} else if (first < 0xf0 /* 0b11110000 */) {
			eat = 2;
		} else if (first < 0xf8 /* 0b11111000 */) {
			eat = 3;
		} else if (first < 0xfc /* 0b11111100 */) {
			eat = 4;
		} else {
			eat = 5;
#endif
		}
		*p += eat;
		*char_adj += eat;
	}

	return CHAR_ADVANCE_OK;
}

						case 'r': mapped='\r'; goto append_mapped;
						case 't': mapped='\t';
append_mapped:				Tcl_AppendToObj(out, &mapped, 1);		// Weird, but arranged this way the compiler optimizes it to a jump table
							break;

						case 'u':
							{
								Tcl_UniChar	acc = 0;
								unsigned int	acc = 0;
								char		utfbuf[6];
								int			i=4, digit;

								if (unlikely(e-p-2 < i)) {	// -2 is for the "u" and the close quote
									err_at = e-1;
									if (err_at < e && *err_at != '"')
										err_at++;	// Bodge the case where the doc was truncated without a closing quote

											goto err;
										}
									}

									acc <<= 4;
									acc += digit;
								}
#if TCL_UTF_MAX > 4
								if ((acc & 0xFFFFFC00) == 0xD800 && p[1] == '\\' && p[2] == 'u') {
									const unsigned char *pp = p + 2;
									Tcl_UniChar	acc2=0;
									unsigned int	acc2=0;

									i=4;
									if (unlikely(e-pp-2 < i)) {	// -2 is for the "u" and the close quote
										err_at = e-1;
										if (err_at < e && *err_at != '"')
											err_at++;	// Bodge the case where the doc was truncated without a closing quote
										errmsg = "Unicode sequence too short";

									}

									if ((acc2 & 0xFFFFFC00) == 0xDC00) {
										acc = ((acc & 0x3FF) << 10) + 0x10000 + (acc2 & 0x3FF);
										p = pp;
									}
								}
#if TCL_UTF_MAX == 3
								if (acc > 0xFFFF) {
									acc -= 0x10000;
									Tcl_UniChar uch = ((acc >> 10) & 0x3FF) | 0xD800;
									acc = (acc & 0x3FF) | 0xDC00;
									const int len0 = Tcl_UniCharToUtf(uch, utfbuf);
									Tcl_AppendToObj(out, utfbuf, len0);
								}
#endif
								//const unsigned char* utfend = output_utf8(acc, utfbuf);
								const int len = Tcl_UniCharToUtf(acc, utfbuf);
								Tcl_AppendToObj(out, utfbuf, len);
							}
							break;

	index = textPtr->numChars;
    }
    byteIndex = Tcl_UtfAtIndex(text, index) - text;
    byteCount = strlen(string);
    if (byteCount == 0) {
	return;
    }
#if TCL_UTF_MAX < 4
    /*
     * Don't insert within surrogate pairs.
     */
    if (byteIndex) {
	Tcl_UniChar ch;
	const char *prevPtr;

	Tcl_UtfToUniChar(string + byteIndex, &ch);
	if ((ch & 0xfc00) == 0xdc00) {
	    prevPtr = Tcl_UtfPrev(string + byteIndex, string);
	    Tcl_UtfToUniChar(prevPtr, &ch);
	    if ((ch & 0xfc00) == 0xd800) {
		byteIndex = prevPtr - string;
		index -= 1;
	    }
	}
    }
#endif
    newStr = (char *) ckalloc(textPtr->numBytes + byteCount + 1);
    memcpy(newStr, text, byteIndex);
    strcpy(newStr + byteIndex, string);
    strcpy(newStr + byteIndex + byteCount, text + byteIndex);

    ckfree(text);
    textPtr->text = newStr;

    }
    if (first > last) {
	return;
    }
    charsRemoved = last + 1 - first;

    byteIndex = Tcl_UtfAtIndex(text, first) - text;
#if TCL_UTF_MAX < 4
    /*
     * Delete complete surrogate pairs.
     */
    if (byteIndex >= 0) {
	Tcl_UniChar ch;
	const char *prevPtr, *nextPtr;

	Tcl_UtfToUniChar(text + byteIndex, &ch);
	if ((ch & 0xfc00) == 0xdc00) {
	    prevPtr = Tcl_UtfPrev(text + byteIndex, text);
	    Tcl_UtfToUniChar(prevPtr, &ch);
	    if ((ch & 0xfc00) == 0xd800) {
		byteIndex = prevPtr - text;
		first--;
	    }
	} else if (charsRemoved == 1 && (ch & 0xfc00) == 0xd800) {
	    nextPtr = Tcl_UtfNext(text + byteIndex);
	    Tcl_UtfToUniChar(nextPtr, &ch);
	    if ((ch & 0xfc00) == 0xdc00) {
		last++;
            }
        }
	if (last >= textPtr->numChars) {
	    last = textPtr->numChars - 1;
	}
	charsRemoved = last + 1 - first;
    }
#endif
    byteCount = Tcl_UtfAtIndex(text + byteIndex, charsRemoved)
	- (text + byteIndex);
#if TCL_UTF_MAX < 4
    if (byteCount) {
	int len;
	Tcl_UniChar ch;
	const char *prevPtr;

	len = Tcl_UtfToUniChar(text + byteIndex + byteCount, &ch);
	if ((ch & 0xfc00) == 0xdc00) {
	    prevPtr = Tcl_UtfPrev(text + byteIndex + byteCount, text);
	    Tcl_UtfToUniChar(prevPtr, &ch);
	    if ((ch & 0xfc00) == 0xd800) {
		byteCount += len;
		charsRemoved++;
	    }
	}
    }
#endif

    newStr = (char *) ckalloc(textPtr->numBytes + 1 - byteCount);
    memcpy(newStr, text, byteIndex);
    strcpy(newStr + byteIndex, text + byteIndex + byteCount);

    ckfree(text);
    textPtr->text = newStr;

				 * index. */
{
    TextItem *textPtr = (TextItem *) itemPtr;
    int length;
    int c;
    Tk_CanvasTextInfo *textInfoPtr = textPtr->textInfoPtr;
    const char *string = Tcl_GetStringFromObj(obj, &length);
#if TCL_UTF_MAX < 4
    int roundUp = 0;
    int oldInsertPos = textPtr->insertPos;
#endif

    c = string[0];

    if ((c == 'e') && (strncmp(string, "end", length) == 0)) {
	*indexPtr = textPtr->numChars;
    } else if ((c == 'i')
	    && (strncmp(string, "insert", length) == 0)) {

		(int) (x*cs - y*s), (int) (y*cs + x*s));
    } else if (Tcl_GetIntFromObj(NULL, obj, indexPtr) == TCL_OK) {
	if (*indexPtr < 0) {
	    *indexPtr = 0;
	} else if (*indexPtr > textPtr->numChars) {
	    *indexPtr = textPtr->numChars;
	}
#if TCL_UTF_MAX < 4
	roundUp = (*indexPtr == (oldInsertPos + 1));
#endif
    } else {
	/*
	 * Some of the paths here leave messages in the interp's result, so we
	 * have to clear it out before storing our own message.
	 */

    badIndex:
	Tcl_SetObjResult(interp, Tcl_ObjPrintf("bad index \"%s\"", string));
	Tcl_SetErrorCode(interp, "TK", "CANVAS", "ITEM_INDEX", "TEXT", NULL);
	return TCL_ERROR;
    }
#if TCL_UTF_MAX < 4
    /*
     * Enforce index on start or end of surrogate pair.
     */
    if (*indexPtr) {
	int byteIndex;
	Tcl_UniChar ch;
	const char *prevPtr, *nextPtr;

	string = textPtr->text;
	byteIndex = Tcl_UtfAtIndex(string, *indexPtr) - string;
	Tcl_UtfToUniChar(string + byteIndex, &ch);
	if ((ch & 0xfc00) == 0xdc00) {
	    if (roundUp) {
		*indexPtr += 1;
	    } else {
		prevPtr = Tcl_UtfPrev(string + byteIndex, string);
		Tcl_UtfToUniChar(prevPtr, &ch);
		if ((ch & 0xfc00) == 0xd800) {
		    *indexPtr -= 1;
		}
	    }
	} else if (roundUp && (ch & 0xfc00) == 0xd800) {
	    nextPtr = Tcl_UtfNext(string + byteIndex);
	    Tcl_UtfToUniChar(nextPtr, &ch);
	    if ((ch & 0xfc00) == 0xdc00) {
		*indexPtr += 2;
	    }
	}
    }
#endif
    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * SetTextCursor --

    /*
     * If we're displaying a special character instead of the value of the
     * entry, recompute the displayString.
     */

    if (entryPtr->showChar != NULL) {
	Tcl_UniChar ch;
	char buf[TCL_UTF_MAX];
	int ch;
	char buf[6];
	int size;

	/*
	 * Normalize the special character so we can safely duplicate it in
	 * the display string. If we didn't do this, then two malformed
	 * characters might end up looking like one valid UTF character in the
	 * resulting string.
	 */

	Tcl_UtfToUniChar(entryPtr->showChar, &ch);
	size = Tcl_UniCharToUtf(ch, buf);
	TkUtfToUniChar(entryPtr->showChar, &ch);
	size = TkUniCharToUtf(ch, buf);

	entryPtr->numDisplayBytes = entryPtr->numChars * size;
	p = (char *) ckalloc(entryPtr->numDisplayBytes + 1);
	entryPtr->displayString = p;

	for (i = entryPtr->numChars; --i >= 0; ) {
	    memcpy(p, buf, size);

				 * string). */
{
    ptrdiff_t byteIndex;
    size_t byteCount, newByteCount;
    int oldChars, charsAdded;
    const char *string;
    char *newStr;
#if TCL_UTF_MAX < 4
    Tcl_UniChar ch;
#endif

    string = entryPtr->string;
    byteIndex = Tcl_UtfAtIndex(string, index) - string;
    byteCount = strlen(value);
    if (byteCount == 0) {
	return TCL_OK;
    }

#if TCL_UTF_MAX < 4
    /*
     * Don't insert within surrogate pairs.
     */
    if (byteIndex) {
	Tcl_UniChar ch;
	const char *prevPtr;

	Tcl_UtfToUniChar(string + byteIndex, &ch);
	if ((ch & 0xFC00) == 0xDC00) {
	    prevPtr = Tcl_UtfPrev(string + byteIndex, string);
	    Tcl_UtfToUniChar(prevPtr, &ch);
	    if ((ch & 0xFC00) == 0xD800) {
		byteIndex = prevPtr - string;
		index -= 1;
	    }
	}
    }
#endif

    newByteCount = entryPtr->numBytes + byteCount + 1;
    newStr = (char *) ckalloc(newByteCount);
    memcpy(newStr, string, byteIndex);
    strcpy(newStr + byteIndex, value);
    strcpy(newStr + byteIndex + byteCount, string + byteIndex);

    if ((entryPtr->validate == VALIDATE_KEY ||
	    entryPtr->validate == VALIDATE_ALL) &&
	    EntryValidateChange(entryPtr, value, newStr, index,
		    VALIDATE_INSERT) != TCL_OK) {
	ckfree(newStr);
	return TCL_OK;
    }

#if TCL_UTF_MAX < 4
    /*
     * Account for high surrogate at end of inserted string.
     */
    if (byteCount > 1) {
	const char *lastPtr = Tcl_UtfPrev(newStr+byteIndex+byteCount, newStr);

	Tcl_UtfToUniChar(lastPtr, &ch);
	if ((ch & 0xFC00) == 0xD800) {
	    /*
	     * A high surrogate. If followed by low surrogate,
	     * adjust index after it.
	     */
	    lastPtr = Tcl_UtfNext(lastPtr);
	    Tcl_UtfToUniChar(lastPtr, &ch);
	    if ((ch & 0xFC00) == 0xDC00) {
		index++;
	    }
	}
    }
#endif

    ckfree((char *)string);
    entryPtr->string = newStr;

    /*
     * The following construction is used because inserting improperly formed
     * UTF-8 sequences between other improperly formed UTF-8 sequences could

    }
    if (count <= 0) {
	return TCL_OK;
    }

    string = entryPtr->string;
    byteIndex = Tcl_UtfAtIndex(string, index) - string;

#if TCL_UTF_MAX < 4
    /*
     * Delete complete surrogate pairs.
     */
    if (byteIndex >= 0) {
	Tcl_UniChar ch;
	const char *prevPtr, *nextPtr;

	Tcl_UtfToUniChar(string + byteIndex, &ch);
	if ((ch & 0xFC00) == 0xDC00) {
	    prevPtr = Tcl_UtfPrev(string + byteIndex, string);
	    Tcl_UtfToUniChar(prevPtr, &ch);
	    if ((ch & 0xFC00) == 0xD800) {
		byteIndex = prevPtr - string;
		count++;
		index--;
	    }
	} else if ((count == 1) && ((ch & 0xFC00) == 0xD800)) {
	    nextPtr = Tcl_UtfNext(string + byteIndex);
	    Tcl_UtfToUniChar(nextPtr, &ch);
	    if ((ch & 0xFC00) == 0xDC00) {
		count++;
	    }
	}
	if ((index + count) > entryPtr->numChars) {
	    count = entryPtr->numChars - index;
	}
    }
#endif

    byteCount = Tcl_UtfAtIndex(string + byteIndex, count) - (string+byteIndex);

#if TCL_UTF_MAX < 4
    if (byteCount) {
	int len;
	Tcl_UniChar ch;
	const char *prevPtr;

	len = Tcl_UtfToUniChar(string + byteIndex + byteCount, &ch);
	if ((ch & 0xFC00) == 0xDC00) {
	    prevPtr = Tcl_UtfPrev(string + byteIndex + byteCount, string);
	    Tcl_UtfToUniChar(prevPtr, &ch);
	    if ((ch & 0xFC00) == 0xD800) {
		byteCount += len;
		count++;
	    }
	}
    }
#endif

    newByteCount = entryPtr->numBytes + 1 - byteCount;
    newStr = (char *) ckalloc(newByteCount);
    memcpy(newStr, string, (size_t) byteIndex);
    strcpy(newStr + byteIndex, string + byteIndex + byteCount);

    toDelete = (char *) ckalloc(byteCount + 1);

    Entry *entryPtr,		/* Entry for which the index is being
				 * specified. */
    Tcl_Obj *indexObj,	/* Specifies character in entryPtr. */
    int *indexPtr)		/* Where to store converted character index */
{
    const char *string = Tcl_GetString(indexObj);
    size_t length = indexObj->length;
    int roundUp = 0;
#if TCL_UTF_MAX < 4
    int oldInsertPos = entryPtr->insertPos;
#endif

    switch (string[0]) {
    case 'a':
	if (strncmp(string, "anchor", length) != 0) {
	    goto badIndex;
	}
	*indexPtr = entryPtr->selectAnchor;

	} else if (strncmp(string, "sel.last", length) == 0) {
	    *indexPtr = entryPtr->selectLast;
	} else {
	    goto badIndex;
	}
	break;
    case '@': {
	int x, roundUp, maxWidth;
	int x, maxWidth;

	if (Tcl_GetInt(NULL, string + 1, &x) != TCL_OK) {
	    goto badIndex;
	}
	if (x < entryPtr->inset) {
	    x = entryPtr->inset;
	}
	roundUp = 0;
	maxWidth = Tk_Width(entryPtr->tkwin) - entryPtr->inset
		- entryPtr->xWidth - 1;
	if (x > maxWidth) {
	    x = maxWidth;
	    roundUp = 1;
	}
	*indexPtr = Tk_PointToChar(entryPtr->textLayout,

	    goto badIndex;
	}
	if (*indexPtr < 0){
	    *indexPtr = 0;
	} else if (*indexPtr > entryPtr->numChars) {
	    *indexPtr = entryPtr->numChars;
	}
#if TCL_UTF_MAX < 4
	roundUp = (indexPtr == &entryPtr->insertPos) &&
		(*indexPtr == (oldInsertPos + 1));
#endif
    }

#if TCL_UTF_MAX < 4
    /*
     * Enforce index on start or end of surrogate pair.
     */
    if (*indexPtr) {
	int byteIndex;
	Tcl_UniChar ch;
	const char *prevPtr;

	string = entryPtr->string;
	byteIndex = Tcl_UtfAtIndex(string, *indexPtr) - string;
	Tcl_UtfToUniChar(string + byteIndex, &ch);
	if ((ch & 0xFC00) == 0xDC00) {
	    if (roundUp) {
		*indexPtr += 1;
	    } else {
		prevPtr = Tcl_UtfPrev(string + byteIndex, string);
		Tcl_UtfToUniChar(prevPtr, &ch);
		if ((ch & 0xFC00) == 0xD800) {
		    *indexPtr -= 1;
		}
	    }
	}
    }
#endif

    return TCL_OK;

  badIndex:
    Tcl_SetObjResult(interp, Tcl_ObjPrintf("bad %s index \"%s\"",
	    (entryPtr->type == TK_ENTRY) ? "entry" : "spinbox", string));
    Tcl_SetErrorCode(interp, "TK",
	    (entryPtr->type == TK_ENTRY) ? "ENTRY" : "SPINBOX",

     * Pick new starting and ending points for the selection.
     */

    if (entryPtr->selectAnchor > entryPtr->numChars) {
	entryPtr->selectAnchor = entryPtr->numChars;
    }
    if (entryPtr->selectAnchor <= index) {
#if TCL_UTF_MAX < 4
	/*
	 * Correct ending point for surrogate pair.
	 */

	Tcl_UniChar ch;
	const char *string;

	string = Tcl_UtfAtIndex(entryPtr->string, index);
	string += Tcl_UtfToUniChar(string, &ch);
	if (((ch & 0xFC00) == 0xDC00) && (index + 1 < entryPtr->numChars)) {
	    index += 1;
	} else if (((ch & 0xFC00) == 0xD800) &&
			(index + 1 < entryPtr->numChars) &&
			(index == entryPtr->insertPos)) {
	    Tcl_UtfToUniChar(string, &ch);
	    if ((ch & 0xFC00) == 0xDC00) {
		index += 2;
	    }
	}
#endif
	newFirst = entryPtr->selectAnchor;
	newLast = index;
    } else {
	newFirst = index;
	newLast = entryPtr->selectAnchor;
	if (newLast < 0) {
	    newFirst = newLast = -1;

     Tcl_DString *dsPtr)	/* Dynamic string in which to append new
				 * command. */
{
    int spaceNeeded, cvtFlags;	/* Used to substitute string as proper Tcl
				 * list element. */
    int number, length;
    const char *string;
    Tcl_UniChar ch;
    int ch;
    char numStorage[2*TCL_INTEGER_SPACE];

    while (1) {
	if (*before == '\0') {
	    break;
	}
	/*

	/*
	 * There's a percent sequence here. Process it.
	 */

	before++; /* skip over % */
	if (*before != '\0') {
	    before += Tcl_UtfToUniChar(before, &ch);
	    before += TkUtfToUniChar(before, &ch);
	} else {
	    ch = '%';
	}
	if (type == VALIDATE_BUTTON) {
	    /*
	     * -command %-substitution
	     */

	    switch (ch) {
	    case 's':		/* Current string value of spinbox */
		string = entryPtr->string;
		break;
	    case 'd':		/* direction, up or down */
		string = change;
		break;
	    case 'W':		/* widget name */
		string = Tk_PathName(entryPtr->tkwin);
		break;
	    default:
		length = Tcl_UniCharToUtf(ch, numStorage);
		length = TkUniCharToUtf(ch, numStorage);
		numStorage[length] = '\0';
		string = numStorage;
		break;
	    }
	} else {
	    /*
	     * -validatecommand / -invalidcommand %-substitution

		    break;
		}
		break;
	    case 'W': /* widget name */
		string = Tk_PathName(entryPtr->tkwin);
		break;
	    default:
		length = Tcl_UniCharToUtf(ch, numStorage);
		length = TkUniCharToUtf(ch, numStorage);
		numStorage[length] = '\0';
		string = numStorage;
		break;
	    }
	}

	spaceNeeded = Tcl_ScanCountedElement(string, -1, &cvtFlags);

		goto error;
	    }
	    if (GetEntryIndex(interp, entryPtr,
		    objv[3], &index) != TCL_OK) {
		goto error;
	    }
	    if (GetEntryIndex(interp, entryPtr,
		    objv[4],& index2) != TCL_OK) {
		    objv[4], &index2) != TCL_OK) {
		goto error;
	    }
	    if (index >= index2) {
		entryPtr->selectFirst = -1;
		entryPtr->selectLast = -1;
	    } else {
		entryPtr->selectFirst = index;

    switch ((enum options) index) {
    case FONT_ACTUAL: {
	int skip, result, n;
	const char *s;
	Tk_Font tkfont;
	Tcl_Obj *optPtr, *charPtr, *resultPtr;
	Tcl_UniChar uniChar = 0;
	int uniChar = 0;
	const TkFontAttributes *faPtr;
	TkFontAttributes fa;

	/*
	 * Params 0 and 1 are 'font actual'. Param 2 is the font name. 3-4 may
	 * be '-displayof $window'
	 */

	}

	/*
	 * The 'charPtr' arg must be a single Unicode.
	 */

	if (charPtr != NULL) {
	    const char *string = Tcl_GetString(charPtr);
	    int len = TkUtfToUniChar(string, &uniChar);
	    if (Tcl_GetCharLength(charPtr) != 1) {

	    if (len != charPtr->length) {
		resultPtr = Tcl_NewStringObj(
			"expected a single character but got \"", -1);
		Tcl_AppendLimitedToObj(resultPtr, Tcl_GetString(charPtr),
		Tcl_AppendLimitedToObj(resultPtr, string,
			-1, 40, "...");
		Tcl_AppendToObj(resultPtr, "\"", -1);
		Tcl_SetObjResult(interp, resultPtr);
		Tcl_SetErrorCode(interp, "TK", "VALUE", "FONT_SAMPLE", NULL);
		return TCL_ERROR;
	    }
	    uniChar = Tcl_GetUniChar(charPtr, 0);
	}

	/*
	 * Find the font.
	 */

	tkfont = Tk_AllocFontFromObj(interp, tkwin, objv[2]);

    } else if (strcasecmp(family, "AvantGarde") == 0) {
	family = "AvantGarde";
    } else if (strcasecmp(family, "ZapfChancery") == 0) {
	family = "ZapfChancery";
    } else if (strcasecmp(family, "ZapfDingbats") == 0) {
	family = "ZapfDingbats";
    } else {
	Tcl_UniChar ch;
	int ch;

	/*
	 * Inline, capitalize the first letter of each word, lowercase the
	 * rest of the letters in each word, and then take out the spaces
	 * between the words. This may make the DString shorter, which is safe
	 * to do.
	 */

	Tcl_DStringAppend(dsPtr, family, -1);

	src = dest = Tcl_DStringValue(dsPtr) + len;
	upper = 1;
	for (; *src != '\0'; ) {
	    while (isspace(UCHAR(*src))) { /* INTL: ISO space */
		src++;
		upper = 1;
	    }
	    src += Tcl_UtfToUniChar(src, &ch);
	    src += TkUtfToUniChar(src, &ch);
	    if (upper) {
		ch = Tcl_UniCharToUpper(ch);
		upper = 0;
	    } else {
		ch = Tcl_UniCharToLower(ch);
	    }
	    dest += Tcl_UniCharToUtf(ch, dest);
	    dest += TkUniCharToUtf(ch, dest);
	}
	*dest = '\0';
	Tcl_DStringSetLength(dsPtr, dest - Tcl_DStringValue(dsPtr));
	family = Tcl_DStringValue(dsPtr) + len;
    }
    if (family != Tcl_DStringValue(dsPtr) + len) {
	Tcl_DStringAppend(dsPtr, family, -1);

	    end = Tcl_UtfAtIndex(chunkPtr->start, index);
	    if (xPtr != NULL) {
		Tk_MeasureChars(tkfont, chunkPtr->start,
			end - chunkPtr->start, -1, 0, &x);
		x += chunkPtr->x;
	    }
	    if (widthPtr != NULL) {
		Tk_MeasureChars(tkfont, end, Tcl_UtfNext(end) - end,
		Tk_MeasureChars(tkfont, end, TkUtfNext(end) - end,
			-1, 0, &w);
	    }
	    goto check;
	}
	index -= chunkPtr->numChars;
	chunkPtr++;
    }

    TextLayout *layoutPtr = (TextLayout *) layout;
    LayoutChunk *chunkPtr = layoutPtr->chunks;
    int baseline = chunkPtr->y;
    Tcl_Obj *psObj = Tcl_NewObj();
    int i, j, len;
    const char *p, *glyphname;
    char uindex[5], c, *ps;
    Tcl_UniChar ch;
    int ch;

    Tcl_AppendToObj(psObj, "[(", -1);
    for (i = 0; i < layoutPtr->numChunks; i++, chunkPtr++) {
	if (baseline != chunkPtr->y) {
	    Tcl_AppendToObj(psObj, ")]\n[(", -1);
	    baseline = chunkPtr->y;
	}

	    /*
	     * INTL: We only handle symbols that have an encoding as a glyph
	     * from the standard set defined by Adobe. The rest get punted.
	     * Eventually this should be revised to handle more sophsticiated
	     * international postscript fonts.
	     */

	    p += Tcl_UtfToUniChar(p, &ch);
	    p += TkUtfToUniChar(p, &ch);
	    if ((ch == '(') || (ch == ')') || (ch == '\\') || (ch < 0x20)) {
		/*
		 * Tricky point: the "03" is necessary in the sprintf below,
		 * so that a full three digits of octal are always generated.
		 * Without the "03", a number following this sequence could be
		 * interpreted by Postscript as part of this sequence.
		 */

#if !defined(__cplusplus) && !defined(c_plusplus)
# define c_class class
#endif

#ifdef TK_USE_POLL
MODULE_SCOPE TkDisplay * TkGetDisplayListExt(struct pollfd **pollTablePtr);
#endif

#if TCL_UTF_MAX > 3
#   define TkUtfToUniChar(src, chPtr) \
	Tcl_UtfToUniChar((src), (Tcl_UniChar *)(chPtr))
#   define TkUniCharToUtf Tcl_UniCharToUtf
#   define TkUtfPrev Tcl_UtfPrev
#   define TkUtfNext Tcl_UtfNext
#else
    MODULE_SCOPE int TkUtfToUniChar(const char *, int *);
    MODULE_SCOPE int TkUniCharToUtf(int, char *);
    MODULE_SCOPE const char *TkUtfPrev(const char *, const char *);
    MODULE_SCOPE const char *TkUtfNext(const char *);
#endif

/*
 * Unsupported commands.
 */

MODULE_SCOPE int	TkUnsupported1ObjCmd(ClientData clientData,
			    Tcl_Interp *interp, int objc,

SelGetProc(
    ClientData clientData,	/* Dynamic string holding partially assembled
				 * selection. */
    Tcl_Interp *interp,		/* Interpreter used for error reporting (not
				 * used). */
    const char *portion)	/* New information to be appended. */
{
#if TCL_UTF_MAX < 4
    /*
     * Ensure WTF-8 without 4-byte UTF-8 sequences.
     */
    Tcl_Encoding encoding;
    Tcl_DString tmp;

    encoding = Tcl_GetEncoding(NULL, "utf-8");
    Tcl_ExternalToUtfDString(encoding, portion, -1, &tmp);
    Tcl_DStringAppend((Tcl_DString *) clientData, Tcl_DStringValue(&tmp),
	Tcl_DStringLength(&tmp));
    Tcl_DStringFree(&tmp);
    if (encoding) {
	Tcl_FreeEncoding(encoding);
    }
#else
    Tcl_DStringAppend((Tcl_DString *) clientData, portion, -1);
#endif
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * HandleTclCommand --

	 */

	if (cmdInfoPtr->interp != NULL) {
	    if (length <= maxBytes) {
		cmdInfoPtr->charOffset += Tcl_NumUtfChars(string, -1);
		cmdInfoPtr->buffer[0] = '\0';
	    } else {
		Tcl_UniChar ch = 0;
		Tcl_UniChar ch;

		p = string;
		string += count;
		numChars = 0;
		while (p < string) {
		    p += Tcl_UtfToUniChar(p, &ch);
		    numChars++;

    Tcl_Obj *stringPtr)		/* Description of the tab stops. See the text
				 * manual entry for details. */
{
    int objc, i, count;
    Tcl_Obj **objv;
    TkTextTabArray *tabArrayPtr;
    TkTextTab *tabPtr;
    Tcl_UniChar ch;
    int ch;
    double prevStop, lastStop;
    /*
     * Map these strings to TkTextTabAlign values.
     */
    static const char *const tabOptionStrings[] = {
	"left", "right", "center", "numeric", NULL
    };

	    continue;
	}

	/*
	 * There may be a more efficient way of getting this.
	 */

	Tcl_UtfToUniChar(Tcl_GetString(objv[i+1]), &ch);
	TkUtfToUniChar(Tcl_GetString(objv[i+1]), &ch);
	if (!Tcl_UniCharIsAlpha(ch)) {
	    continue;
	}
	i += 1;

	if (Tcl_GetIndexFromObjStruct(interp, objv[i], tabOptionStrings,
		sizeof(char *), "tab alignment", 0, &index) != TCL_OK) {

	if (searchSpecPtr->exact) {
	    int maxExtraLines = 0;
	    const char *startOfLine = Tcl_GetString(theLine);

	    CLANG_ASSERT(pattern);
	    do {
		Tcl_UniChar ch;
		int ch;
		const char *p;
		int lastFullLine = lastOffset;

		if (firstNewLine == -1) {
		    if (searchSpecPtr->strictLimits
			    && (firstOffset + matchLength > lastOffset)) {
			/*

		    if (searchSpecPtr->backwards) {
			alreadySearchOffset = p - startOfLine - 1;
			if (alreadySearchOffset < 0) {
			    break;
			}
		    } else {
			firstOffset = p - startOfLine +
				Tcl_UtfToUniChar(startOfLine+matchOffset,&ch);
				TkUtfToUniChar(startOfLine+matchOffset,&ch);
		    }
		}
	    } while (searchSpecPtr->all);
	} else {
	    int maxExtraLines = 0;
	    int matches = 0;
	    int lastNonOverlap = -1;

#else /* !TK_LAYOUT_WITH_BASE_CHUNKS */
    bytesThatFit = CharChunkMeasureChars(chunkPtr, p, maxBytes, 0, -1,
	    chunkPtr->x, maxX, TK_ISOLATE_END, &nextX);
#endif /* TK_LAYOUT_WITH_BASE_CHUNKS */

    if (bytesThatFit < maxBytes) {
	if ((bytesThatFit == 0) && noCharsYet) {
	    Tcl_UniChar ch;
	    int chLen = Tcl_UtfToUniChar(p, &ch);
	    int ch;
	    int chLen = TkUtfToUniChar(p, &ch);

#ifdef TK_LAYOUT_WITH_BASE_CHUNKS
	    bytesThatFit = CharChunkMeasureChars(chunkPtr, line,
		    lineOffset+chLen, lineOffset, -1, chunkPtr->x, -1, 0,
		    &nextX);
#else /* !TK_LAYOUT_WITH_BASE_CHUNKS */
	    bytesThatFit = CharChunkMeasureChars(chunkPtr, p, chLen, 0, -1,

				 * of text). */
    int byteIndex,		/* Byte index of desired character. */
    TkTextIndex *indexPtr)	/* Structure to fill in. */
{
    TkTextSegment *segPtr;
    int index;
    const char *p, *start;
    Tcl_UniChar ch = 0;
    Tcl_UniChar ch;

    indexPtr->tree = tree;
    if (lineIndex < 0) {
	lineIndex = 0;
	byteIndex = 0;
    }
    if (byteIndex < 0) {

				 * of text). */
    int charIndex,		/* Index of desired character. */
    TkTextIndex *indexPtr)	/* Structure to fill in. */
{
    TkTextSegment *segPtr;
    char *p, *start, *end;
    int index, offset;
    Tcl_UniChar ch = 0;
    Tcl_UniChar ch;

    indexPtr->tree = tree;
    if (lineIndex < 0) {
	lineIndex = 0;
	charIndex = 0;
    }
    if (charIndex < 0) {

    TkTextCountType type)	/* The type of item to count */
{
    TkTextLine *linePtr;
    TkTextSegment *segPtr;
    TkTextElideInfo *infoPtr = NULL;
    int byteOffset;
    char *start, *end, *p;
    Tcl_UniChar ch = 0;
    Tcl_UniChar ch;
    int elide = 0;
    int checkElided = (type & COUNT_DISPLAY);

    if (charCount < 0) {
	TkTextIndexBackChars(textPtr, srcPtr, -charCount, dstPtr, type);
	return;
    }

	    }

	    if (!elide) {
		if (segPtr->typePtr == &tkTextCharType) {
		    start = segPtr->body.chars + byteOffset;
		    end = segPtr->body.chars + segPtr->size;
		    for (p = start; p < end; p += Tcl_UtfToUniChar(p, &ch)) {
#if TCL_UTF_MAX < 4
			if (((ch & 0xFC00) == 0xD800) && (p < end)) {
			    char *pp = p;

			    pp += Tcl_UtfToUniChar(pp, &ch);
			    if ((ch & 0xFC00) == 0xDC00) {
				p = pp;
				if (charCount > 0) {
				    charCount--;
				} 
			    }
			}
#endif
			if (charCount == 0) {
			    dstPtr->byteIndex += (p - start);
			    goto forwardCharDone;
			}
			charCount--;
		    }
		} else if (type & COUNT_INDICES) {

	}

	if (!elide) {
	    if (segPtr->typePtr == &tkTextCharType) {
		start = segPtr->body.chars;
		end = segPtr->body.chars + segSize;
		for (p = end; ; p = Tcl_UtfPrev(p, start)) {
#if TCL_UTF_MAX < 4
		    Tcl_UniChar ch;

		    Tcl_UtfToUniChar(p, &ch);
		    if (((ch & 0xFC00) == 0xDC00) && (p > start)) {
			const char *pp = Tcl_UtfPrev(p, start);

			if (pp != NULL) {
			    Tcl_UtfToUniChar(pp, &ch);
			    if ((ch & 0xFC00) == 0xD800) {
				p = pp;
				if (charCount > 0) {
				    charCount--;
				} 
			    }
			}
		    }
#endif
		    if (charCount == 0) {
			dstPtr->byteIndex -= (end - p);
			goto backwardCharDone;
		    }
		    if (p == start) {
			break;
		    }

		    COUNT_DISPLAY_INDICES);
	}
	segPtr = TkTextIndexToSeg(indexPtr, &offset);
	while (1) {
	    int chSize = 1;

	    if (segPtr->typePtr == &tkTextCharType) {
		Tcl_UniChar ch = 0;
		int ch;

		chSize = Tcl_UtfToUniChar(segPtr->body.chars + offset, &ch);
		chSize = TkUtfToUniChar(segPtr->body.chars + offset, &ch);
		if (!Tcl_UniCharIsWordChar(ch)) {
		    break;
		}
		firstChar = 0;
	    }
	    offset += chSize;
	    indexPtr->byteIndex += chSize;

	 */

	segPtr = TkTextIndexToSeg(indexPtr, &offset);
	while (1) {
	    int chSize = 1;

	    if (segPtr->typePtr == &tkTextCharType) {
		Tcl_UniChar ch = 0;
		int ch;

		Tcl_UtfToUniChar(segPtr->body.chars + offset, &ch);
		TkUtfToUniChar(segPtr->body.chars + offset, &ch);
		if (!Tcl_UniCharIsWordChar(ch)) {
		    break;
		}
		if (offset > 0) {
		    chSize = (segPtr->body.chars + offset
			    - Tcl_UtfPrev(segPtr->body.chars + offset,
			    - TkUtfPrev(segPtr->body.chars + offset,
			    segPtr->body.chars));
		}
		firstChar = 0;
	    }
            if (offset == 0) {
		if (indexPtr->byteIndex == 0) {
		    goto done;

    if (detail != NULL) {
	/* Event code will call Tcl_DecrRefCount(). */
	Tcl_IncrRefCount(detail);
    }

    Tk_QueueWindowEvent(&event.general, TCL_QUEUE_TAIL);
}

#if TCL_UTF_MAX < 4
/*
 *---------------------------------------------------------------------------
 *
 * TkUtfToUniChar --
 *
 *	Almost the same as Tcl_UtfToUniChar but using int instead of Tcl_UniChar.
 *	This function is capable of collapsing a upper/lower surrogate pair to a
 *	single unicode character. So, up to 6 bytes might be consumed.
 *
 * Results:
 *	*chPtr is filled with the Tcl_UniChar, and the return value is the
 *	number of bytes from the UTF-8 string that were consumed.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

int
TkUtfToUniChar(
    const char *src,	/* The UTF-8 string. */
    int *chPtr)		/* Filled with the Tcl_UniChar represented by
			 * the UTF-8 string. */
{
    Tcl_UniChar uniChar = 0;
    int len = Tcl_UtfToUniChar(src, &uniChar);

    if ((uniChar & 0xfc00) == 0xd800) {
	int high = uniChar;
	int len2 = Tcl_UtfToUniChar(src+len, &uniChar);

	if ((uniChar & 0xfc00) == 0xdc00) {
	    *chPtr = (((high & 0x3ff) << 10) | (uniChar & 0x3ff)) + 0x10000;
	    len += len2;
	} else {
	    *chPtr = high;
	}
    } else {
	*chPtr = uniChar;
    }
    return len;
}

/*
 *---------------------------------------------------------------------------
 *
 * TkUniCharToUtf --
 *
 *	Almost the same as Tcl_UniCharToUtf but producing surrogates if
 *	TCL_UTF_MAX==3. So, up to 6 bytes might be produced.
 *
 * Results:
 *	*buf is filled with the UTF-8 string, and the return value is the
 *	number of bytes produced.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

int
TkUniCharToUtf(
    int ch,
    char *buf)
{
    int size;

    if ((ch > 0xffff) && (ch <= 0x10ffff)) {
	ch -= 0x10000;
	size = Tcl_UniCharToUtf(((ch >> 10) | 0xd800), buf);
	size += Tcl_UniCharToUtf(((ch & 0x3ff) | 0xdc00), buf+size);
    } else {
	size = Tcl_UniCharToUtf(ch, buf);
    }
    return size;
}

/*
 *---------------------------------------------------------------------------
 *
 * TkUtfPrev --
 *
 *	Almost the same as Tcl_UtfPrev but check for surrogates if
 *	TCL_UTF_MAX==3. So, the pointer might move up to 6 bytes.
 *
 * Results:
 *	Return a pointer to the previous unicode character.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

const char *
TkUtfPrev(
    const char *start,
    const char *source)
{
    const char *p = Tcl_UtfPrev(start, source);

    if ((p == source-3) && ((p[0]&0xFF) == 0xED)
	    && ((p[1]&0xF0) == 0xB0) && ((p[2]&0xC0) == 0x80)) {
	/* We are pointing to a low surrogate. If the previous
	 * codepoint is a high surrogate, we want that in stead. */
	const char *q = p - 3;

	if ((q >= start) && ((q[0]&0xFF) == 0xED)
		&& ((q[1]&0xF0) == 0xA0) && ((q[2]&0xC0) == 0x80)) {
	    p = q;
	}
    }
    return p;
}

/*
 *---------------------------------------------------------------------------
 *
 * TkUtfNext --
 *
 *	Almost the same as Tcl_UtfNext but check for surrogates if
 *	TCL_UTF_MAX==3. So, the pointer might move up to 6 bytes.
 *
 * Results:
 *	Return a pointer to the next unicode character.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

const char *
TkUtfNext(
    const char *source)
{
    const char *p = Tcl_UtfNext(source);

    if ((p == source+3) && ((source[0]&0xFF) == 0xED)
	    && ((source[1]&0xF0) == 0xA0) && ((source[2]&0xC0) == 0x80)) {
	/* We were pointing to a high surrogate. If the next
	 * codepoint is a low surrogate, we want to advance one more. */
	if (((p[0]&0xFF) == 0xED) && ((p[1]&0xF0) == 0xB0)
		&& ((p[2]&0xC0) == 0x80)) {

	    p += 3;
	}
    }
    return p;
}

#endif
/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

 * 	of (the first character in the string) 'showChar'.
 * 	Used to compute the displayString if -show is non-NULL.
 */
static char *EntryDisplayString(const char *showChar, int numChars)
{
    char *displayString, *p;
    int size;
    Tcl_UniChar ch;
    char buf[TCL_UTF_MAX];
    int ch;
    char buf[6];

    Tcl_UtfToUniChar(showChar, &ch);
    size = Tcl_UniCharToUtf(ch, buf);
    TkUtfToUniChar(showChar, &ch);
    size = TkUniCharToUtf(ch, buf);
    p = displayString = ckalloc(numChars * size + 1);

    while (numChars--) {
	memcpy(p, buf, size);
	p += size;
    }
    *p = '\0';

     VREASON reason,		/* Reason for change */
     Tcl_DString *dsPtr)	/* Result of %-substitutions */
{
    int spaceNeeded, cvtFlags;
    int number, length;
    const char *string;
    int stringLength;
    Tcl_UniChar ch;
    int ch;
    char numStorage[2*TCL_INTEGER_SPACE];

    while (*templ) {
	/* Find everything up to the next % character and append it
	 * to the result string.
	 */
	string = Tcl_UtfFindFirst(templ, '%');

	    templ = string;
	}

	/* There's a percent sequence here.  Process it.
	 */
	++templ; /* skip over % */
	if (*templ != '\0') {
	    templ += Tcl_UtfToUniChar(templ, &ch);
	    templ += TkUtfToUniChar(templ, &ch);
	} else {
	    ch = '%';
	}

	stringLength = -1;
	switch (ch) {
	    case 'd': /* Type of call that caused validation */

	    case 'V': /* type of validation in effect */
		string = validateReasonStrings[reason];
		break;
	    case 'W': /* widget name */
		string = Tk_PathName(entryPtr->core.tkwin);
		break;
	    default:
		length = Tcl_UniCharToUtf(ch, numStorage);
		length = TkUniCharToUtf(ch, numStorage);
		numStorage[length] = '\0';
		string = numStorage;
		break;
	}

	spaceNeeded = Tcl_ScanCountedElement(string, stringLength, &cvtFlags);
	length = Tcl_DStringLength(dsPtr);

    char *string = entryPtr->entry.string;
    size_t byteIndex = Tcl_UtfAtIndex(string, index) - string;
    size_t byteCount = strlen(value);
    int charsAdded = Tcl_NumUtfChars(value, byteCount);
    size_t newByteCount = entryPtr->entry.numBytes + byteCount + 1;
    char *newBytes;
    int code;
#if TCL_UTF_MAX < 4
    Tcl_UniChar ch;
#endif

    if (byteCount == 0) {
	return TCL_OK;
    }

#if TCL_UTF_MAX < 4
    /*
     * Don't insert within surrogate pairs.
     */
    if (byteIndex) {
	const char *prevPtr;

	Tcl_UtfToUniChar(string + byteIndex, &ch);
	if ((ch & 0xFC00) == 0xDC00) {
	    prevPtr = Tcl_UtfPrev(string + byteIndex, string);
	    Tcl_UtfToUniChar(prevPtr, &ch);
	    if ((ch & 0xFC00) == 0xD800) {
		byteIndex = prevPtr - string;
		index -= 1;
	    }
	}
    }
#endif

    newBytes = (char *) ckalloc(newByteCount);
    memcpy(newBytes, string, byteIndex);
    strcpy(newBytes + byteIndex, value);
    strcpy(newBytes + byteIndex + byteCount, string + byteIndex);

    code = EntryValidateChange(
	    entryPtr, newBytes, index, charsAdded, VALIDATE_INSERT);

#if TCL_UTF_MAX < 4
    /*
     * Account for high surrogate at end of inserted string.
     */
    if (byteCount > 1) {
	const char *lastPtr = Tcl_UtfPrev(newBytes+byteIndex+byteCount, newBytes);

	Tcl_UtfToUniChar(lastPtr, &ch);
	if ((ch & 0xFC00) == 0xD800) {
	    /*
	     * A high surrogate. If followed by low surrogate,
	     * adjust index after it.
	     */
	    lastPtr = Tcl_UtfNext(lastPtr);
	    Tcl_UtfToUniChar(lastPtr, &ch);
	    if ((ch & 0xFC00) == 0xDC00) {
		index++;
		charsAdded++;
	    }
	}
    }
#endif

    if (code == TCL_OK) {
	AdjustIndices(entryPtr, index, charsAdded);
	code = EntrySetValue(entryPtr, newBytes);
    } else if (code == TCL_BREAK) {
	code = TCL_OK;
    }

    int index,			/* Index of first character to delete. */
    int count)			/* How many characters to delete. */
{
    char *string = entryPtr->entry.string;
    size_t byteIndex, byteCount, newByteCount;
    char *newBytes;
    int code;
#if TCL_UTF_MAX < 4
    Tcl_UniChar ch;
    int len;
    const char *prevPtr, *nextPtr;
#endif

    if (index < 0) {
	index = 0;
    }
    if (count + index > entryPtr->entry.numChars) {
	count = entryPtr->entry.numChars - index;
    }
    if (count <= 0) {
	return TCL_OK;
    }

    byteIndex = Tcl_UtfAtIndex(string, index) - string;

#if TCL_UTF_MAX < 4
    /*
     * Delete complete surrogate pairs.
     */
    Tcl_UtfToUniChar(string + byteIndex, &ch);
    if ((ch & 0xFC00) == 0xDC00) {
	prevPtr = Tcl_UtfPrev(string + byteIndex, string);
	Tcl_UtfToUniChar(prevPtr, &ch);
	if ((ch & 0xFC00) == 0xD800) {
	    byteIndex = prevPtr - string;
	    count++;
	    index--;
	}
    } else if ((count == 1) && ((ch & 0xFC00) == 0xD800)) {
	nextPtr = Tcl_UtfNext(string + byteIndex);
	Tcl_UtfToUniChar(nextPtr, &ch);
	if ((ch & 0xFC00) == 0xDC00) {
	    count++;
	}
    }
    if (count > entryPtr->entry.numChars - index) {
	count = entryPtr->entry.numChars - index;
    }
#endif

    byteCount = Tcl_UtfAtIndex(string+byteIndex, count) - (string+byteIndex);

#if TCL_UTF_MAX < 4
    if (byteCount) {
	len = Tcl_UtfToUniChar(string + byteIndex + byteCount, &ch);
	if ((ch & 0xFC00) == 0xDC00) {
	    prevPtr = Tcl_UtfPrev(string + byteIndex + byteCount, string);
	    Tcl_UtfToUniChar(prevPtr, &ch);
	    if ((ch & 0xFC00) == 0xD800) {
		byteCount += len;
		count++;
	    }
	}
    }
#endif

    newByteCount = entryPtr->entry.numBytes + 1 - byteCount;
    newBytes = (char *) ckalloc(newByteCount);
    memcpy(newBytes, string, byteIndex);
    strcpy(newBytes + byteIndex, string + byteIndex + byteCount);

    code = EntryValidateChange(

    Entry *entryPtr,		/* Entry widget to query */
    Tcl_Obj *indexObj,		/* Symbolic index name */
    int *indexPtr)		/* Return value */
{
#   define EntryWidth(e) (Tk_Width(entryPtr->core.tkwin)) /* Not Right */
    const char *string = Tcl_GetString(indexObj);
    size_t length = indexObj->length;
    int roundUp = 0;
#if TCL_UTF_MAX < 4
    int oldPos = entryPtr->entry.insertPos;
#endif

    if (strncmp(string, "end", length) == 0) {
	*indexPtr = entryPtr->entry.numChars;
    } else if (strncmp(string, "insert", length) == 0) {
	*indexPtr = entryPtr->entry.insertPos;
    } else if (strncmp(string, "left", length) == 0) {	/* for debugging */
	*indexPtr = entryPtr->entry.xscroll.first;

	    *indexPtr = entryPtr->entry.selectFirst;
	} else if (strncmp(string, "sel.last", length) == 0) {
	    *indexPtr = entryPtr->entry.selectLast;
	} else {
	    goto badIndex;
	}
    } else if (string[0] == '@') {
	int roundUp = 0;
	int maxWidth = EntryWidth(entryPtr);
	int x;

	if (Tcl_GetInt(interp, string + 1, &x) != TCL_OK) {
	    goto badIndex;
	}
	if (x > maxWidth) {

	    goto badIndex;
	}
	if (*indexPtr < 0) {
	    *indexPtr = 0;
	} else if (*indexPtr > entryPtr->entry.numChars) {
	    *indexPtr = entryPtr->entry.numChars;
	}
#if TCL_UTF_MAX < 4
	roundUp = (indexPtr == &entryPtr->entry.insertPos) && 
		(*indexPtr == (oldPos + 1));
#endif
    }

#if TCL_UTF_MAX < 4
    /*
     * Enforce index on start or end of surrogate pair.
     */
    if (*indexPtr) {
	int byteIndex;
	Tcl_UniChar ch;
	const char *prevPtr;

	string = entryPtr->entry.string;
	byteIndex = Tcl_UtfAtIndex(string, *indexPtr) - string;
	Tcl_UtfToUniChar(string + byteIndex, &ch);
	if ((ch & 0xFC00) == 0xDC00) {
	    if (roundUp) {
		*indexPtr += 1;
	    } else {
		prevPtr = Tcl_UtfPrev(string + byteIndex, string);
		Tcl_UtfToUniChar(prevPtr, &ch);
		if ((ch & 0xFC00) == 0xD800) {
		    *indexPtr -= 1;
		}
	    }
	}
    }
#endif

    return TCL_OK;

badIndex:
    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
	    "bad entry index \"%s\"", string));
    Tcl_SetErrorCode(interp, "TTK", "ENTRY", "INDEX", NULL);
    return TCL_ERROR;

bind Entry <B1-Motion> {
    set tk::Priv(x) %x
    tk::EntryMouseSelect %W %x
}
bind Entry <Double-1> {
    set tk::Priv(selectMode) word
    tk::EntryMouseSelect %W %x
    catch {%W icursor sel.last}
}
bind Entry <Triple-1> {
    set tk::Priv(selectMode) line
    tk::EntryMouseSelect %W %x
    catch {%W icursor sel.last}
}
bind Entry <Shift-1> {

		}
	    }
	}
	word {
	    if {$cur < $anchor} {
		set before [tcl_wordBreakBefore [$w get] $cur]
		set after [tcl_wordBreakAfter [$w get] $anchor-1]
		set icur before
	    } elseif {$cur > $anchor} {
		set before [tcl_wordBreakBefore [$w get] $anchor]
		set after [tcl_wordBreakAfter [$w get] $cur-1]
		set icur after
	    } else {
		if {[$w index @$Priv(pressX)] < $anchor} {
		      incr anchor -1
		}
		set before [tcl_wordBreakBefore [$w get] $anchor]
		set after [tcl_wordBreakAfter [$w get] $anchor]
		set icur after
	    }
	    if {$before < 0} {
		set before 0
	    }
	    if {$after < 0} {
		set after end
	    }
	    $w selection range $before $after
	    if {$icur eq "after"} {
		$w icursor end
		$w icursor $after
	    } else {
		$w icursor 0
		$w icursor $before
	    }
	    set Priv(mouseMoved) 0
	}
	line {
	    $w selection range 0 end
	}
    }
    if {$Priv(mouseMoved)} {
        $w icursor $cur

		}
	    }
	}
	word {
	    if {$cur < [$w index anchor]} {
		set before [tcl_wordBreakBefore [$w get] $cur]
		set after [tcl_wordBreakAfter [$w get] $anchor-1]
		set icur before
	    } else {
		set before [tcl_wordBreakBefore [$w get] $anchor]
		set after [tcl_wordBreakAfter [$w get] $cur-1]
		set icur after
	    }
	    if {$before < 0} {
		set before 0
	    }
	    if {$after < 0} {
		set after end
	    }
	    $w selection range $before $after
	    if {$icur eq "after"} {
		$w icursor end
		$w icursor $after
	    } else {
		$w icursor 0
		$w icursor $before
	    }
	    set Priv(mouseMoved) 0
	    set cursor ignore
	}
	line {
	    $w selection range 0 end
	}
    }
    if {$cursor ne {} && $cursor ne "ignore"} {
	catch {$w icursor $cursor}

    }
    return $pos
}

## RelIndex -- Compute character/word/line-relative index.
#
proc ttk::entry::RelIndex {w where {index insert}} {
    if {$index eq "insert" && $where eq "nextchar"} {
	# Needed for surrogate pairs:
	set icur [$w index insert]
	$w icursor [expr {$icur + 1}]
	set ret [expr {[$w index insert]}]
	$w icursor $icur
	return $ret
    }
    switch -- $where {
	prevchar	{ expr {[$w index $index] - 1} }
    	nextchar	{ expr {[$w index $index] + 1} }
	prevword	{ PrevWord $w $index }
	nextword	{ NextWord $w $index }
	home		{ return 0 }
	end		{ $w index end }

    int *height)
{
    Tcl_HashEntry *hPtr;
    Pixmap pixmap = None;
    NSString *string;
    NSImage *image = nil;
    NSSize size = { .width = builtInIconSize, .height = builtInIconSize };
    Tcl_Encoding utf8;
    Tcl_DString ds;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    Tcl_DStringInit(&ds);
    if (iconBitmapTable.buckets &&
	    (hPtr = Tcl_FindHashEntry(&iconBitmapTable, name))) {
	OSType type;
	IconBitmap *iconBitmap = (IconBitmap *) Tcl_GetHashValue(hPtr);
	name = NULL;
	size = NSMakeSize(iconBitmap->width, iconBitmap->height);
	switch (iconBitmap->kind) {
	case ICON_FILE:
	    name = Tcl_UtfToExternalDString(utf8, iconBitmap->value, -1, &ds);
	    string = [[NSString stringWithUTF8String:iconBitmap->value]
	    string = [[NSString stringWithUTF8String:name]
		    stringByExpandingTildeInPath];
	    image = [[NSWorkspace sharedWorkspace] iconForFile:string];
	    name = NULL;
	    break;
	case ICON_FILETYPE:
	    name = Tcl_UtfToExternalDString(utf8, iconBitmap->value, -1, &ds);
	    string = [NSString stringWithUTF8String:iconBitmap->value];
	    string = [NSString stringWithUTF8String:name];
	    image = [[NSWorkspace sharedWorkspace] iconForFileType:string];
	    name = NULL;
	    break;
	case ICON_OSTYPE:
	    name = Tcl_UtfToExternalDString(utf8, iconBitmap->value, -1, &ds);
	    if (OSTypeFromString(iconBitmap->value, &type) == TCL_OK) {
	    if (OSTypeFromString(name, &type) == TCL_OK) {
		string = NSFileTypeForHFSTypeCode(type);
		image = [[NSWorkspace sharedWorkspace] iconForFileType:string];
	    }
	    name = NULL;
	    break;
	case ICON_SYSTEMTYPE:
	    name = iconBitmap->value;
	    name = Tcl_UtfToExternalDString(utf8, iconBitmap->value, -1, &ds);
	    break;
	case ICON_NAMEDIMAGE:
	    name = Tcl_UtfToExternalDString(utf8, iconBitmap->value, -1, &ds);
	    string = [NSString stringWithUTF8String:iconBitmap->value];
	    string = [NSString stringWithUTF8String:name];
	    image = [NSImage imageNamed:string];
	    name = NULL;
	    break;
	case ICON_IMAGEFILE:
	    name = Tcl_UtfToExternalDString(utf8, iconBitmap->value, -1, &ds);
	    string = [[NSString stringWithUTF8String:iconBitmap->value]
	    string = [[NSString stringWithUTF8String:name]
		    stringByExpandingTildeInPath];
	    image = [[[NSImage alloc] initWithContentsOfFile:string]
		    autorelease];
	    name = NULL;
	    break;
	}
	if (image) {
	    [image setSize:size];
	}
    } else {
	name = Tcl_UtfToExternalDString(utf8, name, -1, &ds);
	string = [NSString stringWithUTF8String:name];
	image = [NSImage imageNamed:string];
	if (!image) {
	    NSURL *url = [NSURL fileURLWithPath:string];
	    if (url) {
		image = [[[NSImage alloc] initWithContentsOfURL:url]
			autorelease];

	    NSImage *iconImage = [[NSWorkspace sharedWorkspace]
				     iconForFileType: iconUTI];
	    pixmap = PixmapFromImage(display, iconImage, NSSizeToCGSize(size));
	}
    }
    *width = (int) size.width;
    *height = (int) size.height;
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);
    return pixmap;
}

/*
 *----------------------------------------------------------------------
 *
 * TkMacOSXIconBitmapObjCmd --

    const char *name)
{
    NSString *path = nil;
    NSImage *image = nil;
    NSPoint hotSpot = NSZeroPoint;
    int haveHotSpot = 0, result = TCL_ERROR;
    NSCursor *macCursor = nil;
    Tcl_Encoding utf8;
    Tcl_DString ds;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    name = Tcl_UtfToExternalDString(utf8, name, -1, &ds);
    if (name[0] == '@') {
	/*
	 * System cursor of type @filename
	 */

	macCursorPtr->type = IMAGEPATH;
	path = [NSString stringWithUTF8String:&name[1]];

	    hotSpot.y = size.height * 0.5;
	}
	hotSpot.y = -hotSpot.y;
	macCursor = [[NSCursor alloc] initWithImage:image hotSpot:hotSpot];
	[image release];
    }
    macCursorPtr->macCursor = macCursor;
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);
}

/*
 *----------------------------------------------------------------------
 *
 * TkGetCursorByName --
 *

		returnCode: (NSModalResponse) returnCode
	       contextInfo: (void *) contextInfo
{
    FilePanelCallbackInfo *callbackInfo = (FilePanelCallbackInfo *) contextInfo;

    if (returnCode == modalOK) {
	Tcl_Obj *resultObj;
	Tcl_Encoding utf8;
	Tcl_DString ds;

	utf8 = Tcl_GetEncoding(NULL, "utf-8");
	if (callbackInfo->multiple) {
	    resultObj = Tcl_NewListObj(0, NULL);
	    for (NSURL *url in [(NSOpenPanel*)panel URLs]) {
		Tcl_ExternalToUtfDString(utf8, [[url path] UTF8String], -1,
			&ds);
		Tcl_ListObjAppendElement(callbackInfo->interp, resultObj,
			Tcl_NewStringObj([[url path] UTF8String], -1));
			Tcl_NewStringObj(Tcl_DStringValue(&ds),
			    Tcl_DStringLength(&ds)));
		Tcl_DStringFree(&ds);
	    }
	} else {
	    Tcl_ExternalToUtfDString(utf8,
		    [[[panel URL]path] UTF8String], -1, &ds);
	    resultObj = Tcl_NewStringObj([[[panel URL]path] UTF8String], -1);
	    resultObj = Tcl_NewStringObj(Tcl_DStringValue(&ds),
			    Tcl_DStringLength(&ds));
	    Tcl_DStringFree(&ds);
	}
	Tcl_FreeEncoding(utf8);
	if (callbackInfo->cmdObj) {
	    Tcl_Obj **objv, **tmpv;
	    int objc, result = Tcl_ListObjGetElements(callbackInfo->interp,
		    callbackInfo->cmdObj, &objc, &objv);

	    if (result == TCL_OK && objc) {
		tmpv = (Tcl_Obj **)ckalloc(sizeof(Tcl_Obj *) * (objc + 2));

    colorPanel = [NSColorPanel sharedColorPanel];
    [colorPanel orderOut:NSApp];
    [colorPanel setContinuous:NO];
    [colorPanel setBecomesKeyOnlyIfNeeded:NO];
    [colorPanel setShowsAlpha: NO];
    [colorPanel _setUseModalAppearance:YES];
    if (title) {
	NSString *s;
	Tcl_Encoding utf8 = Tcl_GetEncoding(NULL, "utf-8");
	Tcl_DString ds;

	title = Tcl_ExternalToUtfDString(utf8, title, -1, &ds);
	NSString *s = [[NSString alloc] initWithUTF8String:title];
	s = [[NSString alloc] initWithUTF8String:title];

	[colorPanel setTitle:s];
	[s release];
	Tcl_DStringFree(&ds);
	Tcl_FreeEncoding(utf8);
    }
    if (initialColor) {
	[colorPanel setColor:initialColor];
    }
    returnCode = [NSApp runModalForWindow:colorPanel];
    if (returnCode == modalOK) {
	color = [[colorPanel color] colorUsingColorSpace:

static int
parseFileFilters(
    Tcl_Interp *interp,
    Tcl_Obj *fileTypesPtr,
    Tcl_Obj *typeVariablePtr)
{
    FileFilterList fl;

    if (!fileTypesPtr) {
	filterInfo.doFileTypes = false;
	return TCL_OK;
    }

    FileFilterList fl;

    TkInitFileFilters(&fl);
    if (TkGetFileFilters(interp, &fl, fileTypesPtr, 0) != TCL_OK) {
	TkFreeFileFilters(&fl);
	return TCL_ERROR;
    }

    filterInfo.doFileTypes = (fl.filters != NULL);

    filterInfo.fileTypeIndex = 0;
    filterInfo.fileTypeExtensions = [NSMutableArray array];
    filterInfo.fileTypeNames = [NSMutableArray array];
    filterInfo.fileTypeLabels = [NSMutableArray array];
    filterInfo.fileTypeAllowsAll = [NSMutableArray array];

    filterInfo.allowedExtensions = [NSMutableArray array];
    filterInfo.allowedExtensionsAllowAll = NO;

    if (filterInfo.doFileTypes) {
	Tcl_Encoding utf8;
	Tcl_DString ds;
	const char *str;

	utf8 = Tcl_GetEncoding(NULL, "utf-8");
	Tcl_DStringInit(&ds);
	for (FileFilter *filterPtr = fl.filters; filterPtr;
		filterPtr = filterPtr->next) {
	    NSString *name = [[NSString alloc] initWithUTF8String: filterPtr->name];
	    NSString *name;
	    NSMutableArray *clauseextensions;
	    NSMutableArray *displayextensions;
	    bool allowsAll = NO;

	    str = Tcl_UtfToExternalDString(utf8, filterPtr->name, -1, &ds);
	    name = [[NSString alloc] initWithUTF8String:str];
	    [filterInfo.fileTypeNames addObject:name];
	    [name release];
	    Tcl_DStringFree(&ds);
	    NSMutableArray *clauseextensions = [NSMutableArray array];
	    NSMutableArray *displayextensions = [NSMutableArray array];
	    clauseextensions = [NSMutableArray array];
	    displayextensions = [NSMutableArray array];
	    bool allowsAll = NO;

	    for (FileFilterClause *clausePtr = filterPtr->clauses; clausePtr;
		    clausePtr = clausePtr->next) {

		for (GlobPattern *globPtr = clausePtr->patterns; globPtr;
			globPtr = globPtr->next) {
		    const char *str = globPtr->pattern;
		    str = globPtr->pattern;
		    while (*str && (*str == '*' || *str == '.')) {
		    	str++;
		    }
		    if (*str) {
			NSString *extension;

			str = Tcl_UtfToExternalDString(utf8, str, -1, &ds);
			NSString *extension = [[NSString alloc] initWithUTF8String:str];
			extension = [[NSString alloc] initWithUTF8String:str];
			if (![filterInfo.allowedExtensions containsObject:extension]) {
			    [filterInfo.allowedExtensions addObject:extension];
			}

			[clauseextensions addObject:extension];
			[displayextensions addObject:[@"." stringByAppendingString:extension]];

			[extension release];
			Tcl_DStringFree(&ds);
		    } else {
			/*
			 * It is the all pattern (*, .* or *.*)
			 */

			allowsAll = YES;
			filterInfo.allowedExtensionsAllowAll = YES;

		    typeVariablePtr, NULL, TCL_GLOBAL_ONLY);

	    /*
	     * Check that the typevariable exists.
	     */

	    if (selectedFileTypeObj != NULL) {
		const char *selectedFileType =
			Tcl_GetString(selectedFileTypeObj);
		NSString *selectedFileTypeStr;
		NSUInteger index;

		str = Tcl_UtfToExternalDString(utf8,
			    Tcl_GetString(selectedFileTypeObj), -1, &ds);
		NSString *selectedFileTypeStr =
			[[NSString alloc] initWithUTF8String:selectedFileType];
		selectedFileTypeStr = [[NSString alloc] initWithUTF8String:str];
		NSUInteger index =
			[filterInfo.fileTypeNames indexOfObject:selectedFileTypeStr];
		index = [filterInfo.fileTypeNames indexOfObject:selectedFileTypeStr];

		if (index != NSNotFound) {
		    filterInfo.fileTypeIndex = index;
		    filterInfo.preselectFilter = true;
		}
	    }
	}

	Tcl_DStringFree(&ds);
	Tcl_FreeEncoding(utf8);
    }

    TkFreeFileFilters(&fl);
    return TCL_OK;
}

static bool

    Tcl_Obj *cmdObj = NULL, *typeVariablePtr = NULL, *fileTypesPtr = NULL;
    NSString *directory = nil, *filename = nil;
    NSString *message = nil, *title = nil;
    NSWindow *parent;
    openpanel =  [NSOpenPanel openPanel];
    NSInteger modalReturnCode = modalError;
    BOOL parentIsKey = NO;
    Tcl_Encoding utf8;
    Tcl_DString ds;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    Tcl_DStringInit(&ds);
    for (i = 1; i < objc; i += 2) {
	if (Tcl_GetIndexFromObjStruct(interp, objv[i], openOptionStrings,
		sizeof(char *), "option", TCL_EXACT, &index) != TCL_OK) {
	    goto end;
	}
	if (i + 1 == objc) {
	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		    "value for \"%s\" missing", Tcl_GetString(objv[i])));
	    Tcl_SetErrorCode(interp, "TK", "FILEDIALOG", "VALUE", NULL);
	    goto end;
	}
	switch (index) {
	case OPEN_DEFAULT:
	    break;
	case OPEN_FILETYPES:
	    fileTypesPtr = objv[i + 1];
	    break;
	case OPEN_INITDIR:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    if (len) {
		str = Tcl_UtfToExternalDString(utf8, str, -1, &ds);
		directory = [[[NSString alloc] initWithUTF8String:str]
			autorelease];
		Tcl_DStringFree(&ds);
	    }
	    break;
	case OPEN_INITFILE:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    if (len) {
		str = Tcl_UtfToExternalDString(utf8, str, -1, &ds);
		filename = [[[NSString alloc] initWithUTF8String:str]
			autorelease];
		Tcl_DStringFree(&ds);
	    }
	    break;
	case OPEN_MESSAGE:
	    str = Tcl_UtfToExternalDString(utf8,
			Tcl_GetString(objv[i + 1]), -1, &ds);
	    message = [[NSString alloc] initWithUTF8String:
		    Tcl_GetString(objv[i + 1])];
	    message = [[NSString alloc] initWithUTF8String:str];
	    Tcl_DStringFree(&ds);
	    break;
	case OPEN_MULTIPLE:
	    if (Tcl_GetBooleanFromObj(interp, objv[i + 1],
		    &multiple) != TCL_OK) {
		goto end;
	    }
	    break;
	case OPEN_PARENT:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    tkwin = Tk_NameToWindow(interp, str, tkwin);
	    if (!tkwin) {
		goto end;
	    }
	    haveParentOption = 1;
	    break;
	case OPEN_TITLE:
	    str = Tcl_UtfToExternalDString(utf8,
			Tcl_GetString(objv[i + 1]), -1, &ds);
	    title = [[NSString alloc] initWithUTF8String:
		    Tcl_GetString(objv[i + 1])];
	    title = [[NSString alloc] initWithUTF8String:str];
	    Tcl_DStringFree(&ds);
	    break;
	case OPEN_TYPEVARIABLE:
	    typeVariablePtr = objv[i + 1];
	    break;
	case OPEN_COMMAND:
	    cmdObj = objv[i+1];
	    break;

		if (j == selectedFilterIndex) {
		    selectedFilter = [filterInfo.fileTypeNames objectAtIndex:selectedFilterIndex];
		} else {
		    selectedFilter = @"";
		}
	    }
	}
	Tcl_DStringFree(&ds);
	Tcl_ExternalToUtfDString(utf8, [selectedFilter UTF8String], -1, &ds);
	Tcl_ObjSetVar2(interp, typeVariablePtr, NULL,
		Tcl_NewStringObj([selectedFilter UTF8String], -1),
		TCL_GLOBAL_ONLY);
		Tcl_NewStringObj(Tcl_DStringValue(&ds),
			Tcl_DStringLength(&ds)), TCL_GLOBAL_ONLY);
    }
 end:
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);
    return result;
}

/*
 *----------------------------------------------------------------------
 *
 * Tk_GetSaveFileObjCmd --

    Tcl_Obj *cmdObj = NULL, *typeVariablePtr = NULL, *fileTypesPtr = NULL;
    NSString *directory = nil, *filename = nil, *defaultType = nil;
    NSString *message = nil, *title = nil;
    NSWindow *parent;
    savepanel = [NSSavePanel savePanel];
    NSInteger modalReturnCode = modalError;
    BOOL parentIsKey = NO;
    Tcl_Encoding utf8;
    Tcl_DString ds;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    Tcl_DStringInit(&ds);
    for (i = 1; i < objc; i += 2) {
	if (Tcl_GetIndexFromObjStruct(interp, objv[i], saveOptionStrings,
		sizeof(char *), "option", TCL_EXACT, &index) != TCL_OK) {
	    goto end;
	}
	if (i + 1 == objc) {
	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		    "value for \"%s\" missing", Tcl_GetString(objv[i])));
	    Tcl_SetErrorCode(interp, "TK", "FILEDIALOG", "VALUE", NULL);
	    goto end;
	}
	switch (index) {
	    case SAVE_DEFAULT:
		str = Tcl_GetStringFromObj(objv[i + 1], &len);
		while (*str && (*str == '*' || *str == '.')) {
		    str++;
		}
		if (*str) {
		    defaultType = [[[NSString alloc] initWithUTF8String:str]
			    autorelease];
		}
		break;
	    case SAVE_FILETYPES:
		fileTypesPtr = objv[i + 1];
		break;
	    case SAVE_INITDIR:
		str = Tcl_GetStringFromObj(objv[i + 1], &len);
		if (len) {
		    directory = [[[NSString alloc] initWithUTF8String:str]
			    autorelease];
		}
		break;
	    case SAVE_INITFILE:
		str = Tcl_GetStringFromObj(objv[i + 1], &len);
		if (len) {
		    filename = [[[NSString alloc] initWithUTF8String:str]
			    autorelease];
		    [savepanel setNameFieldStringValue:filename];
		}
		break;
	    case SAVE_MESSAGE:
		message = [[NSString alloc] initWithUTF8String:
			Tcl_GetString(objv[i + 1])];
		break;
	    case SAVE_PARENT:
		str = Tcl_GetStringFromObj(objv[i + 1], &len);
		tkwin = Tk_NameToWindow(interp, str, tkwin);
		if (!tkwin) {
		    goto end;
		}
		haveParentOption = 1;
		break;
	    case SAVE_TITLE:
		title = [[NSString alloc] initWithUTF8String:
			Tcl_GetString(objv[i + 1])];
		break;
	    case SAVE_TYPEVARIABLE:
		typeVariablePtr = objv[i + 1];
		break;
	    case SAVE_COMMAND:
		cmdObj = objv[i+1];
		break;
	    case SAVE_CONFIRMOW:
		if (Tcl_GetBooleanFromObj(interp, objv[i + 1],
			&confirmOverwrite) != TCL_OK) {
		    goto end;
		}
		break;
	    case SAVE_NATIVEONLY:
		if (Tcl_GetBooleanFromObj(interp, objv[i + 1],
			&dummy) != TCL_OK) {
		    goto end;
		}
		break;
	case SAVE_DEFAULT:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    while (*str && (*str == '*' || *str == '.')) {
		str++;
	    }
	    if (*str) {
		str = Tcl_UtfToExternalDString(utf8, str, -1, &ds);
		defaultType = [[[NSString alloc] initWithUTF8String:str]
			autorelease];
		Tcl_DStringFree(&ds);
	    }
	    break;
	case SAVE_FILETYPES:
	    fileTypesPtr = objv[i + 1];
	    break;
	case SAVE_INITDIR:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    if (len) {
		str = Tcl_UtfToExternalDString(utf8, str, -1, &ds);
		directory = [[[NSString alloc] initWithUTF8String:str]
			autorelease];
		Tcl_DStringFree(&ds);
	    }
	    break;
	case SAVE_INITFILE:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    if (len) {
		str = Tcl_UtfToExternalDString(utf8, str, -1, &ds);
		filename = [[[NSString alloc] initWithUTF8String:str]
			autorelease];
		[savepanel setNameFieldStringValue:filename];
		Tcl_DStringFree(&ds);
	    }
	    break;
	case SAVE_MESSAGE:
	    str = Tcl_UtfToExternalDString(utf8,
			Tcl_GetString(objv[i + 1]), -1, &ds);
	    message = [[NSString alloc] initWithUTF8String:str];
	    Tcl_DStringFree(&ds);
	    break;
	case SAVE_PARENT:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    tkwin = Tk_NameToWindow(interp, str, tkwin);
	    if (!tkwin) {
		goto end;
	    }
	    haveParentOption = 1;
	    break;
	case SAVE_TITLE:
	    str = Tcl_UtfToExternalDString(utf8,
			Tcl_GetString(objv[i + 1]), -1, &ds);
	    title = [[NSString alloc] initWithUTF8String:str];
	    Tcl_DStringFree(&ds);
	    break;
	case SAVE_TYPEVARIABLE:
	    typeVariablePtr = objv[i + 1];
	    break;
	case SAVE_COMMAND:
	    cmdObj = objv[i+1];
	    break;
	case SAVE_CONFIRMOW:
	    if (Tcl_GetBooleanFromObj(interp, objv[i + 1],
		    &confirmOverwrite) != TCL_OK) {
		goto end;
	    }
	    break;
	case SAVE_NATIVEONLY:
	    if (Tcl_GetBooleanFromObj(interp, objv[i + 1],
		    &dummy) != TCL_OK) {
		goto end;
	    }
	    break;
	}
    }

    if (title) {
	[savepanel setTitle:title];

	/*

    if (typeVariablePtr && (modalReturnCode == NSOKButton)
	    && filterInfo.doFileTypes) {
	/*
	 * The -typevariable must be set to the selected file type, if the
	 * dialog was not cancelled.
	 */
	NSString *selectedFilter = [filterInfo.fileTypeNames objectAtIndex:filterInfo.fileTypeIndex];

	Tcl_DStringFree(&ds);
	NSString *selectedFilter =
	Tcl_ExternalToUtfDString(utf8, [selectedFilter UTF8String], -1, &ds);
	    [filterInfo.fileTypeNames objectAtIndex:filterInfo.fileTypeIndex];
	Tcl_ObjSetVar2(interp, typeVariablePtr, NULL,
		Tcl_NewStringObj([selectedFilter UTF8String], -1),
		TCL_GLOBAL_ONLY);
		Tcl_NewStringObj(Tcl_DStringValue(&ds),
			Tcl_DStringLength(&ds)), TCL_GLOBAL_ONLY);
    }

  end:
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);
    return result;
}

/*
 *----------------------------------------------------------------------
 *
 * Tk_ChooseDirectoryObjCmd --

    Tcl_Obj *cmdObj = NULL;
    NSString *directory = nil;
    NSString *message, *title;
    NSWindow *parent;
    NSOpenPanel *panel = [NSOpenPanel openPanel];
    NSInteger modalReturnCode = modalError;
    BOOL parentIsKey = NO;
    Tcl_Encoding utf8;
    Tcl_DString ds;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    Tcl_DStringInit(&ds);
    for (i = 1; i < objc; i += 2) {
	if (Tcl_GetIndexFromObjStruct(interp, objv[i], chooseOptionStrings,
		sizeof(char *), "option", TCL_EXACT, &index) != TCL_OK) {
	    goto end;
	}
	if (i + 1 == objc) {
	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		    "value for \"%s\" missing", Tcl_GetString(objv[i])));
	    Tcl_SetErrorCode(interp, "TK", "DIRDIALOG", "VALUE", NULL);
	    goto end;
	}
	switch (index) {
	case CHOOSE_INITDIR:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    if (len) {
		str = Tcl_UtfToExternalDString(utf8, str, -1, &ds);
		directory = [[[NSString alloc] initWithUTF8String:str]
			autorelease];
		Tcl_DStringFree(&ds);
	    }
	    break;
	case CHOOSE_MESSAGE:
	    message = [[NSString alloc] initWithUTF8String:
		    Tcl_GetString(objv[i + 1])];
	    str = Tcl_UtfToExternalDString(utf8,
			Tcl_GetString(objv[i + 1]), -1, &ds);
	    message = [[NSString alloc] initWithUTF8String:str];
	    [panel setMessage:message];
	    [message release];
	    Tcl_DStringFree(&ds);
	    break;
	case CHOOSE_MUSTEXIST:
	    if (Tcl_GetBooleanFromObj(interp, objv[i + 1],
		    &mustexist) != TCL_OK) {
		goto end;
	    }
	    break;
	case CHOOSE_PARENT:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    tkwin = Tk_NameToWindow(interp, str, tkwin);
	    if (!tkwin) {
		goto end;
	    }
	    haveParentOption = 1;
	    break;
	case CHOOSE_TITLE:
	    title = [[NSString alloc] initWithUTF8String:
		    Tcl_GetString(objv[i + 1])];
	    str = Tcl_UtfToExternalDString(utf8,
			Tcl_GetString(objv[i + 1]), -1, &ds);
	    title = [[NSString alloc] initWithUTF8String:str];
	    [panel setTitle:title];
	    [title release];
	    Tcl_DStringFree(&ds);
	    break;
	case CHOOSE_COMMAND:
	    cmdObj = objv[i+1];
	    break;
	case CHOOSE_NATIVEONLY:
	    if (Tcl_GetBooleanFromObj(interp, objv[i + 1],
		    &dummy) != TCL_OK) {

	Tcl_DecrRefCount(cmdObj);
    }
    result = (modalReturnCode != modalError) ? TCL_OK : TCL_ERROR;
    if (parentIsKey) {
	[parent makeKeyWindow];
    }
  end:
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);
    return result;
}

/*
 *----------------------------------------------------------------------
 *
 * TkAboutDlg --

    AlertCallbackInfo callbackInfo;
    NSString *message, *title;
    NSWindow *parent;
    NSArray *buttons;
    NSAlert *alert = [NSAlert new];
    NSInteger modalReturnCode = 1;
    BOOL parentIsKey = NO;
    Tcl_Encoding utf8;
    Tcl_DString ds;

    iconIndex = ICON_INFO;
    typeIndex = TYPE_OK;
    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    Tcl_DStringInit(&ds);
    for (i = 1; i < objc; i += 2) {
	if (Tcl_GetIndexFromObjStruct(interp, objv[i], alertOptionStrings,
		sizeof(char *), "option", TCL_EXACT, &index) != TCL_OK) {
	    goto end;
	}
	if (i + 1 == objc) {
	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(

	     * know the '-type' as well.
	     */

	    indexDefaultOption = i;
	    break;

	case ALERT_DETAIL:
	    message = [[NSString alloc] initWithUTF8String:
		    Tcl_GetString(objv[i + 1])];
	    str = Tcl_ExternalToUtfDString(utf8,
			Tcl_GetString(objv[i + 1]), -1, &ds);
	    message = [[NSString alloc] initWithUTF8String:str];
	    [alert setInformativeText:message];
	    [message release];
	    Tcl_DStringFree(&ds);
	    break;

	case ALERT_ICON:
	    if (Tcl_GetIndexFromObjStruct(interp, objv[i + 1], alertIconStrings,
		    sizeof(char *), "-icon value", TCL_EXACT, &iconIndex) != TCL_OK) {
		goto end;
	    }
	    break;

	case ALERT_MESSAGE:
	    message = [[NSString alloc] initWithUTF8String:
		    Tcl_GetString(objv[i + 1])];
	    str = Tcl_ExternalToUtfDString(utf8,
			Tcl_GetString(objv[i + 1]), -1, &ds);
	    message = [[NSString alloc] initWithUTF8String:str];
	    [alert setMessageText:message];
	    [message release];
	    Tcl_DStringFree(&ds);
	    break;

	case ALERT_PARENT:
	    str = Tcl_GetString(objv[i + 1]);
	    tkwin = Tk_NameToWindow(interp, str, tkwin);
	    if (!tkwin) {
		goto end;
	    }
	    haveParentOption = 1;
	    break;

	case ALERT_TITLE:
	    title = [[NSString alloc] initWithUTF8String:
		    Tcl_GetString(objv[i + 1])];
	    str = Tcl_ExternalToUtfDString(utf8,
			Tcl_GetString(objv[i + 1]), -1, &ds);
	    title = [[NSString alloc] initWithUTF8String:str];
	    [[alert window] setTitle:title];
	    [title release];
	    Tcl_DStringFree(&ds);
	    break;

	case ALERT_TYPE:
	    if (Tcl_GetIndexFromObjStruct(interp, objv[i + 1], alertTypeStrings,
		    sizeof(char *), "-type value", TCL_EXACT, &typeIndex) != TCL_OK) {
		goto end;
	    }

 *	None.
 *
 *---------------------------------------------------------------------------
 */

#if TCL_UTF_MAX == 3

/* No special code for BMP needed. */
/* No special code for WTF-8 needed. */
#define NumUTF16Chars Tcl_NumUtfChars

#else

static int
NumUTF16Chars(
    const char *src,		/* The UTF-8 string to measure. */
    int length)			/* The length of the string in bytes, or -1
				 * for strlen(string). */
{
    Tcl_UniChar ch = 0;
    int i = 0;

    if (length < 0) {
	while (*src != '\0') {
	    src += Tcl_UtfToUniChar(src, &ch);
#if TCL_UTF_MAX > 4
	    if (ch > 0xFFFF) {
		/* A surrogate pair in UTF16Char representation. */
		i++;
	    }
#endif
            i++;
        }
	if (i < 0) {
	    i = INT_MAX;
	}
    } else {
	const char *endPtr = src + length - 4;
	const char *endPtr = src + length - TCL_UTF_MAX;

	while (src < endPtr) {
	    src += Tcl_UtfToUniChar(src, &ch);
	    if (ch > 0xFFFF) {
		/* A surrogate pair in UTF16Char representation. */
		i++;
	    }
	    i++;
	}
#if TCL_UTF_MAX > 4
	endPtr += TCL_UTF_MAX;
	while ((src < endPtr) && Tcl_UtfCharComplete(src, endPtr - src)) {
	    src += Tcl_UtfToUniChar(src, &ch);
	    if (ch > 0xFFFF) {
		/* A surrogate pair in UTF16Char representation. */
		i++;
	    }
#endif
	    i++;
	}
	endPtr += 4;
	while ((src < endPtr) && Tcl_UtfCharComplete(src, endPtr - src)) {
	    src += Tcl_UtfToUniChar(src, &ch);
#if TCL_UTF_MAX > 4
	    if (ch > 0xFFFF) {
		/* A surrogate pair in UTF16Char representation. */
		i++;
	    }
#endif
	    i++;
	}
	if (src < endPtr) {
	    i += endPtr - src;
	}
    }
    return i;

    while (src < end && index > 0) {
	--index;
	if (Tcl_UtfCharComplete(src, end - src)) {
	    src += Tcl_UtfToUniChar(src, &ch);
	} else {
	    ch = *src++ & 0x00FF;
	}
#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
	if (ch > 0xFFFF) {
	    /* A surrogate pair in UTF16Char representation. */
	    --index;
	}
#endif
    }
    return src;

    const char *src,		/* Input UTF-8 string to be converted.
				 * Need not be '\0' terminated. */
    int numBytes,		/* Maximum number of bytes to consider from
				 * source string in all. */
    Tcl_DString *dsPtr,		/* Tcl_DString receiving the result. */
    int *lengthPtr)		/* Number of UTF16Chars in result buffer. */
{
    Tcl_UniChar ch = 0;
    Tcl_UniChar ch;
    UTF16Char utf16;
    const char *end;

    Tcl_DStringInit(dsPtr);
    if (numBytes > 0) {
	Tcl_DStringSetLength(dsPtr, numBytes * sizeof(utf16));
	Tcl_DStringSetLength(dsPtr, 0);
    }
    end = src + numBytes;
    while (src < end) {
	int len;

	if (Tcl_UtfCharComplete(src, end - src)) {
	    len = Tcl_UtfToUniChar(src, &ch);
	    src += Tcl_UtfToUniChar(src, &ch);
	} else {
	    len = 1;
	    ch = *src & 0x00FF;
	    ch = *src++ & 0x00FF;
	}

	utf16 = ch;
#if TCL_UTF_MAX < 4
#if TCL_UTF_MAX > 3
	if (ch >= 0xD800 && ch <= 0xDFFF) {
	    utf16 = 0xFFFD;
	}
#elif TCL_UTF_MAX == 4
	if (ch >= 0xD800 && ch <= 0xDFFF) {
	    if ((*src & 0xF8) != 0xF0) {
		utf16 = 0xFFFD;
	    }
	}
#else
	if (ch >= 0xD800 && ch <= 0xDFFF) {
	    utf16 = 0xFFFD;
	} else if (ch > 0xFFFF) {
	    utf16 = (((ch - 0x10000) >> 10) & 0x3FF) | 0xD800;
	    Tcl_DStringAppend(dsPtr, (char *) &utf16, sizeof(utf16));
	    utf16 = ((ch - 0x10000) & 0x3FF) | 0xDC00;
	}
#endif
	Tcl_DStringAppend(dsPtr, (char *) &utf16, sizeof(utf16));
	src += len;
#else
	if (ch >= 0xD800 && ch <= 0xDBFF) {
	    if (!Tcl_UtfCharComplete(src, end - src)) {
		utf16 = 0xFFFD;
	    } else {
		int len = Tcl_UtfToUniChar(src, &ch);

		if (ch >= 0xDC00 && ch <= 0xDFFF) {
		    Tcl_DStringAppend(dsPtr, (char *) &utf16, sizeof(utf16));
		    utf16 = ch;
		    src += len;
		} else {
		    utf16 = 0xFFFD;
		}
	    }
	} else if (ch >= 0xDC00 && ch <= 0xDFFF) {
	    utf16 = 0xFFFD;
	}
#endif
	Tcl_DStringAppend(dsPtr, (char *) &utf16, sizeof(utf16));
    }
    *lengthPtr = Tcl_DStringLength(dsPtr) / sizeof(utf16);
    return (UTF16Char *) Tcl_DStringValue(dsPtr);
}

/*
 *---------------------------------------------------------------------------

static void
GetTkFontAttributesForNSFont(
    NSFont *nsFont,
    TkFontAttributes *faPtr)
{
    NSFontTraitMask traits = [[NSFontManager sharedFontManager]
	    traitsOfFont:nsFont];
    Tcl_Encoding utf8;
    Tcl_DString ds;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    Tcl_ExternalToUtfDString(utf8, [[nsFont familyName] UTF8String], -1, &ds);
    faPtr->family = Tk_GetUid([[nsFont familyName] UTF8String]);
    faPtr->family = Tk_GetUid(Tcl_DStringValue(&ds));
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);
    faPtr->size = [nsFont pointSize];
    faPtr->weight = (traits & NSBoldFontMask ? TK_FW_BOLD : TK_FW_NORMAL);
    faPtr->slant = (traits & NSItalicFontMask ? TK_FS_ITALIC : TK_FS_ROMAN);
}

/*
 *---------------------------------------------------------------------------

{
    NSFontManager *fm = [NSFontManager sharedFontManager];
    NSFont *nsFont, *dflt = nil;
    #define defaultFont (dflt ? dflt : (dflt = [NSFont systemFontOfSize:0]))
    NSString *family;

    if (familyName) {
	Tcl_Encoding utf8;
	Tcl_DString ds;

	utf8 = Tcl_GetEncoding(NULL, "utf-8");
	familyName = Tcl_UtfToExternalDString(utf8, familyName, -1, &ds);
	family = [[[NSString alloc] initWithUTF8String:familyName] autorelease];
	Tcl_DStringFree(&ds);
	Tcl_FreeEncoding(utf8);
    } else {
	family = [defaultFont familyName];
    }
    if (size == 0.0) {
	size = [defaultFont pointSize];
    }
    nsFont = [fm fontWithFamily:family traits:traits weight:weight size:size];

void
TkpGetFontFamilies(
    Tcl_Interp *interp,		/* Interp to hold result. */
    Tk_Window tkwin)		/* For display to query. */
{
    Tcl_Obj *resultPtr = Tcl_NewListObj(0, NULL);
    NSArray *list = [[NSFontManager sharedFontManager] availableFontFamilies];
    Tcl_Encoding utf8;
    Tcl_DString ds;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    for (NSString *family in list) {
	Tcl_ExternalToUtfDString(utf8, [family UTF8String], -1, &ds);
	Tcl_ListObjAppendElement(NULL, resultPtr,
		Tcl_NewStringObj([family UTF8String], -1));
		Tcl_NewStringObj(Tcl_DStringValue(&ds),
			Tcl_DStringLength(&ds)));
	Tcl_DStringFree(&ds);
    }
    Tcl_FreeEncoding(utf8);
    Tcl_SetObjResult(interp, resultPtr);
}

/*
 *-------------------------------------------------------------------------
 *
 * TkpGetSubFonts --

{
    MacFont *fontPtr = (MacFont *) tkfont;
    Tcl_Obj *resultPtr = Tcl_NewListObj(0, NULL);

    if (fontPtr->nsFont) {
	NSArray *list = [[fontPtr->nsFont fontDescriptor]
		objectForKey:NSFontCascadeListAttribute];
	Tcl_Encoding utf8;
	Tcl_DString ds;

	utf8 = Tcl_GetEncoding(NULL, "utf-8");
	for (NSFontDescriptor *subFontDesc in list) {
	    NSString *family = [subFontDesc objectForKey:NSFontFamilyAttribute];

	    if (family) {
		Tcl_ExternalToUtfDString(utf8, [family UTF8String], -1, &ds);
		Tcl_ListObjAppendElement(NULL, resultPtr,
			Tcl_NewStringObj([family UTF8String], -1));
			Tcl_NewStringObj(Tcl_DStringValue(&ds),
				Tcl_DStringLength(&ds)));
		Tcl_DStringFree(&ds);
	    }
	}
	Tcl_FreeEncoding(utf8);
    }
    Tcl_SetObjResult(interp, resultPtr);
}

/*
 *----------------------------------------------------------------------
 *

    if (nsFont && familyName) {
	NSFontTraitMask traits = [[NSFontManager sharedFontManager]
		traitsOfFont:nsFont];
	id underline = [nsAttributes objectForKey:
		NSUnderlineStyleAttributeName];
	id strikethrough = [nsAttributes objectForKey:
		NSStrikethroughStyleAttributeName];
	Tcl_Encoding utf8;
	Tcl_DString ds;

	utf8 = Tcl_GetEncoding(NULL, "utf-8");
	familyName = Tcl_ExternalToUtfDString(utf8, familyName, -1, &ds);
	objv[i++] = Tcl_NewStringObj(familyName, -1);
	Tcl_DStringFree(&ds);
	Tcl_FreeEncoding(utf8);
	objv[i++] = Tcl_NewWideIntObj((Tcl_WideInt) floor([nsFont pointSize] + 0.5));
#define S(s)    Tcl_NewStringObj(STRINGIFY(s),(int)(sizeof(STRINGIFY(s))-1))
	objv[i++] = (traits & NSBoldFontMask)	? S(bold)   : S(normal);
	objv[i++] = (traits & NSItalicFontMask)	? S(italic) : S(roman);
	if ([underline respondsToSelector:@selector(intValue)] &&
		([underline intValue] & (NSUnderlineStyleSingle |
		NSUnderlineStyleThick | NSUnderlineStyleDouble))) {

    }
}

- (NSString *) tkFrameworkImagePath: (NSString *) image
{
    NSString *path = nil;
    NSAutoreleasePool *pool = [NSAutoreleasePool new];
    Tcl_Encoding utf8;
    Tcl_DString ds;
    char *str;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    if (tkLibPath[0] != '\0') {
	str = Tcl_UtfToExternalDString(utf8, tkLibPath, -1, &ds);
	path = [[NSBundle bundleWithPath:[[NSString stringWithUTF8String:
		tkLibPath] stringByAppendingString:@"/../.."]]
	path = [[NSBundle bundleWithPath:[[NSString stringWithUTF8String:str]
		stringByAppendingString:@"/../.."]]
		pathForImageResource:image];
	Tcl_DStringFree(&ds);
    }
    if (!path) {
	const char *tk_library = Tcl_GetVar2(_eventInterp, "tk_library", NULL,
		TCL_GLOBAL_ONLY);

	if (tk_library) {
	    NSFileManager *fm = [NSFileManager defaultManager];

	    str = Tcl_UtfToExternalDString(utf8, tk_library, -1, &ds);
	    path = [[NSString stringWithUTF8String:tk_library]
	    path = [[NSString stringWithUTF8String:str]
		    stringByAppendingFormat:@"/%@", image];
	    if (![fm isReadableFileAtPath:path]) {
		path = [[NSString stringWithUTF8String:tk_library]
		path = [[NSString stringWithUTF8String:str]
			stringByAppendingFormat:@"/../macosx/%@", image];
		if (![fm isReadableFileAtPath:path]) {
		    path = nil;
		}
	    }
	    Tcl_DStringFree(&ds);
	}
    }
#ifdef TK_MAC_DEBUG
    if (!path && getenv("TK_SRCROOT")) {
	path = [[NSString stringWithUTF8String:getenv("TK_SRCROOT")]
		stringByAppendingFormat:@"/macosx/%@", image];
	if (![[NSFileManager defaultManager] isReadableFileAtPath:path]) {
	    path = nil;
	}
    }
#endif
    Tcl_FreeEncoding(utf8);
    [path retain];
    [pool drain];
    return path;
}
@end

#pragma mark -

MODULE_SCOPE Tcl_Obj*
TkMacOSXGetStringObjFromCFString(
    CFStringRef str)
{
    Tcl_Obj *obj = NULL;
    const char *c = CFStringGetCStringPtr(str, kCFStringEncodingUTF8);
    Tcl_Encoding utf8;
    Tcl_DString ds, buffer;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    if (c) {
	c = Tcl_ExternalToUtfDString(utf8, c, -1, &ds);
	obj = Tcl_NewStringObj(c, -1);
	obj = Tcl_NewStringObj(Tcl_DStringValue(&ds),
		    Tcl_DStringLength(&ds));
    } else {
	CFRange all = CFRangeMake(0, CFStringGetLength(str));
	CFIndex len;

	if (CFStringGetBytes(str, all, kCFStringEncodingUTF8, 0, false, NULL,
		0, &len) > 0 && len < INT_MAX) {
	    obj = Tcl_NewObj();
	    Tcl_SetObjLength(obj, len);
	    Tcl_DStringInit(&buffer);
	    Tcl_DStringSetLength(&buffer, len);
	    CFStringGetBytes(str, all, kCFStringEncodingUTF8, 0, false,
		    (UInt8*) obj->bytes, len, NULL);
	}
    }
		    (UInt8*) Tcl_DStringValue(&ds), len, NULL);
	    c = Tcl_ExternalToUtfDString(utf8, Tcl_DStringValue(&buffer),
		    Tcl_DStringLength(&buffer), &ds);
	    Tcl_DStringFree(&buffer);
	    if (Tcl_DStringLength(&ds) < INT_MAX) {
		obj = Tcl_NewStringObj(Tcl_DStringValue(&ds),
			    Tcl_DStringLength(&ds));
	    }
	}
    }
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);
    return obj;
}

/*
 * Local Variables:
 * mode: objc
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

	Tk_Window focusWin = (Tk_Window) winPtr->dispPtr->focusPtr;
	TkSendVirtualEvent(focusWin, "TkAccentBackspace", NULL);
    }

    /*
     * NSString represents a non-BMP character as a string of length 2 where
     * the first character is the high surrogate and the second character is
     * the low surrogate.  We could record this in the XEvent by setting the
     * the low surrogate.
     * keycode to the unicode code point and setting the trans_chars to the
     * 4-byte UTF-8 string.  However, that will not help as long as TCL_UTF_MAX
     * is set to 3.  Until that changes, we just replace non-BMP characters by
     * the "replacement character" U+FFFD.
     */

    for (i = 0; i < len; i++) {
	UniChar nextChar = [str characterAtIndex: i];
	if (CFStringIsSurrogateHighCharacter(nextChar)) {
#if TCL_UTF_MAX > 3
	    UniChar lowChar = [str characterAtIndex: ++i];
	    xEvent.xkey.keycode = CFStringGetLongCharacterForSurrogatePair(
		nextChar, lowChar);
	    xEvent.xkey.nbytes = Tcl_UniCharToUtf(xEvent.xkey.keycode,
						  &xEvent.xkey.trans_chars);
	    xEvent.xkey.nbytes = TkUniCharToUtf(xEvent.xkey.keycode,
						&xEvent.xkey.trans_chars);
	    xEvent.xkey.trans_chars[xEvent.xkey.nbytes] = '\0';
#else
	    i++;
	    xEvent.xkey.keycode = 0xfffd;
	    strcpy(xEvent.xkey.trans_chars, "\xef\xbf\xbd");
	    xEvent.xkey.nbytes = strlen(xEvent.xkey.trans_chars);
#endif
	} else {
	    xEvent.xkey.keycode = (int) nextChar;
	    [[str substringWithRange: NSMakeRange(i,1)]
	        getCString: xEvent.xkey.trans_chars
		maxLength: XMaxTransChars-1 encoding: NSUTF8StringEncoding];
	    xEvent.xkey.nbytes = strlen(xEvent.xkey.trans_chars);
	}

	[self setDelegate:self];
    }
    return self;
}

- (id) initWithTkMenu: (TkMenu *) tkMenu
{
    NSString *title = [[NSString alloc] initWithUTF8String:
	    Tk_PathName(tkMenu->tkwin)];
    NSString *title;
    Tcl_Encoding utf8;
    Tcl_DString ds;
    char *name;

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    name = Tcl_UtfToExternalDString(utf8, Tk_PathName(tkMenu->tkwin), -1, &ds);
    title = [[NSString alloc] initWithUTF8String:name];
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);
    self = [self initWithTitle:title];
    [title release];
    if (self) {
	_tkMenu = tkMenu;
    }
    return self;
}

	    /* Use a semantic foreground color by default. */
	    [image setTemplate:YES];
	}
    }
    [menuItem setImage:image];
    if ((!image || mePtr->compound != COMPOUND_NONE) && mePtr->labelPtr &&
	    mePtr->labelLength) {
	Tcl_Encoding utf8;
	Tcl_DString ds;

	utf8 = Tcl_GetEncoding(NULL, "utf-8");
	Tcl_UtfToExternalDString(utf8, Tcl_GetString(mePtr->labelPtr),
		mePtr->labelLength, &ds);
	title = [[[NSString alloc] initWithBytes:Tcl_GetString(mePtr->labelPtr)
		length:mePtr->labelLength encoding:NSUTF8StringEncoding]
	title = [[[NSString alloc] initWithBytes:Tcl_DStringValue(&ds)
		length:Tcl_DStringLength(&ds) encoding:NSUTF8StringEncoding]
		autorelease];
	if ([title hasSuffix:@"..."]) {
	    title = [NSString stringWithFormat:@"%@%C",
		    [title substringToIndex:[title length] - 3], 0x2026];
	}
	Tcl_DStringFree(&ds);
	Tcl_FreeEncoding(utf8);
    }
    [menuItem setTitle:title];
    if (strcmp(Tcl_GetString(fontPtr), "menu") || gc->foreground != defaultFg
	    || gc->background != defaultBg) {
	attributes = TkMacOSXNSFontAttributesForFont(Tk_GetFontFromObj(
		mePtr->menuPtr->tkwin, fontPtr));
	if (gc->foreground != defaultFg || gc->background != defaultBg) {

	    }
	    i++;
	}
    }
    if (ch) {
	return [[[NSString alloc] initWithCharacters:&ch length:1] autorelease];
    } else {
	NSString *result;
	Tcl_Encoding utf8;
	Tcl_DString ds;

	utf8 = Tcl_GetEncoding(NULL, "utf-8");
	accel = Tcl_UtfToExternalDString(utf8, accel, -1, &ds);
	return [[[[NSString alloc] initWithUTF8String:accel] autorelease]
		lowercaseString];
	result = [[[[NSString alloc] initWithUTF8String:accel] autorelease]
		    lowercaseString];
	Tcl_DStringFree(&ds);
	Tcl_FreeEncoding(utf8);
	return result;
    }
}

/*
 *--------------------------------------------------------------
 *
 * ModifierCharWidth --

	 */

	int width, height;
	Tk_Window tkwin = Tk_MainWindow(interp);
	TkWindow *winPtr = (TkWindow *)tkwin;
	Display *d = winPtr->display;
	NSImage *icon;
	Tcl_Encoding utf8;
	Tcl_DString ds;

	tk_image = Tk_GetImage(interp, tkwin, Tcl_GetString(objv[2]), NULL, NULL);
	if (tk_image == NULL) {
	    return TCL_ERROR;
	}

	Tk_SizeOfImage(tk_image, &width, &height);
	if (width != 0 && height != 0) {
	    icon = TkMacOSXGetNSImageWithTkImage(d, tk_image,
						 width, height);
	    [statusItem setImagewithImage: icon];
	    Tk_FreeImage(tk_image);
	}

	/*
	 * Set the text for the tooltip.
	 */

	utf8 = Tcl_GetEncoding(NULL, "utf-8");
	Tcl_UtfToExternalDString(utf8, Tcl_GetString(objv[3]), -1, &ds);
	NSString *tooltip = [NSString stringWithUTF8String: Tcl_GetString(objv[3])];
	NSString *tooltip = [NSString stringWithUTF8String: Tcl_DStringValue(&ds)];
	Tcl_DStringFree(&ds);
	Tcl_FreeEncoding(utf8);
	if (tooltip == nil) {
	    Tcl_AppendResult(interp, " unable to set tooltip for systray icon", NULL);
	    return TCL_ERROR;
	}

	[statusItem setTextwithString: tooltip];

	}

        /*
         * Modify the text for the tooltip.
         */

	case TRAY_TEXT: {
	    Tcl_Encoding utf8;
	    Tcl_DString ds;

	    utf8 = Tcl_GetEncoding(NULL, "utf-8");
	    Tcl_UtfToExternalDString(utf8, Tcl_GetString(objv[3]), -1, &ds);
	    NSString *tooltip = [NSString stringWithUTF8String:Tcl_GetString(objv[3])];
	    NSString *tooltip = [NSString stringWithUTF8String: Tcl_DStringValue(&ds)];
	    Tcl_DStringFree(&ds);
	    Tcl_FreeEncoding(utf8);
	    if (tooltip == nil) {
		Tcl_AppendResult(interp, "unable to set tooltip for systray icon",
				 NULL);
		return TCL_ERROR;
	    }

	    [statusItem setTextwithString: tooltip];

static int
SysNotifyObjCmd(
    ClientData clientData,
    Tcl_Interp * interp,
    int objc,
    Tcl_Obj *const *objv)
{
    Tcl_Encoding utf8;
    Tcl_DString ds;

    if (objc < 3) {
	Tcl_WrongNumArgs(interp, 1, objv, "title message");
	return TCL_ERROR;
    }

    if ([NSApp macOSVersion] < 101000) {
	Tcl_AppendResult(interp,
	    "Notifications not supported on macOS versions lower than 10.10",
	     NULL);
	return TCL_OK;
    }

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    Tcl_UtfToExternalDString(utf8, Tcl_GetString(objv[1]), -1, &ds);
    NSString *title = [NSString stringWithUTF8String: Tcl_GetString(objv[1])];
    NSString *message = [NSString stringWithUTF8String: Tcl_GetString(objv[2])];
    NSString *title = [NSString stringWithUTF8String: Tcl_DStringValue(&ds)];
    Tcl_DStringFree(&ds);
    Tcl_UtfToExternalDString(utf8, Tcl_GetString(objv[2]), -1, &ds);
    NSString *message = [NSString stringWithUTF8String: Tcl_DStringValue(&ds)];
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);

    /*
     * Update the authorization status in case the user enabled or disabled
     * notifications after the app started up.
     */

#if BUILD_TARGET_HAS_UN_FRAMEWORK

	}
	break;
    case WMATT_TITLEPATH: {
	const char *path = (const char *) Tcl_FSGetNativePath(value);
	NSString *filename = @"";

	if (path && *path) {
	    Tcl_Encoding utf8;
	    Tcl_DString ds;

	    utf8 = Tcl_GetEncoding(NULL, "utf-8");
	    path = Tcl_UtfToExternalDString(utf8, path, -1, &ds);
	    filename = [NSString stringWithUTF8String:path];
	    Tcl_DStringFree(&ds);
	    Tcl_FreeEncoding(utf8);
	}
	[macWindow setRepresentedFilename:filename];
	break;
    }
    case WMATT_TOPMOST:
	if (Tcl_GetBooleanFromObj(interp, value, &boolean) != TCL_OK) {
	    return TCL_ERROR;

	break;
    case WMATT_MODIFIED:
	result = Tcl_NewBooleanObj([macWindow isDocumentEdited]);
	break;
    case WMATT_NOTIFY:
	result = Tcl_NewBooleanObj(tkMacOSXWmAttrNotifyVal);
	break;
    case WMATT_TITLEPATH:
	result = Tcl_NewStringObj([[macWindow representedFilename] UTF8String],
		-1);
    case WMATT_TITLEPATH: {
	Tcl_Encoding utf8;
	Tcl_DString ds;

	utf8 = Tcl_GetEncoding(NULL, "utf-8");
	Tcl_ExternalToUtfDString(utf8,
		[[macWindow representedFilename] UTF8String], -1, &ds);
	result = Tcl_NewStringObj(Tcl_DStringValue(&ds),
			Tcl_DStringLength(&ds));
	Tcl_DStringFree(&ds);
	Tcl_FreeEncoding(utf8);
	break;
    }
    case WMATT_TOPMOST:
	result = Tcl_NewBooleanObj(wmPtr->flags & WM_TOPMOST);
	break;
    case WMATT_TRANSPARENT:
	result = Tcl_NewBooleanObj(wmPtr->flags & WM_TRANSPARENT);
	break;
    case WMATT_TYPE:

 */

void
TkSetWMName(
    TkWindow *winPtr,
    Tk_Uid titleUid)
{
    Tcl_Encoding utf8;
    Tcl_DString ds;
    char *tStr;

    if (Tk_IsEmbedded(winPtr)) {
	return;
    }

    utf8 = Tcl_GetEncoding(NULL, "utf-8");
    tStr = Tcl_UtfToExternalDString(utf8, (const char *) titleUid, -1, &ds); 
    NSString *title = [[NSString alloc] initWithUTF8String:titleUid];
    NSString *title = [[NSString alloc] initWithUTF8String:tStr];
    [TkMacOSXDrawableWindow(winPtr->window) setTitle:title];
    [title release];
    Tcl_DStringFree(&ds);
    Tcl_FreeEncoding(utf8);
}

/*
 *----------------------------------------------------------------------
 *
 * TkGetTransientMaster --
 *

    return 0;
}

static int
ProcessTextInput(XEvent *event, int no_rel, int sdl_mod,
		 const char *text, int len)
{
    int i, n, n2, ulen = Tcl_NumUtfChars(text, len);
    int ret = 0, i, n, ulen;
    char buf[TCL_UTF_MAX];
#if TCL_UTF_MAX < 4
    Tcl_DString ubuf;
    Tcl_Encoding encoding = Tcl_GetEncoding(NULL, "utf-8");

    /*
     * This should make UTF-8 into WTF-8.
     */
    Tcl_DStringInit(&ubuf);
    Tcl_ExternalToUtfDString(encoding, text, len, &ubuf);
    if (encoding) {
	Tcl_FreeEncoding(encoding);
    }
    text = Tcl_DStringValue(&ubuf);
#endif
    ulen = Tcl_NumUtfChars(text, len);
    if (ulen <= 0) {
	SdlTkX.keyuc = 0;
	return 0;
	goto done;
    }
    if (sdl_mod & KMOD_RALT) {
	event->xkey.state &= ~Mod4Mask;
    }
    for (i = 0; i < ulen; i++) {
	Tcl_UniChar ch;

	n = Tcl_UtfToUniChar(text, &ch);
	n2 = 0;

	/* Deal with surrogate pairs */
#if TCL_UTF_MAX > 4
	if ((ch >= 0xd800) && (ch <= 0xdbff)) {
	    Tcl_UniChar ch2;

	    if (i + 1 < ulen) {
		n2 = Tcl_UtfToUniChar(text + n, &ch2);
		if ((ch2 >= 0xdc00) && (ch2 <= 0xdfff)) {
		    ch = ((ch & 0x3ff) << 10) | (ch2 & 0x3ff);
		    ch += 0x10000;
		    ++i;
		} else {
		    ch = 0xfffd;
		    n2 = 0;
		}
	    } else {
		SdlTkX.keyuc = ch;
		return -1;
	    }
	} else if ((ch >= 0xdc00) && (ch <= 0xdfff)) {
	    if (SdlTkX.keyuc) {
		ch = ((SdlTkX.keyuc & 0x3ff) << 10) | (ch & 0x3ff);
		ch += 0x10000;
	    } else {
		ch = 0xfffd;
	    }
	    SdlTkX.keyuc = 0;
	} else if ((ch == 0xfffe) || (ch == 0xffff)) {
	    ch = 0xfffd;
	    SdlTkX.keyuc = 0;
	} else {
	    SdlTkX.keyuc = 0;
	}
#else
	if ((ch >= 0xd800) && (ch <= 0xdbff)) {
	    Tcl_UniChar ch2;

	    if (i + 1 < ulen) {
		n2 = Tcl_UtfToUniChar(text + n, &ch2);
		if ((ch2 >= 0xdc00) && (ch2 <= 0xdfff)) {
		    ++i;
		} else {
		    n2 = 0;
		}
	    }
	    ch = 0xfffd;
	} else if ((ch >= 0xdc00) && (ch <= 0xdfff)) {
	    ch = 0xfffd;
	} else if ((ch == 0xfffe) || (ch == 0xffff)) {
	    ch = 0xfffd;
	}
	SdlTkX.keyuc = 0;
#endif
	event->xkey.nbytes = Tcl_UniCharToUtf(ch, buf);
	event->xkey.time = SdlTkX.time_count;
	if (event->xkey.nbytes > sizeof (event->xkey.trans_chars)) {
	    event->xkey.nbytes = sizeof (event->xkey.trans_chars);
	}
	memcpy(event->xkey.trans_chars, buf, event->xkey.nbytes);
	if (len == 1) {
	    event->xkey.keycode = FixKeyCode(event->xkey.trans_chars[0]);
	} else {
	    event->xkey.keycode = -1;
	}
	text += n + n2;
	text += n;

	/* Queue the KeyPress */
	EVLOG("   KEYPRESS:  CODE=0x%02X  UC=0x%X", event->xkey.keycode, ch);
	event->type = KeyPress;
	if (!no_rel || (i < ulen - 1)) {
	    SdlTkQueueEvent(event);
	    /* Queue the KeyRelease except for the last */
	    event->type = KeyRelease;
	    if (i < ulen - 1) {
		EVLOG(" KEYRELEASE:  CODE=0x%02X", event->xkey.keycode);
		SdlTkQueueEvent(event);
	    }
	}
    }
done:
#if TCL_UTF_MAX < 4
    Tcl_DStringFree(&ubuf);
#endif
    return 1;
    return ret;
}

/*
 *----------------------------------------------------------------------
 *
 * SdlTkTranslateEvent --
 *

    int nearby_pixels;
    TkWindow *capture_window;
    _Window *mouse_window;
    _Window *keyboard_window;
    int mouse_x, mouse_y;
    int raw_mouse_x, raw_mouse_y;
    int sdlfocus;
    int keyuc;
    int cursor_change;
#if !defined(ANDROID) || defined(__TERMUX__)
    Tcl_HashTable sdlcursors;
#endif

    /* Screen refresh, life-cycle, etc. */
    Region screen_dirty_region;

    wSrcStart = (unsigned int *) src;
    wSrcEnd = (unsigned int *) (src + srcLen);

    dstStart = dst;
    dstEnd = dst + dstLen - TCL_UTF_MAX;

    for (numChars = 0; wSrc < wSrcEnd; numChars++) {
	int uch;
        Tcl_UniChar ch;

	if (dst > dstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
	}
	ch = *wSrc++;
	uch = *wSrc++;
	ch = uch;
#if TCL_UTF_MAX < 4
	if (uch > 0xFFFF && uch < 0x10FFFF) {
	    uch -= 0x10000;
	    ch = (uch & 0x3FF) | 0xDC00;
	    dst += Tcl_UniCharToUtf((Tcl_UniChar)((uch >> 10) | 0xD800), dst);
	    if (dst >= dstEnd) {
		result = TCL_CONVERT_NOSPACE;
		break;
	    }
	    numChars++;
	}
#endif
	dst += Tcl_UniCharToUtf(ch, dst);
    }

    *srcReadPtr = (char *) wSrc - (char *) wSrcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;
    return result;

    wDst = (unsigned int *) dst;
    wDstStart = (unsigned int *) dst;
    wDstEnd = (unsigned int *) (dst + dstLen - sizeof (unsigned int));

    result = TCL_OK;
    for (numChars = 0; src < srcEnd; numChars++) {
	int ch, len;
	Tcl_UniChar ucs2;
	Tcl_UniChar ucs, ucs2;

	if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
	    /*
	     * If there is more string to follow, this will ensure that the
	     * last UTF-8 character in the source buffer hasn't been cut off.
	     */

	    result = TCL_CONVERT_MULTIBYTE;
	    break;
	}
	if (wDst > wDstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
        }
	src += Tcl_UtfToUniChar(src, &ucs2);
	src += Tcl_UtfToUniChar(src, &ucs);
	ch = ucs;
	if ((ucs & 0xFFFFFC00) == 0xD800) {
	    if (Tcl_UtfCharComplete(src, srcEnd - src)) {
		len = Tcl_UtfToUniChar(src, &ucs2);
		if ((ucs2 & 0xFFFFFC00) == 0xDC00) {
		    src += len;
		    ch = (((ucs&0x3FF)<<10) | (ucs2&0x3FF)) + 0x10000;
		}
	    }
	}
#ifdef USE_SYMBOLA_CTRL
	if (((int) ucs2 >= 0x00) && ((int) ucs2 < 0x20)) {
	    ucs2 += 0x2400;
	} else if (ucs2 == 0x7F) {
	    ucs2 = 0x2421;
	if ((ch >= 0x00) && (ch < 0x20)) {
	    ch += 0x2400;
	} else if (ch == 0x7F) {
	    ch = 0x2421;
	}
#endif
	*wDst++ = ucs2;
	*wDst++ = ch;
    }
    *srcReadPtr = src - srcStart;
    *dstWrotePtr = (char *) wDst - (char *) wDstStart;
    *dstCharsPtr = numChars;
    return result;
}

 * character existence metrics, used to determine if a screen font can display
 * a given Unicode character.
 *
 * Under Unix, there are three attributes that uniquely identify a "font
 * family": the foundry, face name, and charset.
 */

#if TCL_UTF_MAX > 3
#define FONTMAP_SHIFT		12
#define FONTMAP_PAGES		(1 << (21 - FONTMAP_SHIFT))
#else
#define FONTMAP_SHIFT		10
#define FONTMAP_PAGES		(1 << (sizeof(Tcl_UniChar)*8 - FONTMAP_SHIFT))
#endif
#define FONTMAP_BITSPERPAGE	(1 << FONTMAP_SHIFT)

typedef struct FontFamily {
    struct FontFamily *nextPtr;	/* Next in list of all known font families. */
    int refCount;		/* How many SubFonts are referring to this
				 * FontFamily. When the refCount drops to
				 * zero, this FontFamily may be freed. */

} SubFont;

/*
 * The following structure represents Unix's implementation of a font object.
 */

#define SUBFONT_SPACE		3
#if TCL_UTF_MAX > 3
#define BASE_CHARS		4096
#else
#define BASE_CHARS		2048
#endif

typedef struct UnixFont {
    TkFont font;		/* Stuff used by generic font package. Must be
				 * first in structure. */
    SubFont staticSubFonts[SUBFONT_SPACE];
				/* Builtin space for a limited number of
				 * SubFonts. */

    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
    const char *srcStart, *srcEnd;
    char *dstStart, *dstEnd;
    unsigned int *wDst;
    Tcl_UniChar ch = 0;
    int result;
    int ch, result;
    static char const hexChars[] = "0123456789abcdef";
    static char const mapChars[] = {
	0, 0, 0, 0, 0, 0, 0,
	'a', 'b', 't', 'n', 'v', 'f', 'r'
    };

    result = TCL_OK;

    srcStart = src;
    srcEnd = src + srcLen;

    dstStart = dst;
#if TCL_UTF_MAX > 3
    dstEnd = dst + dstLen - 10 * sizeof(unsigned int);
#else
    dstEnd = dst + dstLen - 6 * sizeof(unsigned int);
#endif
    wDst = (unsigned int *) dst;

    for ( ; src < srcEnd; ) {
	if ((char *) wDst > dstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
	}
	src += Tcl_UtfToUniChar(src, &ch);
	src += TkUtfToUniChar(src, &ch);
	wDst[0] = '\\';
	if ((ch < sizeof(mapChars)) && (mapChars[ch] != 0)) {
	    wDst[1] = mapChars[ch];
	    wDst += 2;
	} else if (ch < 256) {
	    wDst[1] = 'x';
	    wDst[2] = hexChars[(ch >> 4) & 0xf];
	    wDst[3] = hexChars[ch & 0xf];
	    wDst += 4;
#if TCL_UTF_MAX > 3
	} else if (ch < 0x10000)  {
	    wDst[1] = 'u';
	    wDst[2] = hexChars[(ch >> 12) & 0xf];
	    wDst[3] = hexChars[(ch >> 8) & 0xf];
	    wDst[4] = hexChars[(ch >> 4) & 0xf];
	    wDst[5] = hexChars[ch & 0xf];
	    wDst += 6;

	    wDst[4] = hexChars[(ch >> 20) & 0xf];
	    wDst[5] = hexChars[(ch >> 16) & 0xf];
	    wDst[6] = hexChars[(ch >> 12) & 0xf];
	    wDst[7] = hexChars[(ch >> 8) & 0xf];
	    wDst[8] = hexChars[(ch >> 4) & 0xf];
	    wDst[9] = hexChars[ch & 0xf];
	    wDst += 10;
#else
	} else {
	    wDst[1] = 'u';
	    wDst[2] = hexChars[(ch >> 12) & 0xf];
	    wDst[3] = hexChars[(ch >> 8) & 0xf];
	    wDst[4] = hexChars[(ch >> 4) & 0xf];
	    wDst[5] = hexChars[ch & 0xf];
	    wDst += 6;
#endif
	}
    }
    *srcReadPtr = src - srcStart;
    *dstWrotePtr = (char *) wDst - dstStart;
    *dstCharsPtr = *dstWrotePtr / sizeof(unsigned int);
    return result;
}

    lastSubFontPtr = &fontPtr->subFontArray[0];

    if (numBytes == 0) {
	curX = 0;
	curByte = 0;
    } else if (maxLength < 0) {
	const char *p, *end, *next;
	Tcl_UniChar ch = 0;
	int ch;
	SubFont *thisSubFontPtr;
	FontFamily *familyPtr;
	Tcl_DString runString;

	/*
	 * A three step process:
	 * 1. Find a contiguous range of characters that can all be
	 *    represented by a single screen font.
	 * 2. Convert those chars to the encoding of that font.
	 * 3. Measure converted chars.
	 */

	curX = 0;
	end = source + numBytes;
	for (p = source; p < end; ) {
	    next = p + Tcl_UtfToUniChar(p, &ch);
	    next = p + TkUtfToUniChar(p, &ch);
	    thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
	    if (thisSubFontPtr != lastSubFontPtr) {
		familyPtr = lastSubFontPtr->familyPtr;
		Tcl_UtfToExternalDString(familyPtr->encoding, source,
			p - source, &runString);
		if (lastSubFontPtr == &fontPtr->controlSubFont) {
		    fontSize =

	if (lastSubFontPtr == &fontPtr->controlSubFont) {
	    SdlTkFontRestore(lastSubFontPtr->fontStructPtr, fontSize);
	}
	Tcl_DStringFree(&runString);
	curByte = numBytes;
    } else {
	const char *p, *end, *next, *term;
	int newX, termX, sawNonSpace, dstWrote;
	int newX, termX, sawNonSpace, dstWrote, ch;
	Tcl_UniChar ch = 0;
	FontFamily *familyPtr;
	char buf[64];

	/*
	 * How many chars will fit in the space allotted? This first version
	 * may be inefficient because it measures every character
	 * individually.
	 */

	next = source + Tcl_UtfToUniChar(source, &ch);
	next = source + TkUtfToUniChar(source, &ch);
	newX = curX = termX = 0;

	term = source;
	end = source + numBytes;

	sawNonSpace = (ch > 255) || !isspace(ch);
	familyPtr = lastSubFontPtr->familyPtr;

	    p = next;
	    if (p >= end) {
		term = end;
		termX = curX;
		break;
	    }

	    next += Tcl_UtfToUniChar(next, &ch);
	    next += TkUtfToUniChar(next, &ch);
	    if ((ch < 256) && isspace(ch)) {
		if (sawNonSpace) {
		    term = p;
		    termX = curX;
		    sawNonSpace = 0;
		}
	    } else {

	    /*
	     * Include the first character that didn't quite fit in the
	     * desired span. The width returned will include the width of that
	     * extra character.
	     */

	    curX = newX;
	    p += Tcl_UtfToUniChar(p, &ch);
	    p += TkUtfToUniChar(p, &ch);
	}
	if ((flags & TK_AT_LEAST_ONE) && (term == source) && (p < end)) {
	    term = p;
	    termX = curX;
	    if (term == source) {
		term += Tcl_UtfToUniChar(term, &ch);
		term += TkUtfToUniChar(term, &ch);
		termX = newX;
	    }
	} else if ((p >= end) || !(flags & TK_WHOLE_WORDS)) {
	    term = p;
	    termX = curX;
	}

    int x, int y)		/* Coordinates at which to place origin of
				 * string when drawing. */
{
    UnixFont *fontPtr = (UnixFont *) tkfont;
    SubFont *thisSubFontPtr, *lastSubFontPtr;
    Tcl_DString runString;
    const char *p, *end, *next;
    int xStart, window_width;
    int xStart, window_width, ch;
    Tcl_UniChar ch = 0;
    FontFamily *familyPtr;
    int rx, ry, fontSize = 0;
    unsigned width, height, border_width, depth;
    Drawable root;

    lastSubFontPtr = &fontPtr->subFontArray[0];
    xStart = x;

    } else {
	window_width = width;
    }

    end = source + numBytes;
    for (p = source; p <= end; ) {
	if (p < end) {
	    next = p + Tcl_UtfToUniChar(p, &ch);
	    next = p + TkUtfToUniChar(p, &ch);
	    thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
	} else {
	    next = p + 1;
	    thisSubFontPtr = lastSubFontPtr;
	}
	if ((thisSubFontPtr != lastSubFontPtr)
		|| (p == end) || (p-source > 200)) {

    }

    end = (row + 1) << FONTMAP_SHIFT;
    for (i = row << FONTMAP_SHIFT; i < end; i++) {
	if ((i >= 0xD800) && (i <= 0xDFFF)) {
	    continue;
	}
	if (Tcl_UtfToExternal(NULL, encoding, src, Tcl_UniCharToUtf(i, src),
	if (Tcl_UtfToExternal(NULL, encoding, src, TkUniCharToUtf(i, src),
		TCL_ENCODING_STOPONERROR, NULL, buf, sizeof(buf), NULL,
		NULL, NULL) != TCL_OK) {
	    continue;
	}
	if (SdlTkFontHasChar(subFontPtr->fontStructPtr, buf)) {
	    bitOffset = i & (FONTMAP_BITSPERPAGE - 1);
	    subFontPtr->fontMap[row][bitOffset >> 3] |= 1 << (bitOffset & 7);

    if (angle == 0.0) {
	Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y);
    } else {
	UnixFont *fontPtr = (UnixFont *) tkfont;
	SubFont *thisSubFontPtr, *lastSubFontPtr;
	Tcl_DString runString;
	const char *p, *end, *next;
	int xStart, yStart, fontSize = 0;
	int xStart, yStart, fontSize = 0, ch;
	Tcl_UniChar ch = 0;
	FontFamily *familyPtr;
        double sinA = sin(angle*PI/180), cosA = cos(angle*PI/180), dy;
        XPoint points[5];

	lastSubFontPtr = &fontPtr->subFontArray[0];
	xStart = x;
	yStart = y;

	end = source + numBytes;
	for (p = source; p <= end; ) {
	    if (p < end) {
		next = p + Tcl_UtfToUniChar(p, &ch);
		next = p + TkUtfToUniChar(p, &ch);
		thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
	    } else {
		next = p + 1;
		thisSubFontPtr = lastSubFontPtr;
	    }
	    if ((thisSubFontPtr != lastSubFontPtr)
		    || (p == end) || (p-source > 200)) {

{
    if ((mePtr->underline >= 0) && (mePtr->labelPtr != NULL)) {
	int len;

	len = Tcl_GetCharLength(mePtr->labelPtr);
	if (mePtr->underline < len) {
	    int activeBorderWidth, leftEdge;
	    Tcl_UniChar ch = 0;
	    const char *label, *start, *end;

	    label = Tcl_GetString(mePtr->labelPtr);
	    start = Tcl_UtfAtIndex(label, mePtr->underline);
	    end = start + Tcl_UtfToUniChar(start, &ch);
	    end = TkUtfNext(start);

	    Tk_GetPixelsFromObj(NULL, menuPtr->tkwin,
		    menuPtr->activeBorderWidthPtr, &activeBorderWidth);
	    leftEdge = x + mePtr->indicatorSpace + activeBorderWidth;
	    if (menuPtr->menuType == MENUBAR) {
		leftEdge += 5;
	    }

 * character existence metrics, used to determine if a screen font can display
 * a given Unicode character.
 *
 * Under Unix, there are three attributes that uniquely identify a "font
 * family": the foundry, face name, and charset.
 */

#if TCL_UTF_MAX > 3
#define FONTMAP_SHIFT		12
#define FONTMAP_PAGES		(1 << (21 - FONTMAP_SHIFT))
#else
#define FONTMAP_SHIFT		10
#define FONTMAP_PAGES		(1 << (sizeof(Tcl_UniChar)*8 - FONTMAP_SHIFT))
#endif
#define FONTMAP_BITSPERPAGE	(1 << FONTMAP_SHIFT)

typedef struct FontFamily {
    struct FontFamily *nextPtr;	/* Next in list of all known font families. */
    int refCount;		/* How many SubFonts are referring to this
				 * FontFamily. When the refCount drops to
				 * zero, this FontFamily may be freed. */

				 * the conversion. */
    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
    const char *srcStart, *srcEnd;
    char *dstStart, *dstEnd;
    Tcl_UniChar ch = 0;
    int result;
    int ch, result;
    static const char hexChars[] = "0123456789abcdef";
    static const char mapChars[] = {
	0, 0, 0, 0, 0, 0, 0,
	'a', 'b', 't', 'n', 'v', 'f', 'r'
    };

    result = TCL_OK;

    srcStart = src;
    srcEnd = src + srcLen;

    dstStart = dst;
    dstEnd = dst + dstLen - 6;

    for ( ; src < srcEnd; ) {
	if (dst > dstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
	}
	src += Tcl_UtfToUniChar(src, &ch);
	src += TkUtfToUniChar(src, &ch);
	dst[0] = '\\';
	if ((ch < sizeof(mapChars)) && (mapChars[ch] != 0)) {
	    dst[1] = mapChars[ch];
	    dst += 2;
	} else if (ch < 256) {
	    dst[1] = 'x';
	    dst[2] = hexChars[(ch >> 4) & 0xF];

				 * the conversion. */
    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
    const char *srcStart, *srcEnd, *srcClose, *dstStart, *dstEnd;
    int result, numChars;
    Tcl_UniChar ch = 0;
    Tcl_UniChar ch;

    srcStart = src;
    srcEnd = src + srcLen;
    srcClose = srcEnd;
    if (!(flags & TCL_ENCODING_END)) {
	srcClose -= TCL_UTF_MAX;
    }

				 * means return at least one character even if
				 * no characters fit. */
    int *lengthPtr)		/* Filled with x-location just after the
				 * terminating character. */
{
    UnixFont *fontPtr;
    SubFont *lastSubFontPtr;
    int curX, curByte;
    int curX, curByte, ch;

    /*
     * Unix does not use kerning or fractional character widths when
     * displaying text on the screen. So that means we can safely measure
     * individual characters or spans of characters and add up the widths w/o
     * any "off-by-one-pixel" errors.
     */

    fontPtr = (UnixFont *) tkfont;

    lastSubFontPtr = &fontPtr->subFontArray[0];

    if (numBytes == 0) {
	curX = 0;
	curByte = 0;
    } else if (maxLength < 0) {
	const char *p, *end, *next;
	Tcl_UniChar ch = 0;
	SubFont *thisSubFontPtr;
	FontFamily *familyPtr;
	Tcl_DString runString;

	/*
	 * A three step process:
	 * 1. Find a contiguous range of characters that can all be
	 *    represented by a single screen font.
	 * 2. Convert those chars to the encoding of that font.
	 * 3. Measure converted chars.
	 */

	curX = 0;
	end = source + numBytes;
	for (p = source; p < end; ) {
	    next = p + Tcl_UtfToUniChar(p, &ch);
	    next = p + TkUtfToUniChar(p, &ch);
	    thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
	    if (thisSubFontPtr != lastSubFontPtr) {
		familyPtr = lastSubFontPtr->familyPtr;
		Tcl_UtfToExternalDString(familyPtr->encoding, source,
			p - source, &runString);
		if (familyPtr->isTwoByteFont) {
		    curX += XTextWidth16(lastSubFontPtr->fontStructPtr,

		    Tcl_DStringLength(&runString));
	}
	Tcl_DStringFree(&runString);
	curByte = numBytes;
    } else {
	const char *p, *end, *next, *term;
	int newX, termX, sawNonSpace, dstWrote;
	Tcl_UniChar ch = 0;
	FontFamily *familyPtr;
	XChar2b buf[8];

	/*
	 * How many chars will fit in the space allotted? This first version
	 * may be inefficient because it measures every character
	 * individually.
	 */

	next = source + Tcl_UtfToUniChar(source, &ch);
	next = source + TkUtfToUniChar(source, &ch);
	newX = curX = termX = 0;

	term = source;
	end = source + numBytes;

	sawNonSpace = (ch > 255) || !isspace(ch);
	familyPtr = lastSubFontPtr->familyPtr;

	    p = next;
	    if (p >= end) {
		term = end;
		termX = curX;
		break;
	    }

	    next += Tcl_UtfToUniChar(next, &ch);
	    next += TkUtfToUniChar(next, &ch);
	    if ((ch < 256) && isspace(ch)) {
		if (sawNonSpace) {
		    term = p;
		    termX = curX;
		    sawNonSpace = 0;
		}
	    } else {

	    /*
	     * Include the first character that didn't quite fit in the
	     * desired span. The width returned will include the width of that
	     * extra character.
	     */

	    curX = newX;
	    p += Tcl_UtfToUniChar(p, &ch);
	    p += TkUtfToUniChar(p, &ch);
	}
	if ((flags & TK_AT_LEAST_ONE) && (term == source) && (p < end)) {
	    term = p;
	    termX = curX;
	    if (term == source) {
		term += Tcl_UtfToUniChar(term, &ch);
		term += TkUtfToUniChar(term, &ch);
		termX = newX;
	    }
	} else if ((p >= end) || !(flags & TK_WHOLE_WORDS)) {
	    term = p;
	    termX = curX;
	}

    int x, int y)		/* Coordinates at which to place origin of
				 * string when drawing. */
{
    UnixFont *fontPtr = (UnixFont *) tkfont;
    SubFont *thisSubFontPtr, *lastSubFontPtr;
    Tcl_DString runString;
    const char *p, *end, *next;
    int xStart, needWidth, window_width, do_width;
    int xStart, needWidth, window_width, do_width, ch;
    Tcl_UniChar ch = 0;
    FontFamily *familyPtr;
#ifdef TK_DRAW_CHAR_XWINDOW_CHECK
    int rx, ry;
    unsigned width, height, border_width, depth;
    Drawable root;
#endif

    window_width = 32768;
#endif

    end = source + numBytes;
    needWidth = fontPtr->font.fa.underline + fontPtr->font.fa.overstrike;
    for (p = source; p <= end; ) {
	if (p < end) {
	    next = p + Tcl_UtfToUniChar(p, &ch);
	    next = p + TkUtfToUniChar(p, &ch);
	    thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
	} else {
	    next = p + 1;
	    thisSubFontPtr = lastSubFontPtr;
	}
	if ((thisSubFontPtr != lastSubFontPtr)
		|| (p == end) || (p-source > 200)) {

static void
FontMapLoadPage(
    SubFont *subFontPtr,	/* Contains font mapping cache to be
				 * updated. */
    int row)			/* Index of the page to be loaded into the
				 * cache. */
{
    char buf[16], src[TCL_UTF_MAX];
    char buf[16], src[TCL_UTF_MAX*2];
    int minHi, maxHi, minLo, maxLo, scale, checkLo;
    int i, end, bitOffset, isTwoByteFont, n;
    Tcl_Encoding encoding;
    XFontStruct *fontStructPtr;
    XCharStruct *widths;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));

	}
    }

    end = (row + 1) << FONTMAP_SHIFT;
    for (i = row << FONTMAP_SHIFT; i < end; i++) {
	int hi, lo;

	if (Tcl_UtfToExternal(NULL, encoding, src, Tcl_UniCharToUtf(i, src),
	if (Tcl_UtfToExternal(NULL, encoding, src, TkUniCharToUtf(i, src),
		TCL_ENCODING_STOPONERROR, NULL, buf, sizeof(buf), NULL,
		NULL, NULL) != TCL_OK) {
	    continue;
	}
	if (isTwoByteFont) {
	    hi = ((unsigned char *) buf)[0];
	    lo = ((unsigned char *) buf)[1];

{
    int i, nameIdx, numNames, srcLen, numEncodings, bestIdx[2];
    Tk_Uid hateFoundry;
    const char *charset, *hateCharset;
    unsigned bestScore[2];
    char **nameList;
    char **nameListOrig;
    char src[TCL_UTF_MAX];
    char src[8];
    FontAttributes want, got;
    Display *display;
    SubFont subFont;
    XFontStruct *fontStructPtr;
    Tcl_DString dsEncodings;
    Tcl_Encoding *encodingCachePtr;

    display = fontPtr->display;
    nameList = ListFonts(display, faceName, &numNames);
    if (numNames == 0) {
	return NULL;
    }
    nameListOrig = nameList;

    srcLen = Tcl_UniCharToUtf(ch, src);
    srcLen = TkUniCharToUtf(ch, src);

    want.fa = fontPtr->font.fa;
    want.xa = fontPtr->xa;

    want.fa.family = Tk_GetUid(faceName);
    want.fa.size = (double)-fontPtr->pixelSize;

#ifdef TK_USE_INPUT_METHODS
    if ((winPtr->dispPtr->flags & TK_DISPLAY_USE_IM)
	    && (winPtr->dispPtr->inputContext != NULL)
	    && (eventPtr->type == KeyPress)) {
	Status status;

#if X_HAVE_UTF8_STRING
#if TCL_UTF_MAX < 4
	/*
	 * We want WTF-8 here.
	 */
	Tcl_DStringInit(&buf);
	Tcl_DStringSetLength(&buf, TCL_DSTRING_STATIC_SIZE-1);
	len = Xutf8LookupString(winPtr->dispPtr->inputContext,
		&eventPtr->xkey,
		Tcl_DStringValue(&buf), Tcl_DStringLength(&buf),
		&kePtr->keysym, &status);

	if (status == XBufferOverflow) {
	    /*
	     * Expand buffer and try again.
	     */

	    Tcl_DStringSetLength(&buf, len);
	    len = Xutf8LookupString(winPtr->dispPtr->inputContext,
		    &eventPtr->xkey,
		    Tcl_DStringValue(&buf), Tcl_DStringLength(&buf),
		    &kePtr->keysym, &status);
	}
	Tcl_DStringSetLength(&buf, len);
	if ((status != XLookupChars) && (status != XLookupBoth)) {
	    len = 0;
	} else {
	    Tcl_Encoding encoding = Tcl_GetEncoding(NULL, "utf-8");

	    Tcl_ExternalToUtfDString(encoding, Tcl_DStringValue(&buf),
		len, dsPtr);
	    len = Tcl_DStringLength(dsPtr);
	    if (encoding) {
		Tcl_FreeEncoding(encoding);
	    }
	}
	Tcl_DStringFree(&buf);
#else
	Tcl_DStringSetLength(dsPtr, TCL_DSTRING_STATIC_SIZE-1);
	len = Xutf8LookupString(winPtr->dispPtr->inputContext,
		&eventPtr->xkey,
		Tcl_DStringValue(dsPtr), Tcl_DStringLength(dsPtr),
		&kePtr->keysym, &status);

	if (status == XBufferOverflow) {

		    Tcl_DStringValue(dsPtr), Tcl_DStringLength(dsPtr),
		    &kePtr->keysym, &status);
	}
	if ((status != XLookupChars) && (status != XLookupBoth)) {
	    len = 0;
	}
	Tcl_DStringSetLength(dsPtr, len);
#endif
#else /* !X_HAVE_UTF8_STRING */
	/*
	 * Overallocate the dstring to the maximum stack amount.
	 */

	Tcl_DStringInit(&buf);
	Tcl_DStringSetLength(&buf, TCL_DSTRING_STATIC_SIZE-1);

{
    if ((mePtr->underline >= 0) && (mePtr->labelPtr != NULL)) {
	int len;

	len = Tcl_GetCharLength(mePtr->labelPtr);
	if (mePtr->underline < len) {
	    int activeBorderWidth, leftEdge;
	    Tcl_UniChar ch = 0;
	    const char *label, *start, *end;

	    label = Tcl_GetString(mePtr->labelPtr);
	    start = Tcl_UtfAtIndex(label, mePtr->underline);
	    end = start + Tcl_UtfToUniChar(start, &ch);
	    end = TkUtfNext(start);

	    Tk_GetPixelsFromObj(NULL, menuPtr->tkwin,
		    menuPtr->activeBorderWidthPtr, &activeBorderWidth);
	    leftEdge = x + mePtr->indicatorSpace + activeBorderWidth;
	    if (menuPtr->menuType == MENUBAR) {
		leftEdge += 5;
	    }

    Tcl_RegisterConfig(mainPtr->interp, "tk", cfg, "utf-8");
#endif
}

static XftFont *
GetFont(
    UnixFtFont *fontPtr,
    FcChar32 ucs4,
    int ucs4,
    double angle)
{
    int i;

    if (ucs4) {
	for (i = 0; i < fontPtr->nfaces; i++) {
	    FcCharSet *charset = fontPtr->faces[i].charset;

	    if (charset && FcCharSetHasChar(charset, ucs4)) {
	    if (charset && FcCharSetHasChar(charset, (FcChar32)ucs4)) {
		break;
	    }
	}
	if (i == fontPtr->nfaces) {
	    i = 0;
	}
    } else {

    Tk_Window tkwin,		/* Window on the font's display */
    Tk_Font tkfont,		/* Font to query */
    int c,			/* Character of interest */
    TkFontAttributes *faPtr)	/* Output: Font attributes */
{
    UnixFtFont *fontPtr = (UnixFtFont *) tkfont;
				/* Structure describing the logical font */
    FcChar32 ucs4 = (FcChar32) c;
				/* UCS-4 character to map */
    XftFont *ftFont = GetFont(fontPtr, ucs4, 0.0);
    XftFont *ftFont = GetFont(fontPtr, c, 0.0);
				/* Actual font used to render the character */

    GetTkFontAttributes(ftFont, faPtr);
    faPtr->underline = fontPtr->font.fa.underline;
    faPtr->overstrike = fontPtr->font.fa.overstrike;
}


    handler = Tk_CreateErrorHandler(fontPtr->display,
	    -1, -1, -1, InitFontErrorProc, &errorFlag);
    curX = 0;
    curByte = 0;
    sawNonSpace = 0;
    while (numBytes > 0) {
	Tcl_UniChar unichar;
	int unichar;

	clen = Tcl_UtfToUniChar(source, &unichar);
	clen = TkUtfToUniChar(source, &unichar);
	c = (FcChar32) unichar;
#if TCL_UTF_MAX == 4
	if (!clen && (*source & 0xf8) == 0xf0) {
	    clen += Tcl_UtfToUniChar(source, &unichar);
	    c = (((c & 0x3ff) << 10) | (unichar & 0x3ff)) + 0x10000;
	}
#endif

	if ((unichar >= 0xD800) && (unichar <= 0xDFFF)) {
	if (clen <= 0) {
	    /*
	     * This can't happen (but see #1185640)
	     */

	    unichar = 0xFFFD;
	    Tk_DeleteErrorHandler(handler);
	    *lengthPtr = curX;
	    return curByte;
	}

	c = (FcChar32) unichar;
	source += clen;
	numBytes -= clen;
	if (c < 256 && isspace(c)) {		/* I18N: ??? */
	    if (sawNonSpace) {
		termByte = curByte;
		termX = curX;
		sawNonSpace = 0;

    xftcolor = LookUpColor(display, fontPtr, values.foreground);
    if (tsdPtr->clipRegion != NULL) {
	XftDrawSetClip(fontPtr->ftDraw, tsdPtr->clipRegion);
    }
    nspec = 0;
    while (numBytes > 0) {
	XftFont *ftFont;
	FcChar32 c;
	int c;

	clen = FcUtf8ToUcs4((FcChar8 *) source, &c, numBytes);
	if (clen <= 0) {
	clen = TkUtfToUniChar(source, &c);
	if ((c >= 0xD800) && (c <= 0xDFFF)) {
	    /*
	     * This should not happen, but it can.
	     */

	    c = 0xFFFD;
	    goto doUnderlineStrikeout;
	}
	source += clen;
	numBytes -= clen;

	ftFont = GetFont(fontPtr, c, 0.0);
	if (ftFont) {
	    specs[nspec].glyph = XftCharIndex(fontPtr->display, ftFont, c);

    }
    if (nspec) {
	LOCK;
	XftDrawGlyphFontSpec(fontPtr->ftDraw, xftcolor, specs, nspec);
	UNLOCK;
    }

  doUnderlineStrikeout:
    if (tsdPtr->clipRegion != NULL) {
	XftDrawSetClip(fontPtr->ftDraw, NULL);
    }
    if (fontPtr->font.fa.underline != 0) {
	XFillRectangle(display, drawable, gc, xStart,
		y + fontPtr->font.underlinePos, (unsigned) (x - xStart),
		(unsigned) fontPtr->font.underlineHeight);

    nglyph = 0;
    currentFtFont = NULL;
    originX = originY = 0;

    while (numBytes > 0) {
	XftFont *ftFont;
	FcChar32 c;
	int c;

	clen = FcUtf8ToUcs4((FcChar8 *) source, &c, numBytes);
	if (clen <= 0) {
	clen = TkUtfToUniChar(source, &c);
	if ((c >= 0xD800) && (c <= 0xDFFF)) {
	    /*
	     * This should not happen, but it can.
	     */

	    c = 0xFFFD;
	    goto doUnderlineStrikeout;
	}
	source += clen;
	numBytes -= clen;

	ftFont = GetFont(fontPtr, c, angle);
	if (!ftFont) {
	    continue;

    xftcolor = LookUpColor(display, fontPtr, values.foreground);
    if (tsdPtr->clipRegion != NULL) {
	XftDrawSetClip(fontPtr->ftDraw, tsdPtr->clipRegion);
    }
    nspec = 0;
    while (numBytes > 0) {
	XftFont *ftFont, *ft0Font;
	FcChar32 c;
	int c;

	clen = FcUtf8ToUcs4((FcChar8 *) source, &c, numBytes);
	if (clen <= 0) {
	clen = TkUtfToUniChar(source, &c);
	if ((c >= 0xD800) && (c <= 0xDFFF)) {
	    /*
	     * This should not happen, but it can.
	     */

	    c = 0xFFFD;
	    goto doUnderlineStrikeout;
	}
	source += clen;
	numBytes -= clen;

	ftFont = GetFont(fontPtr, c, angle);
	ft0Font = GetFont(fontPtr, c, 0.0);
	if (ftFont && ft0Font) {

    if (nspec) {
	LOCK;
	XftDrawGlyphFontSpec(fontPtr->ftDraw, xftcolor, specs, nspec);
	UNLOCK;
    }
#endif /* XFT_HAS_FIXED_ROTATED_PLACEMENT */

  doUnderlineStrikeout:
    if (tsdPtr->clipRegion != NULL) {
	XftDrawSetClip(fontPtr->ftDraw, NULL);
    }
    if (fontPtr->font.fa.underline || fontPtr->font.fa.overstrike) {
	XPoint points[5];
	double width = (x - xStart) * cosA + (yStart - y) * sinA;
	double barHeight = fontPtr->font.underlineHeight;

	    /*
	     * The X selection data is in UTF-8 format already. We can't
	     * guarantee that propInfo is NULL-terminated, so we might have to
	     * copy the string.
	     */

	    char *propData = propInfo;
#if TCL_UTF_MAX < 4
	    Tcl_Encoding encoding;
#endif

	    if (format != 8) {
		Tcl_SetObjResult(retrPtr->interp, Tcl_ObjPrintf(
			"bad format for string selection: wanted \"8\", got \"%d\"",
			format));
		Tcl_SetErrorCode(retrPtr->interp, "TK", "SELECTION", "FORMAT",
			NULL);
		retrPtr->result = TCL_ERROR;
		return;
	    }

	    if (propInfo[numItems] != '\0') {
		propData = (char *) ckalloc(numItems + 1);
		strcpy(propData, propInfo);
		propData[numItems] = '\0';
	    }

	    interp = retrPtr->interp;
	    Tcl_Preserve(interp);
#if TCL_UTF_MAX < 4
	    encoding = Tcl_GetEncoding(NULL, "utf-8");
	    Tcl_ExternalToUtfDString(encoding, propInfo, (int)numItems, &ds);
	    if (encoding) {
		Tcl_FreeEncoding(encoding);
	    }
	    retrPtr->result = retrPtr->proc(retrPtr->clientData,
		    retrPtr->interp, Tcl_DStringValue(&ds));
	    Tcl_DStringFree(&ds);
#else
	    retrPtr->result = retrPtr->proc(retrPtr->clientData,
		    retrPtr->interp, propData);
#endif
	    Tcl_Release(interp);
	    if (propData != propInfo) {
		ckfree(propData);
	    }

	} else if (type == dispPtr->incrAtom) {
	    /*
	     * It's a !?#@!?!! INCR-style reception. Arrange to receive the

	    propPtr = (char *) buffer;
	    format = 32;
	    incr.converts[i].offset = 0;
	    XChangeProperty(reply.xsel.display, reply.xsel.requestor,
		    property, type, format, PropModeReplace,
		    (unsigned char *) propPtr, numItems);
	} else if (type == winPtr->dispPtr->utf8Atom) {
#if TCL_UTF_MAX > 3
	    /*
	     * This matches selection requests of type UTF8_STRING, which
	     * allows us to pass our utf-8 information untouched.
	     */

	    XChangeProperty(reply.xsel.display, reply.xsel.requestor,
		    property, type, 8, PropModeReplace,
		    (unsigned char *) buffer, numItems);
#else
	    /*
	     * Must ensure not to export WTF-8 here.
	     */
	    Tcl_DString ds;
	    Tcl_Encoding encoding;

	    encoding = Tcl_GetEncoding(NULL, "utf-8");
	    Tcl_UtfToExternalDString(encoding, (char *) buffer, -1, &ds);
	    XChangeProperty(reply.xsel.display, reply.xsel.requestor,
		    property, type, 8, PropModeReplace,
		    (unsigned char *) Tcl_DStringValue(&ds),
		    Tcl_DStringLength(&ds));
	    if (encoding) {
		Tcl_FreeEncoding(encoding);
	    }
	    Tcl_DStringFree(&ds);
#endif
	} else if ((type == XA_STRING)
		|| (type == winPtr->dispPtr->compoundTextAtom)) {
	    Tcl_DString ds;
	    Tcl_Encoding encoding;

	    /*
	     * STRING is Latin-1, COMPOUND_TEXT is an iso2022 variant. We need

UpdateTitle(
    TkWindow *winPtr)
{
    WmInfo *wmPtr = winPtr->wmInfoPtr;
    Atom XA_UTF8_STRING = Tk_InternAtom((Tk_Window) winPtr, "UTF8_STRING");
    const char *string;
    Tcl_DString ds;
    Tcl_Encoding encoding;

    /*
     * Set window title:
     */

    string = (wmPtr->title != NULL) ? wmPtr->title : winPtr->nameUid;
    Tcl_UtfToExternalDString(NULL, string, -1, &ds);
    XStoreName(winPtr->display, wmPtr->wrapperPtr->window,
	    Tcl_DStringValue(&ds));
    Tcl_DStringFree(&ds);

    encoding = Tcl_GetEncoding(NULL, "utf-8");
    Tcl_UtfToExternalDString(encoding, string, -1, &ds);
    SetWindowProperty(wmPtr->wrapperPtr, "_NET_WM_NAME", XA_UTF8_STRING, 8,
	    Tcl_DStringValue(&ds), Tcl_DStringLength(&ds));
	    string, strlen(string));
    Tcl_DStringFree(&ds);

    /*
     * Set icon name:
     */

    if (wmPtr->iconName != NULL) {
	Tcl_UtfToExternalDString(NULL, wmPtr->iconName, -1, &ds);
	XSetIconName(winPtr->display, wmPtr->wrapperPtr->window,
		Tcl_DStringValue(&ds));
	Tcl_DStringFree(&ds);

	Tcl_UtfToExternalDString(encoding, wmPtr->iconName, -1, &ds);
	SetWindowProperty(wmPtr->wrapperPtr, "_NET_WM_ICON_NAME",
		XA_UTF8_STRING, 8, wmPtr->iconName, strlen(wmPtr->iconName));
		XA_UTF8_STRING, 8,
		Tcl_DStringValue(&ds), Tcl_DStringLength(&ds));
	Tcl_DStringFree(&ds);
    }

    if (encoding) {
	Tcl_FreeEncoding(encoding);
    }
}

/*
 *--------------------------------------------------------------
 *
 * UpdatePhotoIcon --

 * instance of this structure. The most important shared property is the
 * character existence metrics, used to determine if a screen font can display
 * a given Unicode character.
 *
 * Under Windows, a "font family" is uniquely identified by its face name.
 */

#if TCL_UTF_MAX > 3
#define FONTMAP_SHIFT		12
#define FONTMAP_PAGES	    	(1 << (21 - FONTMAP_SHIFT))
#else
#define FONTMAP_SHIFT		10
#define FONTMAP_PAGES		(1 << (sizeof(Tcl_UniChar)*8 - FONTMAP_SHIFT))
#endif
#define FONTMAP_BITSPERPAGE	(1 << FONTMAP_SHIFT)

typedef struct FontFamily {
    struct FontFamily *nextPtr;	/* Next in list of all known font families. */
    size_t refCount;		/* How many SubFonts are referring to this
				 * FontFamily. When the refCount drops to
				 * zero, this FontFamily may be freed. */

    int *lengthPtr)		/* Filled with x-location just after the
				 * terminating character. */
{
    HDC hdc;
    HFONT oldFont;
    WinFont *fontPtr;
    int curX, moretomeasure;
    Tcl_UniChar ch;
    int ch;
    SIZE size;
    FontFamily *familyPtr;
    Tcl_DString runString;
    SubFont *thisSubFontPtr, *lastSubFontPtr;
    const char *p, *end, *next = NULL, *start;

    if (numBytes == 0) {

     */

    moretomeasure = 0;
    curX = 0;
    start = source;
    end = start + numBytes;
    for (p = start; p < end; ) {
	next = p + Tcl_UtfToUniChar(p, &ch);
	next = p + TkUtfToUniChar(p, &ch);
	thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
	if (thisSubFontPtr != lastSubFontPtr) {
	    familyPtr = lastSubFontPtr->familyPtr;
	    Tcl_UtfToExternalDString(familyPtr->encoding, start,
		    p - start, &runString);
	    size.cx = 0;
	    familyPtr->getTextExtentPoint32Proc(hdc,

	char buf[16];
	int dstWrote;
	int lastSize = 0;

	familyPtr = lastSubFontPtr->familyPtr;
	Tcl_DStringInit(&runString);
	for (p = start; p < end; ) {
	    next = p + Tcl_UtfToUniChar(p, &ch);
	    next = p + TkUtfToUniChar(p, &ch);
	    Tcl_UtfToExternal(NULL, familyPtr->encoding, p,
		    (int) (next - p), 0, NULL, buf, sizeof(buf), NULL,
		    &dstWrote, NULL);
	    Tcl_DStringAppend(&runString,buf,dstWrote);
	    size.cx = 0;
	    familyPtr->getTextExtentPoint32Proc(hdc,
		    (WCHAR *) Tcl_DStringValue(&runString),

    if ((flags & TK_WHOLE_WORDS) && (p < end)) {
	/*
	 * Scan the string for the last word break and than repeat the whole
	 * procedure without the maxLength limit or any flags.
	 */

	const char *lastWordBreak = NULL;
	Tcl_UniChar ch2;
	int ch2;

	end = p;
	p = source;
	ch = ' ';
	while (p < end) {
	    next = p + Tcl_UtfToUniChar(p, &ch2);
	    next = p + TkUtfToUniChar(p, &ch2);
	    if ((ch != ' ') && (ch2 == ' ')) {
		lastWordBreak = p;
	    }
	    p = next;
	    ch = ch2;
	}

				 * following string. */
    const char *source,		/* Potentially multilingual UTF-8 string. */
    int numBytes,		/* Length of string in bytes. */
    double x, double y,		/* Coordinates at which to place origin of
				 * string when drawing. */
    double angle)
{
    Tcl_UniChar ch;
    int ch;
    SIZE size;
    HFONT oldFont;
    FontFamily *familyPtr;
    Tcl_DString runString;
    const char *p, *end, *next;
    SubFont *lastSubFontPtr, *thisSubFontPtr;
    TEXTMETRICW tm;
    double sinA = sin(angle * PI/180.0), cosA = cos(angle * PI/180.0);

    lastSubFontPtr = &fontPtr->subFontArray[0];
    oldFont = SelectFont(hdc, fontPtr, lastSubFontPtr, angle);
    GetTextMetricsW(hdc, &tm);

    end = source + numBytes;
    for (p = source; p < end; ) {
	next = p + Tcl_UtfToUniChar(p, &ch);
	next = p + TkUtfToUniChar(p, &ch);
	thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);

	/*
	 * The drawing API has a limit of 32767 pixels in one go.
	 * To avoid spending time on a rare case we do not measure each char,
	 * instead we limit to drawing chunks of 200 bytes since that works
	 * well in practice.

    SubFont *subFontPtr,	/* Contains font mapping cache to be
				 * updated. */
    int row)			/* Index of the page to be loaded into the
				 * cache. */
{
    FontFamily *familyPtr;
    Tcl_Encoding encoding;
    char src[TCL_UTF_MAX], buf[16];
    char src[4], buf[16];
    USHORT *startCount, *endCount;
    int i, j, bitOffset, end, segCount;

    subFontPtr->fontMap[row] = (char *) ckalloc(FONTMAP_BITSPERPAGE / 8);
    memset(subFontPtr->fontMap[row], 0, FONTMAP_BITSPERPAGE / 8);

    familyPtr = subFontPtr->familyPtr;

	 * we don't know the proper Unicode -> symbol font mapping, we can
	 * install the symbol font as the base font and access its glyphs.
	 */

	end = (row + 1) << FONTMAP_SHIFT;
	for (i = row << FONTMAP_SHIFT; i < end; i++) {
	    if (Tcl_UtfToExternal(NULL, encoding, src,
		    Tcl_UniCharToUtf(i, src), TCL_ENCODING_STOPONERROR, NULL,
		    TkUniCharToUtf(i, src), TCL_ENCODING_STOPONERROR, NULL,
		    buf, sizeof(buf), NULL, NULL, NULL) != TCL_OK) {
		continue;
	    }
	    bitOffset = i & (FONTMAP_BITSPERPAGE - 1);
	    subFontPtr->fontMap[row][bitOffset >> 3] |= 1 << (bitOffset & 7);
	}
    }

	int i;
	const char *label = (mePtr->labelPtr == NULL) ? ""
		: Tcl_GetString(mePtr->labelPtr);
	const char *accel = ((menuPtr->menuType == MENUBAR) || (mePtr->accelPtr == NULL)) ? ""
		: Tcl_GetString(mePtr->accelPtr);
	const char *p, *next;
	Tcl_DString itemString;
	Tcl_UniChar ch = 0;

	/*
	 * We have to construct the string with an ampersand preceeding the
	 * underline character, and a tab seperating the text and the accel
	 * text. We have to be careful with ampersands in the string.
	 */

	Tcl_DStringInit(&itemString);

	for (p = label, i = 0; *p != '\0'; i++, p = next) {
	    if (i == mePtr->underline) {
		Tcl_DStringAppend(&itemString, "&", 1);
	    }
	    if (*p == '&') {
		Tcl_DStringAppend(&itemString, "&", 1);
	    }
	    next = p + Tcl_UtfToUniChar(p, &ch);
	    next = TkUtfNext(p);
	    Tcl_DStringAppend(&itemString, p, (int) (next - p));
	}
	ch = 0;
	if (mePtr->accelLength > 0) {
	    Tcl_DStringAppend(&itemString, "\t", 1);
	    for (p = accel, i = 0; *p != '\0'; i++, p = next) {
		if (*p == '&') {
		    Tcl_DStringAppend(&itemString, "&", 1);
		}
		next = p + Tcl_UtfToUniChar(p, &ch);
		next = TkUtfNext(p);
		Tcl_DStringAppend(&itemString, p, (int) (next - p));
	    }
	}

	itemText = (char *)ckalloc(Tcl_DStringLength(&itemString) + 1);
	strcpy(itemText, Tcl_DStringValue(&itemString));
	Tcl_DStringFree(&itemString);

{
    if ((mePtr->underline >= 0) && (mePtr->labelPtr != NULL)) {
	int len;

	len = Tcl_GetCharLength(mePtr->labelPtr);
	if (mePtr->underline < len) {
	    const char *label, *start, *end;
	    Tcl_UniChar ch = 0;

	    label = Tcl_GetString(mePtr->labelPtr);
	    start = Tcl_UtfAtIndex(label, mePtr->underline);
	    end = start + Tcl_UtfToUniChar(start, &ch);
	    end = TkUtfNext(start);
	    Tk_UnderlineChars(menuPtr->display, d,
		    gc, tkfont, label, x + mePtr->indicatorSpace,
		    y + (height + fmPtr->ascent - fmPtr->descent) / 2,
		    (int) (start - label), (int) (end - label));
	}
    }
}

	msg = msgBuf;
    } else {
	Tcl_Encoding encoding;
	char *msgPtr;

	encoding = Tcl_GetEncoding(NULL, "unicode");
	Tcl_ExternalToUtfDString(encoding, (char *) wMsgPtr, -1, &ds);
	if (encoding) {
	Tcl_FreeEncoding(encoding);
	    Tcl_FreeEncoding(encoding);
	}
	LocalFree(wMsgPtr);

	msgPtr = Tcl_DStringValue(&ds);
	length = Tcl_DStringLength(&ds);

	/*
	 * Trim the trailing CR/LF from the system message.

typedef Tcl_UniChar chr;	/* The type itself. */
typedef int pchr;		/* What it promotes to. */
typedef unsigned uchr;		/* Unsigned type that will hold a chr. */
typedef int celt;		/* Type to hold chr, or NOCELT */
#define	NOCELT (-1)		/* Celt value which is not valid chr */
#define	CHR(c) (UCHAR(c))	/* Turn char literal into chr literal */
#define	DIGITVAL(c) ((c)-'0')	/* Turn chr digit into its value */
#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
#define	CHRBITS	32		/* Bits in a chr; must not use sizeof */
#define	CHR_MIN	0x00000000	/* Smallest and largest chr; the value */
#define	CHR_MAX	0xFFFFFFFF	/* CHR_MAX-CHR_MIN+1 should fit in uchr */
#else
#define	CHRBITS	16		/* Bits in a chr; must not use sizeof */
#define	CHR_MIN	0x0000		/* Smallest and largest chr; the value */
#define	CHR_MAX	0xFFFF		/* CHR_MAX-CHR_MIN+1 should fit in uchr */

 * is the default and recommended mode. UCS-4 is experimental and not
 * recommended. It works for the core, but most extensions expect UCS-2.
 */

#ifndef TCL_UTF_MAX
#define TCL_UTF_MAX		3
#endif
#if (TCL_UTF_MAX != 3) && (TCL_UTF_MAX != 4)
#error TCL_UTF_MAX must be 3 or 4
#endif

/*
 * This represents a Unicode character. Any changes to this should also be
 * reflected in regcustom.h.
 */

#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
    /*
     * unsigned int isn't 100% accurate as it should be a strict 4-byte value
     * (perhaps wchar_t). 64-bit systems may have troubles. The size of this
     * value must be reflected correctly in regcustom.h and
     * in tclEncoding.c.
     * XXX: Tcl is currently UCS-2 and planning UTF-16 for the Unicode
     * XXX: string rep that Tcl_UniChar represents.  Changing the size

	src = TclGetStringFromObj(objPtr, &length);
	srcEnd = src + length;

	byteArrayPtr = (ByteArray *) ckalloc(BYTEARRAY_SIZE(length));
	byteArrayPtr->bytes = (unsigned char *) (byteArrayPtr + 1);
	for (dst = byteArrayPtr->bytes; src < srcEnd; ) {
	    src += TclUtfToUniChar(src, &ch);
#if TCL_UTF_MAX == 3
	    if ((ch & 0xFC00) == 0xD800) {
		if (Tcl_UtfCharComplete(src, srcEnd - src)) {
		    int uch = ch;
		    int len2 = TclUtfToUniChar(src, &ch);

		    if ((ch & 0xFC00) == 0xDC00) {
			src += len2;
			uch = (((uch&0x3ff)<<10) | (ch&0x3ff)) + 0x10000;
		    }
		    ch = UCHAR(uch);
		}
	    }
#endif
	    *dst++ = UCHAR(ch);
	}

	byteArrayPtr->used = dst - byteArrayPtr->bytes;
	byteArrayPtr->allocated = length;

	TclFreeIntRep(objPtr);

 badIndex:
    errorString = "not enough arguments for all format specifiers";
    goto error;

 badField:
    {
	Tcl_UniChar ch = 0;
	char buf[TCL_UTF_MAX + 1] = "";
	char buf[TCL_UTF_MAX + 1];

	TclUtfToUniChar(errorString, &ch);
	buf[Tcl_UniCharToUtf(ch, buf)] = '\0';
	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		"bad field specifier \"%s\"", buf));
	return TCL_ERROR;
    }

 badIndex:
    errorString = "not enough arguments for all format specifiers";
    goto error;

 badField:
    {
	Tcl_UniChar ch = 0;
	char buf[TCL_UTF_MAX + 1] = "";
	char buf[TCL_UTF_MAX + 1];

	TclUtfToUniChar(errorString, &ch);
	buf[Tcl_UniCharToUtf(ch, buf)] = '\0';
	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		"bad field specifier \"%s\"", buf));
	return TCL_ERROR;
    }

	 * Convert character to Unicode for comparison purposes. If either
	 * string is at the terminating null, do a byte-wise comparison and
	 * bail out immediately.
	 */

	if ((*left != '\0') && (*right != '\0')) {
	    Tcl_UniChar lch = 0, rch = 0;
	    int len;

	    len = TclUtfToUniChar(left, &lch);
	    left += TclUtfToUniChar(left, &lch);
	    right += TclUtfToUniChar(right, &rch);

	    uniLeft = lch;
	    uniRight = rch;
#if TCL_UTF_MAX == 4
	    if (!len) {
		len = TclUtfToUniChar(left, &lch);
		uniLeft = (((uniLeft&0x3FF)<<10) | (lch&0x3FF)) + 0x10000;
	    }
#if TCL_UTF_MAX == 3
	    if (*left && ((lch & 0xFC00) == 0xD800)) {
		int len2 = TclUtfToUniChar(left, &lch);

		if ((lch & 0xFC00) == 0xDC00) {
		    uniLeft = (((uniLeft&0x3FF)<<10) | (lch&0x3FF)) + 0x10000;
		    left += len2;
		}
#endif
	    left += len;

	    len = TclUtfToUniChar(right, &rch);
	    uniRight = rch;
	    }
	    if (*right && ((rch & 0xFC00) == 0xD800)) {
		int len2 = TclUtfToUniChar(right, &rch);

#if TCL_UTF_MAX == 4
	    if (!len) {
		if ((rch & 0xFC00) == 0xDC00) {
		len = TclUtfToUniChar(right, &rch);
		uniRight = (((uniRight&0x3FF)<<10) | (rch&0x3FF)) + 0x10000;
	    }
		    uniRight = (((uniRight&0x3FF)<<10) | (rch&0x3FF)) + 0x10000;
		    right += len2;
		}
#endif
	    right += len;

	    }
#endif
	    /*
	     * Convert both chars to lower for the comparison, because
	     * dictionary sorts are case-insensitive. Covert to lower, not
	     * upper, so chars between Z and a will sort before A (where most
	     * other interesting punctuations occur).
	     */

static Tcl_NRPostProc	SwitchPostProc;
static Tcl_NRPostProc	TryPostBody;
static Tcl_NRPostProc	TryPostFinal;
static Tcl_NRPostProc	TryPostHandler;
static int		UniCharIsAscii(int character);
static int		UniCharIsHexDigit(int character);

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
static int		MemCmp(const void *s1, const void *s2, size_t n,
			    int flags);
static int		NumCodePointsUtf(const char *src, int length,
			    int *flagPtr);
static int		NumCodePointsUnicode(const Tcl_UniChar *src,
			    int length, int *flagPtr);
static int		UniCharNcmp(const Tcl_UniChar *ucs,

	"\xE2\x80\xAF" /* narrow no-break space (U+202f) */
	"\xE2\x81\x9F" /* medium mathematical space (U+205f) */
	"\xE2\x81\xA0" /* word joiner (U+2060) */
	"\xE3\x80\x80" /* ideographic space (U+3000) */
	"\xEF\xBB\xBF" /* zero width no-break space (U+feff) */
;

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
/*
 *---------------------------------------------------------------------------
 *
 * MemCmp --
 *
 *	Private wrapper for memcmp(). See C library documentation.
 *
 *---------------------------------------------------------------------------
 */

static int
MemCmp(const void *s1, const void *s2, size_t n, int flags)
{
    return memcmp(s1, s2, n);
}
#endif

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
/*
 *---------------------------------------------------------------------------
 *
 * NumCodePointsUtf --
 *
 *	Like Tcl_NumUtfChars() but returns the number of code points.
 *

static int
NumCodePointsUtf(
    const char *src,		/* The UTF-8 string to measure. */
    int length,			/* The length of the string in bytes. */
    int *flagPtr)		/* Location to receive end flag. */
{
    Tcl_UniChar ch = 0;
    int len, i = 0;
    int i = 0;
    const char *endPtr = src + length - TCL_UTF_MAX;

    *flagPtr = 0;
    while (src < endPtr) {
	len = TclUtfToUniChar(src, &ch);
	if (len) {
	src += TclUtfToUniChar(src, &ch);
	if ((ch & 0xFC00) == 0xD800) {
	    ch = 0;
	} else {
	    len = TclUtfToUniChar(src, &ch);
	}
	src += len;
	    if ((src < endPtr) && Tcl_UtfCharComplete(src, endPtr - src)) {
		int len = TclUtfToUniChar(src, &ch);

		if ((ch & 0xFC00) == 0xDC00) {
		    --i;
		    src += len;
		}
	    }
	}
	i++;
    }
    endPtr += TCL_UTF_MAX;
    while ((src < endPtr) && Tcl_UtfCharComplete(src, endPtr - src)) {
	len = TclUtfToUniChar(src, &ch);
	if (len) {
	    ch = 0;
	src += TclUtfToUniChar(src, &ch);
	if ((ch & 0xFC00) == 0xD800) {
	    if ((src < endPtr) && Tcl_UtfCharComplete(src, endPtr - src)) {
	} else {
	    len = TclUtfToUniChar(src, &ch);
	}
	src += len;
		int len = TclUtfToUniChar(src, &ch);

		if ((ch & 0xFC00) == 0xDC00) {
		    --i;
		    src += len;
		}
	    }
	}
	i++;
    }
    if (src < endPtr) {
	i += endPtr - src;
    } else if (i && ((ch & 0xFC00) == 0xD800)) {
	*flagPtr = 1;
    }
    return i;
}
#endif

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
/*
 *----------------------------------------------------------------------
 *
 * UtfNcmp --
 *
 *	Like Tcl_UtfNcmp() but the limit is guaranteed and specified in
 *	code points.

static int
UtfNcmp(
    const char *cs,		/* UTF string to compare to ct. */
    const char *ct,		/* UTF string cs is compared to. */
    size_t numCp,		/* Number of code points to compare. */
    int flags)			/* Flags describing string ends. */
{
    Tcl_UniChar ch1 = 0, ch2 = 0;
    int uch1, uch2;

    while (numCp-- > 0) {

	cs += TclUtfToUniChar(cs, &ch1);
	ct += TclUtfToUniChar(ct, &ch2);

	uch1 = ch1;
	uch2 = ch2;

	if ((ch1 & 0xFC00) == 0xD800) {
	    if ((flags & 1) && (numCp == 0)) {
		/* String ends with high surrogate. */
	    } else {
		int len = TclUtfToUniChar(cs, &ch1);

		if ((ch1 & 0xFC00) == 0xDC00) {
		    uch1 = (((uch1&0x3FF)<<10) | (ch1&0x3FF)) + 0x10000;
		    cs += len;
		}
	    }
	}
	if ((ch2 & 0xFC00) == 0xD800) {
	    if ((flags & 2) && (numCp == 0)) {
		/* String ends with high surrogate. */
	    } else {
		int len = TclUtfToUniChar(ct, &ch2);

		if ((ch2 & 0xFC00) == 0xDC00) {
		    uch2 = (((uch2&0x3FF)<<10) | (ch2&0x3FF)) + 0x10000;
		    ct += len;
		}
	    }
	}

	if (uch1 != uch2) {
	    return (uch1 - uch2);
	}
    }
    return Tcl_UtfNcmp(cs, ct, numCp);
    return 0;
}
#endif

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
/*
 *----------------------------------------------------------------------
 *
 * UtfNcasecmp --
 *
 *	Like Tcl_UtfNcasecmp() but the limit is guaranteed and specified in
 *	code points.

static int
UtfNcasecmp(
    const char *cs,		/* UTF string to compare to ct. */
    const char *ct,		/* UTF string cs is compared to. */
    size_t numCp,		/* Number of code points to compare. */
    int flags)			/* Flags describing string ends. */
{
    Tcl_UniChar ch1 = 0, ch2 = 0;
    int uch1, uch2;

    while (numCp-- > 0) {

	cs += TclUtfToUniChar(cs, &ch1);
	ct += TclUtfToUniChar(ct, &ch2);

	uch1 = ch1;
	uch2 = ch2;

	if ((ch1 & 0xFC00) == 0xD800) {
	    if ((flags & 1) && (numCp == 0)) {
		/* String ends with high surrogate. */
	    } else {
		int len = TclUtfToUniChar(cs, &ch1);

		if ((ch1 & 0xFC00) == 0xDC00) {
		    uch1 = (((uch1&0x3FF)<<10) | (ch1&0x3FF)) + 0x10000;
		    cs += len;
		}
	    }
	}
	if ((ch2 & 0xFC00) == 0xD800) {
	    if ((flags & 2) && (numCp == 0)) {
		/* String ends with high surrogate. */
	    } else {
		int len = TclUtfToUniChar(ct, &ch2);

		if ((ch2 & 0xFC00) == 0xDC00) {
		    uch2 = (((uch2&0x3FF)<<10) | (ch2&0x3FF)) + 0x10000;
		    ct += len;
		}
	    }
	}

	if (uch1 != uch2) {
	    uch1 = TclUCS4ToLower(uch1);
	    uch2 = TclUCS4ToLower(uch2);
	    if (uch1 != uch2) {
		return (uch1 - uch2);
	    }
	}
    }
    return Tcl_UtfNcasecmp(cs, ct, numCp);
    return 0;
}
#endif

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
/*
 *---------------------------------------------------------------------------
 *
 * NumCodePointsUnicode --
 *
 *	Returns the number of code points of a Tcl_UniChar array.
 *

	    }
	}
    }
    return n;
}
#endif

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
/*
 *----------------------------------------------------------------------
 *
 * UniCharNcmp --
 *
 *	Like Tcl_UniCharNcmp() but the limit is guaranteed and specified in
 *	code points.

	    return (lcs - lct);
	}
    }
    return 0;
}
#endif

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
/*
 *----------------------------------------------------------------------
 *
 * UniCharNcasecmp --
 *
 *	Like Tcl_UniCharNcasecmp() but the limit is guaranteed and specified in
 *	code points.

	 * This is a simple one pair string map situation. We make use of a
	 * slightly modified version of the one pair STR_MAP code.
	 */

	int slen, nocase;
	int (*strCmpFn)(const Tcl_UniChar*,const Tcl_UniChar*,unsigned long);
	Tcl_UniChar *p;
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
	Tcl_UniChar wsrclc;
#endif

	numMatches = 0;
	nocase = (cflags & TCL_REG_NOCASE);
	strCmpFn = nocase ? Tcl_UniCharNcasecmp : Tcl_UniCharNcmp;

		    Tcl_AppendUnicodeToObj(resultPtr, wsubspec, wsublen);
		    Tcl_AppendUnicodeToObj(resultPtr, wstring, 1);
		    numMatches++;
		}
		wlen = 0;
	    }
	} else {
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
	    wsrclc = Tcl_UniCharToLower(*wsrc);
#endif
	    for (p = wfirstChar = wstring; wstring < wend; wstring++) {
		if (
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
		    (*wstring == *wsrc ||
			(nocase && Tcl_UniCharToLower(*wstring)==wsrclc)) &&
			(slen==1 || (strCmpFn(wstring, wsrc,
				(unsigned long) slen) == 0))
#else
			!strCmpFn(wstring, wsrc, (unsigned long) slen)
#endif

	Tcl_InitHashTable(&charReuseTable, TCL_ONE_WORD_KEYS);

	for ( ; stringPtr < end; stringPtr += len) {
	    int fullchar;

	    len = TclUtfToUniChar(stringPtr, &ch);
	    fullchar = ch;

#if TCL_UTF_MAX == 4
	    if (!len) {
		len += TclUtfToUniChar(stringPtr, &ch);
		fullchar = (((fullchar & 0x3FF) << 10) | (ch & 0x3FF)) + 0x10000;
#if TCL_UTF_MAX == 3
	    if ((stringPtr + len < end) && (fullchar <= 0xFFFF)
		    && ((fullchar & 0xFC00) == 0xD800)) {
		int len2 = TclUtfToUniChar(stringPtr + len, &ch);

		if ((ch & 0xFC00) == 0xDC00) {
		    fullchar = ((fullchar & 0x3FF) << 10) | (ch & 0x3FF);
		    fullchar += 0x10000;
		    len += len2;
		}
	    }
#endif

	    /*
	     * Assume Tcl_UniChar is an integral type...
	     */

	 */

	Tcl_DStringInit(&ds);
	p = splitChars;
	while (p < splitChars + splitCharLen) {
	    len = TclUtfToUniChar(p, &ch);
	    uch = ch;
#if TCL_UTF_MAX == 4
	    if (!len) {
	       	len = TclUtfToUniChar(p, &ch);
		uch = (((uch&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
#if TCL_UTF_MAX == 3
	    if ((ch & 0xFC00) == 0xD800) {
		int len2;

		ch = 0;
	       	len2 = TclUtfToUniChar(p + len, &ch);
		if ((ch & 0xFC00) == 0xDC00) {
		    len += len2;
		    uch = (((uch&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
		}
	    }
#endif
	    Tcl_DStringAppend(&ds, (char *) &uch, sizeof(int));
	    p += len;
	}

	/*
	 * Now have real length of split chars.
	 */

	splitCharLen = Tcl_DStringLength(&ds) / sizeof(int);

	/*
	 * Normal case: split on any of a given set of characters. Discard
	 * instances of the split characters.
	 */

	for (element = stringPtr; stringPtr < end; stringPtr += len) {
	    len = TclUtfToUniChar(stringPtr, &ch);
	    uch = ch;
#if TCL_UTF_MAX == 4
	    if (!len) {
		len = TclUtfToUniChar(stringPtr, &ch);
		uch = (((uch&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
#if TCL_UTF_MAX == 3
	    if ((ch & 0xFC00) == 0xD800) {
		int len2;

		ch = 0;
		len2 = TclUtfToUniChar(stringPtr + len, &ch);
		if ((ch & 0xFC00) == 0xDC00) {
		    len += len2;
		    uch = (((uch&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
		}
	    }
#endif
	    for (i = 0; i < splitCharLen; i++) {
		if (uch == ((int *)Tcl_DStringValue(&ds))[i]) {
		    TclNewStringObj(objPtr, element, stringPtr - element);
		    Tcl_ListObjAppendElement(NULL, listPtr, objPtr);
		    element = stringPtr + len;

	 */

	if (TclIsPureByteArray(objv[1])) {
	    unsigned char uch = UCHAR(ch);

	    Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(&uch, 1));
	} else {
	    char buf[TCL_UTF_MAX] = "";
	    char buf[TCL_UTF_MAX];

	    length = Tcl_UniCharToUtf(ch, buf);
#if TCL_UTF_MAX == 4
	    if (!length) {
		/* Special case for handling high surrogates. */
		length = Tcl_UniCharToUtf(-1, buf);
	    }
#endif
	    Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, length));
	}
    }
    return TCL_OK;
}

/*

	}
	end = string1 + length1;
	for (; string1 < end; string1 += length2, failat++) {
	    int fullchar;

	    length2 = TclUtfToUniChar(string1, &ch);
	    fullchar = ch;
#if TCL_UTF_MAX == 4
	    if (!length2) {
	    	length2 = TclUtfToUniChar(string1, &ch);
	    	fullchar = (((fullchar & 0x3FF) << 10) | (ch & 0x3FF)) + 0x10000;
#if TCL_UTF_MAX == 3
	    if ((string1 + length2 < end) && ((ch & 0xFC00) == 0xD800)) {
		int length3 = TclUtfToUniChar(string1 + length2, &ch);

		if ((ch & 0xFC00) == 0xDC00) {
		    fullchar = ((fullchar & 0x3FF) << 10) | (ch & 0x3FF);
		    fullchar += 0x10000;
		    length2 += length3;
		}
	    }
#endif
	    if (!chcomp(fullchar)) {
		result = 0;
		break;
	    }
	}

	 * extra calls to get Unicode data. The algorithm is otherwise
	 * identical to the multi-pair case. This will be >30% faster on
	 * larger strings.
	 */

	int mapLen;
	Tcl_UniChar *mapString;
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
	Tcl_UniChar u2lc;
#endif

	ustring2 = Tcl_GetUnicodeFromObj(mapElemv[0], &length2);
	p = ustring1;
	if ((length2 > length1) || (length2 == 0)) {
	    /*
	     * Match string is either longer than input or empty.
	     */

	    ustring1 = end;
	} else {
	    mapString = Tcl_GetUnicodeFromObj(mapElemv[1], &mapLen);
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
	    u2lc = (nocase ? Tcl_UniCharToLower(*ustring2) : 0);
#endif
	    for (; ustring1 < end; ustring1++) {
		if (
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
		    ((*ustring1 == *ustring2) ||
			(nocase&&Tcl_UniCharToLower(*ustring1)==u2lc)) &&
			(length2==1 || strCmpFn(ustring1, ustring2,
				(unsigned long) length2) == 0)
#else
		    !strCmpFn(ustring1, ustring2, (unsigned long) length2)
#endif

		    Tcl_AppendUnicodeToObj(resultPtr, mapString, mapLen);
		}
	    }
	}
    } else {
	Tcl_UniChar **mapStrings;
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
	Tcl_UniChar *u2lc = NULL;
#endif
	int *mapLens;

	/*
	 * Precompute pointers to the Unicode string and length. This saves us
	 * repeated function calls later, significantly speeding up the
	 * algorithm. We only need the lowercase first char in the nocase
	 * case.
	 */

	mapStrings = (Tcl_UniChar **)
		TclStackAlloc(interp, mapElemc*2*sizeof(Tcl_UniChar *));
	mapLens = (int *)
		TclStackAlloc(interp, mapElemc * 2 * sizeof(int));
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
	if (nocase) {
	    u2lc = (Tcl_UniChar *)
		    TclStackAlloc(interp, mapElemc * sizeof(Tcl_UniChar));
	}
#endif
	for (index = 0; index < mapElemc; index++) {
	    mapStrings[index] = Tcl_GetUnicodeFromObj(mapElemv[index],
		    mapLens+index);
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
	    if (nocase && ((index % 2) == 0)) {
		u2lc[index/2] = Tcl_UniCharToLower(*mapStrings[index]);
	    }
#endif
	}
	for (p = ustring1; ustring1 < end; ustring1++) {
	    for (index = 0; index < mapElemc; index += 2) {
		/*
		 * Get the key string to match on.
		 */

		ustring2 = mapStrings[index];
		length2 = mapLens[index];
		if (
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
		    (length2 > 0) && ((*ustring1 == *ustring2) || (nocase &&
			(Tcl_UniCharToLower(*ustring1) == u2lc[index/2]))) &&
			/* Restrict max compare length. */
			(end-ustring1 >= length2) && ((length2 == 1) ||
			!strCmpFn(ustring2, ustring1, length2))
#else
		    (length2 > 0) && (end-ustring1 >= length2) &&

		    Tcl_AppendUnicodeToObj(resultPtr,
			    mapStrings[index+1], mapLens[index+1]);
		    break;
		}
	    }
	}
#if TCL_UTF_MAX != 4
#if TCL_UTF_MAX > 3
	if (nocase) {
	    TclStackFree(interp, u2lc);
	}
#endif
	TclStackFree(interp, mapLens);
	TclStackFree(interp, mapStrings);
    }

    }
    string = TclGetStringFromObj(objv[1], &length);
    if (index >= numChars) {
	index = numChars - 1;
    }
    cur = 0;
    if (index > 0) {
#if TCL_UTF_MAX == 3
	int len;
#endif

	p = Tcl_UtfAtIndex(string, index);

#if TCL_UTF_MAX == 4
	length = TclUtfToUniChar(p, &ch);
#if TCL_UTF_MAX == 3
	len = TclUtfToUniChar(p, &ch);
	uch = ch;
	if (!length) {
	    TclUtfToUniChar(p, &ch);
	    uch = (((uch&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
	if ((p + len < string + length) && (ch & 0xFC00) == 0xD800) {
	    TclUtfToUniChar(p + len, &ch);
	    if ((ch & 0xFC00) == 0xDC00) {
		uch = (((uch&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
	    }
	} else if ((ch & 0xFC00) == 0xDC00) {
	    const char *pp;
	    int ppInc = 0;

	    pp = TclUtfPrev(p, string);
	    do {
		pp += ppInc;
		ppInc = TclUtfToUniChar(pp, &ch);
	    } while (pp + ppInc < p);
	    if ((ch & 0xFC00) == 0xD800) {
		p = pp;
		uch = (((ch&0x3FF)<<10) | (uch&0x3FF)) + 0x10000;
		index--;
	    }
	}
#else
	TclUtfToUniChar(p, &ch);
	uch = ch;
#endif
	
	for (cur = index; cur >= 0; cur--) {
	    int delta = 0;
	    const char *next;

	    if (!Tcl_UniCharIsWordChar(uch)) {
		break;
	    }

	    next = TclUtfPrev(p, string);
	    do {
		next += delta;
		delta = TclUtfToUniChar(next, &ch);
	    } while (next + delta < p);
	    p = next;
		uch = ch;
#if TCL_UTF_MAX == 4
		if (!delta) {
		    delta = TclUtfToUniChar(next, &ch);
		    uch = (((uch&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
	    uch = ch;

#if TCL_UTF_MAX == 3
	    if ((p > string) && (ch & 0xFC00) == 0xDC00) {
		const char *pp;
		int ppInc = 0;

		pp = TclUtfPrev(p, string);
		do {
		    pp += ppInc;
		    ppInc = TclUtfToUniChar(pp, &ch);
		} while (pp + ppInc < p);
		if ((ch & 0xFC00) == 0xD800) {
		    p = pp;
		    uch = (((ch&0x3FF)<<10) | (uch&0x3FF)) + 0x10000;
		    if (!Tcl_UniCharIsWordChar(uch)) {
			goto endForLoop;
			break;
		    }
		    cur--;
		}
#endif
	    } while (next + delta < p);
	    p = next;
	}
	    }
#if TCL_UTF_MAX == 4
endForLoop:
#endif
	}
	if (cur != index) {
	    cur += 1;
	}
    }
    Tcl_SetObjResult(interp, Tcl_NewIntObj(cur));
    return TCL_OK;
}

    if (index < 0) {
	index = 0;
    }
    if (index < numChars) {
	p = Tcl_UtfAtIndex(string, index);
	end = string+length;
	for (cur = index; p < end; cur++) {
#if TCL_UTF_MAX == 4
	    length = TclUtfToUniChar(p, &ch);
	    p += TclUtfToUniChar(p, &ch);
	    uch = ch;
	    if (!length) {
		length = TclUtfToUniChar(p, &ch);
		uch = (((uch&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
		if (Tcl_UniCharIsWordChar(uch)) {
		    cur++;
		    continue;
		}
		break;
	    }
#if TCL_UTF_MAX == 3
	    if ((p < end) && ((ch & 0xFC00) == 0xD800)) {
		int len = TclUtfToUniChar(p, &ch);

		if ((ch & 0xFC00) == 0xDC00) {
		    uch = (((uch&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
		    p += len;
		    if (Tcl_UniCharIsWordChar(uch)) {
			cur++;
			continue;
		    }
		    break;
		}
	    p += length;
#else
	    p += TclUtfToUniChar(p, &ch);
	    uch = ch;
	    }
#endif
	    if (!Tcl_UniCharIsWordChar(uch)) {
		break;
	    }
	}
	if (cur == index) {
	    cur++;

    int checkEq,		/* comparison is only for equality */
    int nocase,			/* comparison is not case sensitive */
    int reqlength)		/* requested length; -1 to compare whole
				 * strings */
{
    const char *s1, *s2;
    int empty, length, match, s1len, s2len;
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
    int s1flag = 0, s2flag = 0;
    typedef int (*memCmpFn_t)(const void *, const void *, size_t, int);
#else
    typedef int (*memCmpFn_t)(const void *, const void *, size_t);
#endif
    memCmpFn_t memCmpFn;

	 * type conversions and it is much faster. Only do this if we're
	 * case-sensitive (which is all that really makes sense with byte
	 * arrays anyway, and we have no memcasecmp() for some reason... :^)
	 */

	s1 = (char *) Tcl_GetByteArrayFromObj(value1Ptr, &s1len);
	s2 = (char *) Tcl_GetByteArrayFromObj(value2Ptr, &s2len);
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
	memCmpFn = MemCmp;
#else
	memCmpFn = memcmp;
#endif
    } else if ((value1Ptr->typePtr == &tclStringType)
	    && (value2Ptr->typePtr == &tclStringType)) {
	/*
	 * Do a Unicode-specific comparison if both of the args are of String
	 * type. If the char length == byte length, we can do a memcmp. In
	 * benchmark testing this proved the most efficient check between the
	 * Unicode and string comparison operations.
	 */

	if (nocase) {
	    s1 = (char *) Tcl_GetUnicodeFromObj(value1Ptr, &s1len);
	    s2 = (char *) Tcl_GetUnicodeFromObj(value2Ptr, &s2len);
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
	    s1len = NumCodePointsUnicode((Tcl_UniChar *) s1, s1len, &s1flag);
	    s2len = NumCodePointsUnicode((Tcl_UniChar *) s2, s2len, &s2flag);
	    memCmpFn = (memCmpFn_t) UniCharNcasecmp;
#else
	    memCmpFn = (memCmpFn_t) Tcl_UniCharNcasecmp;
	    memCmpFn = (memCmpFn_t)Tcl_UniCharNcasecmp;
#endif
	} else {
	    s1len = Tcl_GetCharLength(value1Ptr);
	    s2len = Tcl_GetCharLength(value2Ptr);
	    if ((s1len == value1Ptr->length)
		    && (value1Ptr->bytes != NULL)
		    && (s2len == value2Ptr->length)
		    && (value2Ptr->bytes != NULL)) {
		s1 = value1Ptr->bytes;
		s2 = value2Ptr->bytes;
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
		memCmpFn = MemCmp;
#else
		memCmpFn = memcmp;
#endif
	    } else {
		s1 = (char *) Tcl_GetUnicode(value1Ptr);
		s2 = (char *) Tcl_GetUnicode(value2Ptr);
		if (
#ifdef WORDS_BIGENDIAN
			1
#else
			checkEq
#endif /* WORDS_BIGENDIAN */
		        ) {
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
		    memCmpFn = MemCmp;
#else
		    memCmpFn = memcmp;
#endif
		    s1len *= sizeof(Tcl_UniChar);
		    s2len *= sizeof(Tcl_UniChar);
		} else {
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
		    s1len = NumCodePointsUnicode((Tcl_UniChar *) s1,
			    s1len, &s1flag);
		    s2len = NumCodePointsUnicode((Tcl_UniChar *) s2,
			    s2len, &s2flag);
		    memCmpFn = (memCmpFn_t) UniCharNcmp;
#else
		    memCmpFn = (memCmpFn_t) Tcl_UniCharNcmp;

	if (!nocase && checkEq) {
	    /*
	     * When we have equal-length we can check only for (in)equality.
	     * We can use memcmp() in all (n)eq cases because we don't need to
	     * worry about lexical LE/BE variance.
	     */
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
	    memCmpFn = MemCmp;
#else
	    memCmpFn = memcmp;
#endif
	} else {
	    /*
	     * As a catch-all we will work with UTF-8. We cannot use memcmp()
	     * as that is unsafe with any string containing NUL (\xC0\x80 in
	     * Tcl's utf rep). We can use the more efficient TclpUtfNcmp2 if
	     * we are case-sensitive and no specific length was requested.
	     */
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
	    s1len = NumCodePointsUtf(s1, s1len, &s1flag);
	    s2len = NumCodePointsUtf(s2, s2len, &s2flag);
	    memCmpFn = (memCmpFn_t) (nocase ? UtfNcasecmp : UtfNcmp);
	    memCmpFn = (memCmpFn_t)
		    (nocase ? UtfNcasecmp : UtfNcmp);
#else
	    if ((reqlength < 0) && !nocase) {
		memCmpFn = (memCmpFn_t) TclpUtfNcmp2;
	    } else {
		s1len = Tcl_NumUtfChars(s1, s1len);
		s2len = Tcl_NumUtfChars(s2, s2len);
		memCmpFn = (memCmpFn_t)

    if (checkEq && (s1len != s2len)) {
	match = 1;		/* This will be reversed below. */
    } else {
	/*
	 * The comparison function should compare up to the minimum byte
	 * length only.
	 */
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
	match = memCmpFn(s1, s2, (size_t) length, s1flag | (s2flag << 1));
#else
	match = memCmpFn(s1, s2, (size_t) length);
#endif
    }
    if ((match == 0) && (reqlength > length)) {
	match = s1len - s2len;

	PUSH("");
	count++;
    }

    for (endTokenPtr = tokenPtr + parse.numTokens;
	    tokenPtr < endTokenPtr; tokenPtr = TokenAfter(tokenPtr)) {
	int length, literal, catchRange, breakJump;
	char buf[TCL_UTF_MAX] = "";
	char buf[TCL_UTF_MAX*2];
	JumpFixup startFixup, okFixup, returnFixup, breakFixup;
	JumpFixup continueFixup, otherFixup, endFixup;

	switch (tokenPtr->type) {
	case TCL_TOKEN_TEXT:
	    literal = TclRegisterNewLiteral(envPtr,
		    tokenPtr->start, tokenPtr->size);

	    if (tempPtr != NULL) {
		Tcl_AppendToObj(tempPtr, tokenPtr->start, tokenPtr->size);
	    }
	    break;

	case TCL_TOKEN_BS:
	    if (tempPtr != NULL) {
		char utfBuf[TCL_UTF_MAX] = "";
		char utfBuf[TCL_UTF_MAX*2];
		int length = TclParseBackslash(tokenPtr->start,
			tokenPtr->size, NULL, utfBuf);

#if TCL_UTF_MAX > 3
		if ((length > 1) && (numComponents > 0)) {
		    /*
		     * Try to collapse a surrogate pair into a single

				 * compile. */
    int count,			/* Number of tokens to consider at tokenPtr.
				 * Must be at least 1. */
    CompileEnv *envPtr)		/* Holds the resulting instructions. */
{
    Tcl_DString textBuffer;	/* Holds concatenated chars from adjacent
				 * TCL_TOKEN_TEXT, TCL_TOKEN_BS tokens. */
    char buffer[TCL_UTF_MAX] = "";
    char buffer[TCL_UTF_MAX*2];
    int i, numObjsToConcat, length, adjust;
    unsigned char *entryCodeNext = envPtr->codeNext;
#define NUM_STATIC_POS 20
    int isLiteral, maxNumCL, numCL;
    int *clPosition = NULL;
    int depth = TclGetStackDepth(envPtr);

	    i += 2;
	    continue;
	case '\v':
	    Tcl_AppendToObj(appendObj, "\\v", -1);
	    i += 2;
	    continue;
	default:
#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
	    if (ch > 0xFFFF) {
		Tcl_AppendPrintfToObj(appendObj, "\\U%08x", ch);
		i += 10;
	    } else
#elif TCL_UTF_MAX > 3
	    /* If len == 0, this means we have a char > 0xFFFF, resulting in
	     * TclUtfToUniChar producing a surrogate pair. We want to output
	     * this pair as a single Unicode character.
	     */
	    if (len == 0) {
		int upper = ((ch & 0x3FF) + 1) << 10;
		len = TclUtfToUniChar(p, &ch);
		Tcl_AppendPrintfToObj(appendObj, "\\U%08x", upper + (ch & 0x3FF));
		i += 10;
	    } else
#endif
	    if (ch < 0x20 || ch >= 0x7F) {
		Tcl_AppendPrintfToObj(appendObj, "\\u%04x", ch);
		i += 6;
	    } else {
		Tcl_AppendPrintfToObj(appendObj, "%c", ch);

			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);
static int		TableToUtfProc(ClientData clientData, const char *src,
			    int srcLen, int flags, Tcl_EncodingState *statePtr,
			    char *dst, int dstLen, int *srcReadPtr,
			    int *dstWrotePtr, int *dstCharsPtr);
static size_t		unilen(const char *src);
#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
static size_t		unilen4(const char *src);
#endif
static int		UnicodeToUtfProc(ClientData clientData,
			    const char *src, int srcLen, int flags,
			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);
static int		UtfToUnicodeProc(ClientData clientData,
			    const char *src, int srcLen, int flags,
			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);
#if TCL_UTF_MAX > 3
static int		UtfToUtfProc(ClientData clientData,
			    const char *src, int srcLen, int flags,
			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr, int pureNullMode);
#endif
static int		UtfIntToUtfExtProc(ClientData clientData,
			    const char *src, int srcLen, int flags,
			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);
static int		UtfExtToUtfIntProc(ClientData clientData,
			    const char *src, int srcLen, int flags,

			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);
static int		UtfToMcesu8Proc(ClientData clientData,
			    const char *src, int srcLen, int flags,
			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);
#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
static int		Utf16ToUtfProc(ClientData clientData,
			    const char *src, int srcLen, int flags,
			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
			    int *srcReadPtr, int *dstWrotePtr,
			    int *dstCharsPtr);
static int		UtfToUtf16Proc(ClientData clientData,
			    const char *src, int srcLen, int flags,

    type.toUtfProc	= UtfExtToUtfIntProc;
    type.fromUtfProc	= UtfIntToUtfExtProc;
    type.freeProc	= NULL;
    type.nullSize	= 1;
    type.clientData	= NULL;
    Tcl_CreateEncoding(&type);

#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
    type.encodingName   = "utf-32";
#else
    type.encodingName   = "unicode";
#endif
    type.toUtfProc	= UnicodeToUtfProc;
    type.fromUtfProc    = UtfToUnicodeProc;
    type.freeProc	= NULL;
#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
    type.nullSize	= 4;
#else
    type.nullSize	= 2;
#endif
    type.clientData	= NULL;
    Tcl_CreateEncoding(&type);

#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
    type.encodingName   = "unicode";
    type.toUtfProc	= Utf16ToUtfProc;
    type.fromUtfProc    = UtfToUtf16Proc;
    type.freeProc	= NULL;
    type.nullSize	= 2;
    type.clientData	= NULL;
    Tcl_CreateEncoding(&type);

    encodingPtr->toUtfProc	= typePtr->toUtfProc;
    encodingPtr->fromUtfProc	= typePtr->fromUtfProc;
    encodingPtr->freeProc	= typePtr->freeProc;
    encodingPtr->nullSize	= typePtr->nullSize;
    encodingPtr->clientData	= typePtr->clientData;
    if (typePtr->nullSize == 1) {
	encodingPtr->lengthProc = (LengthProc *) strlen;
#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
    } else if (typePtr->nullSize == 4) {
	encodingPtr->lengthProc = (LengthProc *) unilen4;
#endif
    } else {
	encodingPtr->lengthProc = (LengthProc *) unilen;
    }
    encodingPtr->refCount	= 1;

}

/*
 *-------------------------------------------------------------------------
 *
 * UtfIntToUtfExtProc --
 *
 *	Convert from UTF-8 to UTF-8. While converting null-bytes from the
 *	Tcl's internal representation (0xC0, 0x80) to the official
 *	Convert from (U|W)TF-8 to UTF-8. While converting null-bytes
 *	from Tcl's internal representation (0xC0, 0x80) to the official
 *	representation (0x00). See UtfToUtfProc for details.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.

    int *dstWrotePtr,		/* Filled with the number of bytes that were
				 * stored in the output buffer as a result of
				 * the conversion. */
    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
#if TCL_UTF_MAX > 3
    /* UTF-8 to UTF-8 */

    return UtfToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
	    srcReadPtr, dstWrotePtr, dstCharsPtr, 1);
#else
    /* WTF-8 to UTF-8 */
}


    const char *srcStart, *srcEnd, *srcClose;
    const char *dstStart, *dstEnd;
    int result, numChars, charLimit = INT_MAX;
    Tcl_UniChar ch;

    result = TCL_OK;

    srcStart = src;
    srcEnd = src + srcLen;
    srcClose = srcEnd;
    if ((flags & TCL_ENCODING_END) == 0) {
	srcClose -= 3;
    }
    if (flags & TCL_ENCODING_CHAR_LIMIT) {
	charLimit = *dstCharsPtr;
    }

    dstStart = dst;
    dstEnd = dst + dstLen - 4;

    for (numChars = 0; src < srcEnd && numChars <= charLimit; numChars++) {
	if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
	    result = TCL_CONVERT_MULTIBYTE;
	    break;
	}
	if (dst > dstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
	}
	if (UCHAR(*src) == 0xc0 && (src + 1 < srcEnd) &&
		UCHAR(*(src+1)) == 0x80) {
	    *dst++ = 0;
	    src += 2;
	} else if (!Tcl_UtfCharComplete(src, srcEnd - src)) {
	    ch = (unsigned char) *src;
	    src += 1;
	    dst += Tcl_UniCharToUtf(ch, dst);
	} else {
	    int ch2, len;
	    
	    src += Tcl_UtfToUniChar(src, &ch);
	    ch2 = ch;
	    if ((ch & 0xFC00) == 0xD800) {
		if (Tcl_UtfCharComplete(src, srcEnd - src)) {
		    len = Tcl_UtfToUniChar(src, &ch);
		    if ((ch & 0xFC00) == 0xDC00) {
			src += len;
			ch2 = (((ch2&0x3FF)<<10) | (ch&0x3FF)) + 0x10000;
		    }
		}
	    }
	    dst += TclUniCharToUtfExt(ch2, dst);
	}
    }
    *srcReadPtr = src - srcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;
    return result;
#endif
}

/*
 *-------------------------------------------------------------------------
 *
 * UtfExtToUtfIntProc --
 *
 *	Convert from UTF-8 to UTF-8 while converting null-bytes from the
 *	Convert from UTF-8 to (U|W)TF-8 while converting null-bytes from the
 *	official representation (0x00) to Tcl's internal representation (0xC0,
 *	0x80). See UtfToUtfProc for details.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:

    int *dstWrotePtr,		/* Filled with the number of bytes that were
				 * stored in the output buffer as a result of
				 * the conversion. */
    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
#if TCL_UTF_MAX > 3
    /* UTF-8 to UTF-8 */

    return UtfToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
	    srcReadPtr, dstWrotePtr, dstCharsPtr, 0);
#else
    /* UTF-8 to WTF-8 */
}


    const char *srcStart, *srcEnd, *srcClose;
    const char *dstStart, *dstEnd;
    int ch, result, numChars, charLimit = INT_MAX;

    result = TCL_OK;

    srcStart = src;
    srcEnd = src + srcLen;
    srcClose = srcEnd;
    if ((flags & TCL_ENCODING_END) == 0) {
	srcClose -= 4;
    }
    if (flags & TCL_ENCODING_CHAR_LIMIT) {
	charLimit = *dstCharsPtr;
    }

    dstStart = dst;
    dstEnd = dst + dstLen - TCL_UTF_MAX;

    for (numChars = 0; src < srcEnd && numChars <= charLimit; numChars++) {
	if ((src > srcClose) && (!TclUtfCharCompleteExt(src, srcEnd - src))) {
	    result = TCL_CONVERT_MULTIBYTE;
	    break;
	}
	if (dst > dstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
	}
	if (UCHAR(*src) < 0x80 && UCHAR(*src) != 0) {
	    *dst++ = *src++;
	} else if (!TclUtfCharCompleteExt(src, srcEnd - src)) {
	    ch = (unsigned char) *src;
	    src += 1;
	    dst += Tcl_UniCharToUtf(ch, dst);
	} else {
	    int len = TclUtfToUniCharExt(src, &ch);

	    if (ch > 0xFFFF && ch <= 0x10FFFF) {
		int dstLen;

		ch -= 0x10000;
		dstLen = Tcl_UniCharToUtf((ch >> 10) | 0xD800, dst);
		ch = (ch & 0x3FF) | 0xDC00;
		if (dst + dstLen > dstEnd) {
		    result = TCL_CONVERT_NOSPACE;
		    break;
		}
		dst += dstLen;
		numChars++;
	    }
	    src += len;
	    dst += Tcl_UniCharToUtf(ch, dst);
	}
    }

    *srcReadPtr = src - srcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;
    return result;
#endif
}

#if TCL_UTF_MAX > 3
/*
 *-------------------------------------------------------------------------
 *
 * UtfToUtfProc --
 *
 *	Convert from UTF-8 to UTF-8. Note that the UTF-8 to UTF-8 translation
 *	is not a no-op, because it will turn a stream of improperly formed

    int pureNullMode)		/* Convert embedded nulls from internal
				 * representation to real null-bytes or vice
				 * versa. */
{
    const char *srcStart, *srcEnd, *srcClose;
    const char *dstStart, *dstEnd;
    int result, numChars, charLimit = INT_MAX;
    Tcl_UniChar *chPtr = (Tcl_UniChar *) statePtr;
    Tcl_UniChar ch = 0;

    if (flags & TCL_ENCODING_START) {
    	*statePtr = 0;
    }
    result = TCL_OK;

    srcStart = src;
    srcEnd = src + srcLen;
    srcClose = srcEnd;
    if ((flags & TCL_ENCODING_END) == 0) {
	srcClose -= TCL_UTF_MAX;

	} else if (!Tcl_UtfCharComplete(src, srcEnd - src)) {
	    /*
	     * Always check before using TclUtfToUniChar. Not doing can so
	     * cause it run beyond the end of the buffer! If we happen such an
	     * incomplete char its bytes are made to represent themselves.
	     */

	    *chPtr = (unsigned char) *src;
	    ch = (unsigned char) *src;
	    src += 1;
	    dst += Tcl_UniCharToUtf(*chPtr, dst);
	    dst += Tcl_UniCharToUtf(ch, dst);
	} else {
	    int len = TclUtfToUniChar(src, chPtr);
	    src += TclUtfToUniChar(src, &ch);
	    src += len;
	    dst += Tcl_UniCharToUtf(*chPtr, dst);
#if TCL_UTF_MAX == 4
	    if (!len) {
		src += TclUtfToUniChar(src, chPtr);
		dst += Tcl_UniCharToUtf(*chPtr, dst);
	    }
#if TCL_UTF_MAX > 3
	    /*
	     * Collapse surrogate pairs in both directions.
	     */

	    if ((ch & 0xFFFFC00) == 0xD800 &&
		Tcl_UtfCharComplete(src, srcEnd - src)) {
		Tcl_UniChar ch2;
		int len;

		len = Tcl_UtfToUniChar(src, &ch2);
		if ((ch2 & 0xFFFFFC00) == 0xDC00) {
		    src += len;
		    ch = (((ch & 0x3FF) << 10) | (ch2 & 0x3FF)) + 0x10000;
		}
	    }
#endif
	    dst += Tcl_UniCharToUtf(ch, dst);
	}
    }

    *srcReadPtr = src - srcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;
    return result;
}
#endif

/*
 *-------------------------------------------------------------------------
 *
 * UnicodeToUtfProc --
 *
 *	Convert from Unicode to UTF-8.

    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
    const char *srcStart, *srcEnd;
    const char *dstEnd, *dstStart;
    int result, numChars, charLimit = INT_MAX;
    Tcl_UniChar *chPtr = (Tcl_UniChar *) statePtr;
    Tcl_UniChar ch = 0;

    if (flags & TCL_ENCODING_START) {
    	*statePtr = 0;
    }
    if (flags & TCL_ENCODING_CHAR_LIMIT) {
	charLimit = *dstCharsPtr;
    }
    result = TCL_OK;
    if ((srcLen % sizeof(Tcl_UniChar)) != 0) {
	result = TCL_CONVERT_MULTIBYTE;
	srcLen /= sizeof(Tcl_UniChar);

	}

	/*
	 * Special case for 1-byte utf chars for speed. Make sure we work with
	 * Tcl_UniChar-size data.
	 */

	*chPtr = *(Tcl_UniChar *)src;
	if (*chPtr && *chPtr < 0x80) {
	    *dst++ = (*chPtr & 0xFF);
	ch = *(Tcl_UniChar *)src;
	if (ch && ch < 0x80) {
	    *dst++ = (ch & 0xFF);
	} else {
	    dst += Tcl_UniCharToUtf(*chPtr, dst);
	    dst += Tcl_UniCharToUtf(ch, dst);
	}
	src += sizeof(Tcl_UniChar);
    }

    *srcReadPtr = src - srcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;

				 * the conversion. */
    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
    const char *srcStart, *srcEnd, *srcClose, *dstStart, *dstEnd;
    int result, numChars;
    Tcl_UniChar *chPtr = (Tcl_UniChar *) statePtr;
    Tcl_UniChar ch = 0;

    if (flags & TCL_ENCODING_START) {
    	*statePtr = 0;
    }
    srcStart = src;
    srcEnd = src + srcLen;
    srcClose = srcEnd;
    if ((flags & TCL_ENCODING_END) == 0) {
	srcClose -= TCL_UTF_MAX;
    }

	    result = TCL_CONVERT_MULTIBYTE;
	    break;
	}
	if (dst > dstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
	}
	src += TclUtfToUniChar(src, chPtr);
	src += TclUtfToUniChar(src, &ch);

	/*
	 * Need to handle this in a way that won't cause misalignment by
	 * casting dst to a Tcl_UniChar. [Bug 1122671]
	 */

#ifdef WORDS_BIGENDIAN
#if TCL_UTF_MAX > 4
	*dst++ = (*chPtr >> 24);
	*dst++ = ((*chPtr >> 16) & 0xFF);
	*dst++ = ((*chPtr >> 8) & 0xFF);
	*dst++ = (*chPtr & 0xFF);
#if TCL_UTF_MAX > 3
	*dst++ = (ch >> 24);
	*dst++ = ((ch >> 16) & 0xFF);
	*dst++ = ((ch >> 8) & 0xFF);
	*dst++ = (ch & 0xFF);
#else
	*dst++ = (*chPtr >> 8);
	*dst++ = (*chPtr & 0xFF);
	*dst++ = (ch >> 8);
	*dst++ = (ch & 0xFF);
#endif
#else
#if TCL_UTF_MAX > 4
	*dst++ = (*chPtr & 0xFF);
	*dst++ = ((*chPtr >> 8) & 0xFF);
	*dst++ = ((*chPtr >> 16) & 0xFF);
	*dst++ = (*chPtr >> 24);
#if TCL_UTF_MAX > 3
	*dst++ = (ch & 0xFF);
	*dst++ = ((ch >> 8) & 0xFF);
	*dst++ = ((ch >> 16) & 0xFF);
	*dst++ = (ch >> 24);
#else
	*dst++ = (*chPtr & 0xFF);
	*dst++ = (*chPtr >> 8);
	*dst++ = (ch & 0xFF);
	*dst++ = (ch >> 8);
#endif
#endif
    }
    *srcReadPtr = src - srcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;
    return result;

	     */

	    result = TCL_CONVERT_MULTIBYTE;
	    break;
	}
	len = TclUtfToUniChar(src, &ch);

#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
	/*
	 * This prevents a crash condition. More evaluation is required for
	 * full support of int Tcl_UniChar. [Bug 1004065]
	 */

	if (ch & 0xFFFF0000) {
	    word = 0;
	} else
#elif TCL_UTF_MAX == 4
	if (!len) {
	    word = 0;
	} else
#endif
	    word = fromUnicode[(ch >> 8)][ch & 0xFF];

	if ((word == 0) && (ch != 0)) {
	    if (flags & TCL_ENCODING_STOPONERROR) {

	}
	len = TclUtfToUniChar(src, &ch);

	/*
	 * Check for illegal characters.
	 */

	if (ch > 0xFF
	if (ch > 0xFF) {
#if TCL_UTF_MAX == 4
		|| !len
#endif
		) {
	    if (flags & TCL_ENCODING_STOPONERROR) {
		result = TCL_CONVERT_UNKNOWN;
		break;
	    }
#if TCL_UTF_MAX == 4
	    if (!len) len = 4;
#endif

	    /*
	     * Plunge on, using '?' as a fallback character.
	     */

	    ch = (Tcl_UniChar) '?';
	}

    *srcReadPtr = src - srcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;
    return result;
}

#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
/*
 *-------------------------------------------------------------------------
 *
 * Utf16ToUtfProc --
 *
 *	Convert from UTF-16 to UTF-8.
 *

    *srcReadPtr = src - srcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;
    return result;
}
#endif

#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
/*
 *-------------------------------------------------------------------------
 *
 * UtfToUtf16Proc --
 *
 *	Convert from UTF-8 to UTF-16.
 *

	    *chPtr = (unsigned char) *src;
	    src += 1;
	    dst += Tcl_UniCharToUtf(*chPtr, dst);
	} else {
	    int len = TclUtfToUniChar(src, chPtr);

	    src += len;
#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
	    if (*chPtr > 0xFFFF) {
		int ch;

		ch = (((*chPtr - 0x10000) >> 10) & 0x3FF) | 0xD800;
		dst += Tcl_UniCharToUtf(ch, dst);
		ch = ((*chPtr - 0x10000) & 0x3FF) | 0xDC00;
		dst += Tcl_UniCharToUtf(ch, dst);
		continue;
	    }
#endif
#if TCL_UTF_MAX == 4
	    if (!len) {
		dst += Tcl_UniCharToUtf(*chPtr, dst);
		src += TclUtfToUniChar(src, chPtr);
	    }
#endif
	    if ((*chPtr & 0xF800) == 0xD800) {
		/*
		 * Don't let stray surrogates pass.
		 */

		*chPtr = 0xFFFD;
	    }
	    dst += Tcl_UniCharToUtf(*chPtr, dst);
	}
    }

    *srcReadPtr = src - srcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;

	    *chPtr = (unsigned char) *src;
	    src += 1;
	    dst += Tcl_UniCharToUtf(*chPtr, dst);
	} else {
	    int len = TclUtfToUniChar(src, chPtr);

	    src += len;
#if TCL_UTF_MAX >= 4
#if TCL_UTF_MAX > 3
	    if ((*chPtr & 0xFC00) == 0xD800) {
		int len2 = 0;
		Tcl_UniChar ch2 = 0;

		if (Tcl_UtfCharComplete(src, srcEnd - src)) {
		    len2 = TclUtfToUniChar(src, &ch2);
		}

    p = (unsigned short *) src;
    while (*p != 0x0000) {
	p++;
    }
    return (char *) p - src;
}

#if TCL_UTF_MAX > 4
#if TCL_UTF_MAX > 3
static size_t
unilen4(
    const char *src)
{
    unsigned int *p;

    p = (unsigned int *) src;

	} else if (TclIsPureByteArray(valuePtr)) {
	    objResultPtr = Tcl_NewByteArrayObj(
		    Tcl_GetByteArrayFromObj(valuePtr, NULL)+index, 1);
	} else if (valuePtr->bytes && length == valuePtr->length) {
	    objResultPtr = Tcl_NewStringObj((const char *)
		    valuePtr->bytes+index, 1);
	} else {
	    char buf[TCL_UTF_MAX] = "";
	    char buf[TCL_UTF_MAX];
	    Tcl_UniChar ch = Tcl_GetUniChar(valuePtr, index);

	    /*
	     * This could be: Tcl_NewUnicodeObj((const Tcl_UniChar *)&ch, 1)
	     * but creating the object as a string seems to be faster in
	     * practical use.
	     */

	    length = Tcl_UniCharToUtf(ch, buf);
#if TCL_UTF_MAX == 4
	    /* Special case for handling high surrogates. */
	    if (!length) {
		length = Tcl_UniCharToUtf(-1, buf);
	    }
#endif
	    objResultPtr = Tcl_NewStringObj(buf, length);
	}

	TRACE_APPEND(("\"%s\"\n", O2S(objResultPtr)));
	NEXT_INST_F(1, 2, 1);

    case INST_STR_RANGE:

	ustring1 = Tcl_GetUnicodeFromObj(valuePtr, &length);
	match = 1;
	if (length > 0) {
	    end = ustring1 + length;
	    for (p=ustring1 ; p<end ; p++) {
		int ch = *p;

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
		if (((ch&0xFC00)==0xD800) && (p+1<end)) {
		    if ((p[1]&0xFC00)==0xDC00) {
			ch = ((ch&0x3FF) << 10) + 0x10000 + (p[1]&0x3FF);
			p++;
		    }
		}
#endif

MODULE_SCOPE void *	TclpThreadGetGlobalTSD(void *tsdKeyPtr);

MODULE_SCOPE void	TclErrorStackResetIf(Tcl_Interp *interp, const char *msg, int length);

#if TCL_UTF_MAX > 3
MODULE_SCOPE int	TclCollapseSurrogatePair(Tcl_Token *tokenPtr,
			    int *numReadPtr, char *buffer);
#define	TclUCS4ToUpper(ch) Tcl_UniCharToUpper((ch))
#define	TclUCS4ToLower(ch) Tcl_UniCharToLower((ch))
#define	TclUCS4ToTitle(ch) Tcl_UniCharToTitle((ch))
#endif
#else
#if TCL_UTF_MAX == 4
MODULE_SCOPE int	TclUniCharToUtfExt(int ch, char *buf);
MODULE_SCOPE int	TclUtfToUniCharExt(const char *src, int *chPtr);
MODULE_SCOPE int	TclUtfCharCompleteExt(const char *src, int len);
MODULE_SCOPE int	TclUCS4ToUpper(int ch);
MODULE_SCOPE int	TclUCS4ToLower(int ch);
MODULE_SCOPE int	TclUCS4ToTitle(int ch);
#else
#define	TclUCS4ToUpper(ch) Tcl_UniCharToUpper((ch))
#define	TclUCS4ToLower(ch) Tcl_UniCharToLower((ch))
#define	TclUCS4ToTitle(ch) Tcl_UniCharToTitle((ch))
#endif

/*
 * Many parsing tasks need a common definition of whitespace.
 * Use this routine and macro to achieve that and place
 * optimization (fragile on changes) in one place.
 */

/*
 * Further on, in UNICODE mode we just use Tcl_NewUnicodeObj, otherwise
 * NewNativeObj is needed (which provides proper conversion from native
 * encoding to UTF-8).
 */

#if defined(UNICODE) && (TCL_UTF_MAX <= 4)
#if defined(UNICODE) && (TCL_UTF_MAX == 3)
#   define NewNativeObj Tcl_NewUnicodeObj
#else /* !UNICODE || (TCL_UTF_MAX > 4) */
#else /* !UNICODE || (TCL_UTF_MAX > 3) */
static inline Tcl_Obj *
NewNativeObj(
    TCHAR *string,
    int length)
{
    Tcl_DString ds;

 *	Scans up to numBytes bytes starting at src, consuming a backslash
 *	sequence as defined by Tcl's parsing rules.
 *
 * Results:
 *	Records at readPtr the number of bytes making up the backslash
 *	sequence. Records at dst the UTF-8 encoded equivalent of that
 *	backslash sequence. Returns the number of bytes written to dst, at
 *	most TCL_UTF_MAX. Either readPtr or dst may be NULL, if the results
 *	most TCL_UTF_MAX*2. Either readPtr or dst may be NULL, if the results
 *	are not needed, but the return value is the same either way.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

int
TclParseBackslash(
    const char *src,		/* Points to the backslash character of a a
				 * backslash sequence. */
    int numBytes,		/* Max number of bytes to scan. */
    int *readPtr,		/* NULL, or points to storage where the number
				 * of bytes scanned should be written. */
    char *dst)			/* NULL, or points to buffer where the UTF-8
				 * encoding of the backslash sequence is to be
				 * written. At most TCL_UTF_MAX bytes will be
				 * written. At most TCL_UTF_MAX*2 bytes will be
				 * written there. */
{
    const char *p = src+1;
    Tcl_UniChar unichar = 0;
    int result;
    int count;
    char buf[TCL_UTF_MAX] = "";
    char buf[TCL_UTF_MAX];

    if (numBytes == 0) {
	if (readPtr != NULL) {
	    *readPtr = 0;
	}
	return 0;
    }

	     * No hexdigits -> This is just "U".
	     */
	    result = 'U';
	} else {
	    /*
	     * Check Unicode range.
	     */
#if TCL_UTF_MAX > 3
	    if ((result < 0) || (result > 0x10FFFF)) {
		result = 0xFFFD;
	    }
#else
	    if ((result < 0) || (result > 0xFFFF)) {
		result = 0xFFFD;
	    }
#endif
	}
	break;
    case '\n':
	count--;
	do {
	    p++;
	    count++;

	break;
    }

  done:
    if (readPtr != NULL) {
	*readPtr = count;
    }
    count = Tcl_UniCharToUtf(result, dst);
#if TCL_UTF_MAX == 4
    if (!count) {
	/* Special case for handling high surrogates. */
	count = Tcl_UniCharToUtf(-1, dst);
    count = 0;
#if TCL_UTF_MAX == 3
    if ((result > 0xFFFF) && (result <= 0x10FFFF)) {
	result -= 0x10000;
	count += Tcl_UniCharToUtf((result >> 10) | 0xD800, dst);
	result = (result & 0x3FF) | 0xDC00;
    }
#endif
    count += Tcl_UniCharToUtf(result, dst + count);
    return count;
}

/*
 *----------------------------------------------------------------------
 *
 * ParseComment --

    adjust = 0;
    result = NULL;
    for (; count>0 && code==TCL_OK ; count--, tokenPtr++) {
	Tcl_Obj *appendObj = NULL;
	const char *append = NULL;
	int appendByteLength = 0;
	char utfCharBytes[TCL_UTF_MAX] = "";
	char utfCharBytes[TCL_UTF_MAX*2];

	switch (tokenPtr->type) {
	case TCL_TOKEN_TEXT:
	    append = tokenPtr->start;
	    appendByteLength = tokenPtr->size;
	    break;

TclCollapseSurrogatePair(
    Tcl_Token *tokenPtr,	/* Pointer to token to be checked. */
    int *numReadPtr,		/* Pointer to number of consumed input chars. */
    char *buffer)		/* Buffer holding UTF data of previous token. */
{
    int count, numRead;
    Tcl_UniChar ch = 0, ch2 = 0;
    char buffer2[TCL_UTF_MAX] = "";
    char buffer2[TCL_UTF_MAX];

    Tcl_UtfToUniChar(buffer, &ch);
    TclUtfToUniChar(buffer, &ch);
    if ((ch <= 0xFFFF) && ((ch & 0xFC00) == 0xD800)) {
	if (tokenPtr->type == TCL_TOKEN_BS) {
	    count = TclParseBackslash(tokenPtr->start, tokenPtr->size,
			    &numRead, buffer2);
	    if (count <= 0) {
		return 0;
	    }
	    Tcl_UtfToUniChar(buffer2, &ch2);
	    TclUtfToUniChar(buffer2, &ch2);
	    if ((ch2 <= 0xFFFF) && ((ch2 & 0xFC00) == 0xDC00)) {
		unsigned int uch = ((ch & 0x3FF) << 10) + (ch2 & 0x3FF);

		uch += 0x10000;
		if (numReadPtr != NULL) {
		    *numReadPtr = numRead;
		}
		return Tcl_UniCharToUtf(uch, buffer);
	    }
	}
    }
    return 0;
}
#endif


/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */


/*
 *----------------------------------------------------------------------
 *
 * UtfToUniChar --
 *
 *	Wrapper to Tcl_UtfToUniChar() capable of dealing with
 *	UCS4 when compiled with TCL_UTF_MAX == 4.
 *	surrogate pairs when compiled with TCL_UTF_MAX == 3.
 *
 * Results:
 *	*chPtr is filled with the full unicode character, and the
 *	return value is the number of bytes from the UTF-8 string that
 *	were consumed.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

static int
#if TCL_UTF_MAX != 4
inline
#endif
UtfToUniChar(
    const char *src,
    int *chPtr)
{
    Tcl_UniChar ch = 0;
    Tcl_UniChar ch;
    int uch, len;

    len = TclUtfToUniChar(src, &ch);
    uch = ch;
#if TCL_UTF_MAX == 4
    if (!len) {
	len = TclUtfToUniChar(src + len, &ch);
#if TCL_UTF_MAX == 3
    if ((ch & 0xFC00) == 0xD800) {
	int len2 = TclUtfToUniChar(src + len, &ch);

	if (len2 && ((ch & 0xFC00) == 0xDC00)) {
	uch = ((uch & 0x3FF) << 10) + 0x10000 + (ch & 0x3FF);
	    uch = ((uch & 0x3FF) << 10) + 0x10000 + (ch & 0x3FF);
	    len += len2;
	}
    }
#endif
    *chPtr = uch;
    return len;
}

/*

    if (last < 0 || last >= stringPtr->numChars) {
	last = stringPtr->numChars - 1;
    }
    if (last < first) {
	TclNewObj(newObjPtr);
	return newObjPtr;
    }
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
    /* See: bug [11ae2be95dac9417] */
    if ((first > 0) && ((stringPtr->unicode[first] & 0xFC00) == 0xDC00)
	    && ((stringPtr->unicode[first-1] & 0xFC00) == 0xD800)) {
	++first;
    }
    if ((last + 1 < stringPtr->numChars)
	    && ((stringPtr->unicode[last+1] & 0xFC00) == 0xDC00)

		    numChars = precision;
		    Tcl_IncrRefCount(segment);
		    allocSegment = 1;
		}
	    }
	    break;
	case 'c': {
	    char buf[TCL_UTF_MAX] = "";
	    char buf[TCL_UTF_MAX*2];
	    int code, length;

	    if (TclGetIntFromObj(interp, segment, &code) != TCL_OK) {
		goto error;
	    }
	    length = Tcl_UniCharToUtf(code, buf);
#if TCL_UTF_MAX == 4
	    if (!length) {
		/* Special case for handling high surrogates. */
		length = Tcl_UniCharToUtf(-1, buf);
	    length = 0;
#if TCL_UTF_MAX == 3
	    if ((code > 0xFFFF) && (code <= 0x10FFFF)) {
		code -= 0x10000;
		length = Tcl_UniCharToUtf((code >> 10) | 0xD800, buf);
		code = (code & 0x3FF) | 0xDC00;
	    }
#endif
	    length += Tcl_UniCharToUtf(code, buf + length);
	    segment = Tcl_NewStringObj(buf, length);
	    Tcl_IncrRefCount(segment);
	    allocSegment = 1;
	    break;
	}

	case 'u':

Tcl_Obj *
TclStringReverse(
    Tcl_Obj *objPtr)
{
    String *stringPtr;
    Tcl_UniChar ch = 0;
#if TCL_UTF_MAX == 3
    int needFlip = 0;
#endif

    if (TclIsPureByteArray(objPtr)) {
	int numBytes;
	unsigned char *from = Tcl_GetByteArrayFromObj(objPtr, &numBytes);

	if (Tcl_IsShared(objPtr)) {
	    objPtr = Tcl_NewByteArrayObj(NULL, numBytes);
	}
	ReverseBytes(Tcl_GetByteArrayFromObj(objPtr, NULL), from, numBytes);
	return objPtr;
    }

    SetStringFromAny(NULL, objPtr);
    stringPtr = GET_STRING(objPtr);

    if (stringPtr->hasUnicode) {
	Tcl_UniChar *from = Tcl_GetUnicode(objPtr);
	Tcl_UniChar *src = from + stringPtr->numChars;
	Tcl_UniChar *to;
#if TCL_UTF_MAX == 4
	int needFlip = 0;
#endif

	if (Tcl_IsShared(objPtr)) {
	    /*
	     * Create a non-empty, pure unicode value, so we can coax
	     * Tcl_SetObjLength into growing the unicode rep buffer.
	     */

	    objPtr = Tcl_NewUnicodeObj(&ch, 1);
	    Tcl_SetObjLength(objPtr, stringPtr->numChars);
	    to = Tcl_GetUnicode(objPtr);
	    while (--src >= from) {
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
		ch = *src;
		if ((ch & 0xF800) == 0xD800) {
		    needFlip = 1;
		}
		*to++ = ch;
#else
		*to++ = *src;
#endif
	    }
	} else {
	    /*
	     * Reversing in place.
	     */

#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
	    to = src;
#endif
	    while (--src > from) {
		ch = *src;
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
		if ((ch & 0xF800) == 0xD800) {
		    needFlip = 1;
		}
#endif
		*src = *from;
		*from++ = ch;
	    }
	}
#if TCL_UTF_MAX == 4
#if TCL_UTF_MAX == 3
	if (needFlip) {
	    /*
	     * Flip back surrogate pairs. There might be a better way.
	     */

	    from = to - stringPtr->numChars;
	    while (--to >= from) {

		 * NOTE: We know that the from buffer is NUL-terminated. It's
		 * part of the contract for objPtr->bytes values. Thus, we can
		 * skip calling Tcl_UtfCharComplete() here.
		 */

		int bytesInChar = TclUtfToUniChar(from, &ch);

#if TCL_UTF_MAX == 4
		if (bytesInChar == 0) {
		    bytesInChar += TclUtfToUniChar(from, &ch);
#if TCL_UTF_MAX == 3
		if ((ch & 0xF800) == 0xD800) {
		    needFlip = 1;
		}
#endif
		ReverseBytes((unsigned char *)to, (unsigned char *)from,
			bytesInChar);
		to += bytesInChar;
		from += bytesInChar;
		bytesLeft -= bytesInChar;
		charCount++;
	    }

	    from = to = objPtr->bytes;
	    stringPtr->numChars = charCount;
	}
	/* Pass 2. Reverse all the bytes. */
	ReverseBytes((unsigned char *)to, (unsigned char *)from, numBytes);

#if TCL_UTF_MAX == 3
	if (needFlip) {
	    /* Pass 3. Flip back surrogate pairs. Might be a better way. */
	    numBytes = objPtr->length;
	    from = to = objPtr->bytes;
	    from += numBytes;	/* This is the end (The Doors, Jim Morrison) */
	    while (to < from) {
		Tcl_UniChar ch1, ch2;
		int len, len2;

		len = TclUtfToUniChar(to, &ch1);
	 	if (((ch1 & 0xFC00) == 0xDC00) &&
			(to + len + TCL_UTF_MAX <= from)) {
		    len2 = TclUtfToUniChar(to + len, &ch2);
		    if ((ch2 & 0xFC00) == 0xD800) {
			Tcl_UniCharToUtf(ch2, to);
			Tcl_UniCharToUtf(ch1, to + len);
			len += len2;
		    }
		}
		to += len;
	     }
	}
#endif
    }

    return objPtr;
}

/*
 *---------------------------------------------------------------------------

    Tcl_Obj *objPtr,
    const char *bytes,
    int numBytes,
    int numAppendChars)
{
    String *stringPtr = GET_STRING(objPtr);
    int needed, numOrigChars = 0;
    Tcl_UniChar *dst, unichar = 0;
    Tcl_UniChar *dst;

    if (stringPtr->hasUnicode) {
	numOrigChars = stringPtr->numChars;
    }
    if (numAppendChars == -1) {
	TclNumUtfChars(numAppendChars, bytes, numBytes);
    }

    stringPtr->hasUnicode = 1;
    if (bytes) {
	stringPtr->numChars = needed;
    } else {
	numAppendChars = 0;
    }
    for (dst=stringPtr->unicode + numOrigChars; numAppendChars-- > 0; dst++) {
	bytes += TclUtfToUniChar(bytes, &unichar);
	bytes += TclUtfToUniChar(bytes, dst);
	*dst = unichar;
    }
    *dst = 0;
}

/*
 *----------------------------------------------------------------------
 *

    int numChars)
{
    /*
     * Precondition: this is the "string" Tcl_ObjType.
     */

    int i, origLength, size = 0;
    char *dst, buf[TCL_UTF_MAX] = "";
    char *dst, buf[TCL_UTF_MAX];
    String *stringPtr = GET_STRING(objPtr);
#if TCL_UTF_MAX == 4
    int length;
#endif

    if (numChars < 0) {
	numChars = UnicodeLength(unicode);
    }

    if (numChars == 0) {
	return 0;

     */

    if (numChars <= (INT_MAX - size)/TCL_UTF_MAX
	    && stringPtr->allocated >= size + numChars * TCL_UTF_MAX) {
	goto copyBytes;
    }

#if TCL_UTF_MAX == 4
    length = -1;
    for (i = 0; i < numChars && size >= 0; i++) {
	length = Tcl_UniCharToUtf((int) unicode[i], buf);
	size += (unsigned int) length;
    }
    if (!length) {
	/* Special case for handling high surrogates. */
	size += (unsigned int) Tcl_UniCharToUtf(-1, buf);
    }
#else
    for (i = 0; i < numChars && size >= 0; i++) {
	size += (unsigned int) Tcl_UniCharToUtf((int) unicode[i], buf);
    }
#endif
    if (size < 0) {
	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
    }

    /*
     * Grow space if needed.
     */

    if (size > stringPtr->allocated) {
	GrowStringBuffer(objPtr, size, 1);
    }

  copyBytes:
    dst = objPtr->bytes + origLength;
#if TCL_UTF_MAX == 4
    length = -1;
    for (i = 0; i < numChars; i++) {
	length = Tcl_UniCharToUtf(unicode[i], dst);
	dst += length;
    }
    if (!length) {
	/* Special case for handling high surrogates. */
	dst += Tcl_UniCharToUtf(-1, dst);
    }
#else
    for (i = 0; i < numChars; i++) {
	dst += Tcl_UniCharToUtf(unicode[i], dst);
    }
#endif
    *dst = '\0';
    objPtr->length = dst - objPtr->bytes;
    return numChars;
}

/*
 *----------------------------------------------------------------------

    9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856,
    9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856, 9856,
    9856, 9856, 9856, 9856, 9856, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    1344, 1344, 1344, 1344, 9888, 1344, 1344, 9920, 3296, 9952, 9984, 10016,
    1344, 1344, 10048, 10080, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    1344, 1344, 1344, 10112, 10144, 1344, 10176, 1344, 10208, 10240, 10272,
    10304, 10336, 10368, 1344, 1344, 1344, 10400, 10432, 64, 10464, 10496,
    10528, 4736, 10560, 10592
    10528, 4736, 10560, 10592,
#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
    ,10624, 10656, 10688, 3296, 1344, 1344, 1344, 10720, 10752, 10784,
    10624, 10656, 10688, 3296, 1344, 1344, 1344, 10720, 10752, 10784,
    10816, 10848, 10880, 10912, 8032, 10944, 3296, 3296, 3296, 3296, 9216,
    1344, 10976, 11008, 1344, 11040, 11072, 11104, 11136, 1344, 11168,
    3296, 11200, 11232, 11264, 1344, 11296, 11328, 11360, 11392, 1344,
    11424, 1344, 11456, 11488, 11520, 3296, 3296, 1344, 1344, 1344, 1344,
    1344, 1344, 1344, 1344, 1344, 7776, 4704, 11552, 11584, 11616, 3296,
    3296, 11648, 11680, 11712, 11744, 4736, 11776, 3296, 11808, 11840,
    11872, 3296, 3296, 1344, 11904, 11936, 6880, 11968, 12000, 12032, 12064,

    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    15488
#endif /* TCL_UTF_MAX > 3 */
};

/*
 * The groupMap is indexed by combining the alternate page number with
 * the page offset and returns a group number that identifies a unique
 * set of character attributes.
 */

    13, 13, 13, 13, 13, 13, 13, 13, 13, 5, 7, 6, 7, 5, 6, 3, 5, 6, 3, 3,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 92, 92, 0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15,
    15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15,
    0, 0, 0, 4, 4, 7, 11, 14, 4, 4, 0, 14, 7, 7, 7, 7, 14, 14, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 14, 14, 0, 0
    0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 14, 14, 0, 0,
#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
    ,15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 0, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18,

    14, 14, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 15, 15, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15
#endif /* TCL_UTF_MAX > 3 */
};

/*
 * Each group represents a unique set of character attributes.  The attributes
 * are encoded into a 32-bit value as follows:
 *
 * Bits 0-4	Character category: see the constants listed below.

    -2750143, -976319, -2746047, 2763650, 2762882, -2759615, -2751679,
    -2760383, -2760127, -2768575, 1859714, -9044927, -10823615, -12158,
    -10830783, -10833599, -10832575, -10830015, -10817983, -10824127,
    -10818751, 237633, -12223, -10830527, -9058239, 237698, 9949314,
    18, 17, 10305, 10370, 10049, 10114, 8769, 8834
};

#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
#   define UNICODE_OUT_OF_RANGE(ch) (((ch) & 0x1FFFFF) >= 0x323C0)
#define UNICODE_OUT_OF_RANGE(ch) (((ch) & 0x1FFFFF) >= 0x323C0)
#else
#   define UNICODE_OUT_OF_RANGE(ch) (((ch) & 0x1F0000) != 0)
#endif

/*
 * The following constants are used to determine the category of a
 * Unicode character.
 */

enum {

#define GetDelta(info) ((info) >> 8)

/*
 * This macro extracts the information about a character from the
 * Unicode character tables.
 */

#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
#   define GetUniCharInfo(ch) (groups[groupMap[pageMap[((ch) & 0x1FFFFF) >> OFFSET_BITS] | ((ch) & ((1 << OFFSET_BITS)-1))]])
#define GetUniCharInfo(ch) (groups[groupMap[pageMap[((ch) & 0x1FFFFF) >> OFFSET_BITS] | ((ch) & ((1 << OFFSET_BITS)-1))]])
#else
#   define GetUniCharInfo(ch) (groups[groupMap[pageMap[((ch) & 0xFFFF) >> OFFSET_BITS] | ((ch) & ((1 << OFFSET_BITS)-1))]])
#endif

    4,4,4,4,4,
#else
    1,1,1,1,1,
#endif
    1,1,1,1,1,1,1,1,1,1,1
};

#if TCL_UTF_MAX == 3

static const unsigned char totalBytesExt[256] = {
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
    3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
    4,4,4,4,4,
    1,1,1,1,1,1,1,1,1,1,1
};

#endif

/*
 * Functions used only in this module.
 */

static int		UtfCount(int ch);
static int		Invalid(unsigned char *src);


    if (ch >= 0) {
	if (ch <= 0x7FF) {
	    buf[1] = (char) ((ch | 0x80) & 0xBF);
	    buf[0] = (char) ((ch >> 6) | 0xC0);
	    return 2;
	}
	if (ch <= 0xFFFF) {
#if TCL_UTF_MAX == 4
	    if ((ch & 0xF800) == 0xD800) {
		if (ch & 0x0400) {
		    /* Low surrogate */
		    if (((buf[0] & 0xF8) == 0xF0) && ((buf[1] & 0xC0) == 0x80)
			    && ((buf[2] & 0xCF) == 0)) {
			/* Previous Tcl_UniChar was a High surrogate, so combine */
			buf[3] = (char) ((ch & 0x3F) | 0x80);
			buf[2] |= (char) (((ch >> 6) & 0x0F) | 0x80);
			return 4;
		    }
		    /* Previous Tcl_UniChar was not a high surrogate, so just output */
		} else {
		    /* High surrogate */
		    ch += 0x40;
		    /* Fill buffer with specific 3-byte (invalid) byte combination,
		       so following low surrogate can recognize it and combine */
		    buf[2] = (char) ((ch << 4) & 0x30);
		    buf[1] = (char) (((ch >> 2) & 0x3F) | 0x80);
		    buf[0] = (char) (((ch >> 8) & 0x07) | 0xF0);
		    return 0;
		}
	    }
#endif
	    goto three;
	}

#if TCL_UTF_MAX > 3
	if (ch <= 0x10FFFF) {
	    buf[3] = (char) ((ch | 0x80) & 0xBF);
	    buf[2] = (char) (((ch >> 6) | 0x80) & 0xBF);
	    buf[1] = (char) (((ch >> 12) | 0x80) & 0xBF);
	    buf[0] = (char) ((ch >> 18) | 0xF0);
	    return 4;
	}
#endif
    }

    ch = 0xFFFD;
three:
    buf[2] = (char) ((ch | 0x80) & 0xBF);
    buf[1] = (char) (((ch >> 6) | 0x80) & 0xBF);
    buf[0] = (char) ((ch >> 12) | 0xE0);
    return 3;
}

#if TCL_UTF_MAX == 4
    else if (ch == -1) {
	if (((buf[0] & 0xF8) == 0xF0) && ((buf[1] & 0xC0) == 0x80)
		&& ((buf[2] & 0xCF) == 0)) {
	    ch = 0xD7C0 + ((buf[0] & 0x07) << 8) + ((buf[1] & 0x3F) << 2)
		    + ((buf[2] & 0x30) >> 4);
#if TCL_UTF_MAX == 3

int
TclUniCharToUtfExt(
    int ch,			/* The Tcl_UniChar to be stored in the
				 * buffer. */
    char *buf)			/* Buffer in which the UTF-8 representation of
				 * the Tcl_UniChar is stored. Buffer must be
				 * large enough to hold the UTF-8 character
				 * (at most 4 bytes). */
{
    if ((unsigned)(ch - 1) < (UNICODE_SELF - 1)) {
	buf[0] = (char) ch;
	return 1;
    }
    if (ch >= 0) {
	if (ch <= 0x7FF) {
	    buf[1] = (char) ((ch | 0x80) & 0xBF);
	    buf[0] = (char) ((ch >> 6) | 0xC0);
	    return 2;
	}
	if (ch <= 0xFFFF) {
	    goto three;
	}
	if (ch <= 0x10FFFF) {
	    buf[3] = (char) ((ch | 0x80) & 0xBF);
	    buf[2] = (char) (((ch >> 6) | 0x80) & 0xBF);
	    buf[1] = (char) (((ch >> 12) | 0x80) & 0xBF);
	    buf[0] = (char) ((ch >> 18) | 0xF0);
	    return 4;
    }
	}
#endif
    }

    ch = 0xFFFD;
three:
    buf[2] = (char) ((ch | 0x80) & 0xBF);
    buf[1] = (char) (((ch >> 6) | 0x80) & 0xBF);
    buf[0] = (char) ((ch >> 12) | 0xE0);
    return 3;
}

#endif

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UniCharToUtfDString --
 *
 *	Convert the given Unicode string to UTF-8.