From 1b1bab45a700c36f964cdbd1a79045e914e0aa96 Mon Sep 17 00:00:00 2001 From: hershey Date: Tue, 15 Jun 1999 22:06:17 +0000 Subject: beefed up the string object tests --- generic/tclStringObj.c | 140 ++++++++++++++++++++++-------------------- generic/tclTestObj.c | 17 +++++- tests/stringObj.test | 162 ++++++++++++++++++++++++++++--------------------- 3 files changed, 180 insertions(+), 139 deletions(-) diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c index 09cfc4c..e00b02a 100644 --- a/generic/tclStringObj.c +++ b/generic/tclStringObj.c @@ -1,29 +1,31 @@ /* * tclStringObj.c -- * - * This file contains procedures that implement string operations - * on Tcl objects. To do this efficiently (i.e. to allow many - * appends to be done to an object without constantly reallocating - * the space for the string representation) we overallocate the - * space for the string and use the internal representation to keep - * track of the extra space. Objects with this internal - * representation are called "expandable string objects". - * - * Since some string operations work with UTF strings and others require Unicode - format, the string obeject type stores one or both formats. If the object is - created with a Unicode string, then UTF form is not stored until it is - required by a string operation. The string object always stores the number of - characters, so if the object is created with a UTF string, we automatically - convert it to unicode (as this costs little more than - -A Unicode string - * is an internationalized string. Conceptually, a Unicode string is an - * array of 16-bit quantities organized as a sequence of properly formed - * UTF-8 characters. There is a one-to-one map between Unicode and UTF - * characters. The Unicode ojbect is opitmized for the case where each UTF - * char in a string is only one byte. In this case, we store the value of - * numChars, but we don't copy the bytes to the unicodeObj->chars. Before - * accessing obj->chars, check if unicodeObj->numChars == obj->length. + * This file contains procedures that implement string operations on Tcl + * objects. Some string operations work with UTF strings and others + * require Unicode format. Functions that require knowledge of the width + * of each character, such as indexing, operate on Unicode data. + * + * A Unicode string is an internationalized string. Conceptually, a + * Unicode string is an array of 16-bit quantities organized as a sequence + * of properly formed UTF-8 characters. There is a one-to-one map between + * Unicode and UTF characters. Because Unicode characters have a fixed + * width, operations such as indexing operate on Unicode data. The String + * ojbect is opitmized for the case where each UTF char in a string is + * only one byte. In this case, we store the value of numChars, but we + * don't store the Unicode data (unless Tcl_GetUnicode is explicitly + * called). + * + * The String object type stores one or both formats. The default + * behavior is to store UTF. Once Unicode is calculated by a function, it + * is stored in the internal rep for future access (without an additional + * O(n) cost). + * + * To allow many appends to be done to an object without constantly + * reallocating the space for the string or Unicode representation, we + * allocate double the space for the string or Unicode and use the + * internal representation to keep track of how much space is used + * vs. allocated. * * Copyright (c) 1995-1997 Sun Microsystems, Inc. * Copyright (c) 1999 by Scriptics Corporation. @@ -31,8 +33,7 @@ A Unicode string * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclStringObj.c,v 1.9 1999/06/15 03:14:44 hershey Exp $ - */ + * RCS: @(#) $Id: tclStringObj.c,v 1.10 1999/06/15 22:06:17 hershey Exp $ */ #include "tclInt.h" @@ -80,7 +81,7 @@ Tcl_ObjType tclStringType = { * shrinking of the UTF and Unicode reps of the String object with fewer * mallocs. To optimize string length and indexing operations, this * structure also stores the number of characters (same of UTF and Unicode!) - * once that value has been computede. + * once that value has been computed. */ typedef struct String { @@ -321,12 +322,6 @@ Tcl_GetCharLength(objPtr) SetStringFromAny(NULL, objPtr); stringPtr = GET_STRING(objPtr); -/* if (objPtr->bytes == NULL) { */ -/* printf("called Tcl_GetCharLength with unicode str.\n"); */ -/* } else { */ -/* printf("called Tcl_GetCharLength with str = %s\n", objPtr->bytes); */ -/* } */ - /* * If numChars is unknown, then calculate the number of characaters * while populating the Unicode string. @@ -395,12 +390,6 @@ Tcl_GetUniChar(objPtr, index) SetStringFromAny(NULL, objPtr); stringPtr = GET_STRING(objPtr); -/* if (objPtr->bytes == NULL) { */ -/* printf("called Tcl_GetUniChar with unicode str.\n"); */ -/* } else { */ -/* printf("called Tcl_GetUniChar with str = %s\n", objPtr->bytes); */ -/* } */ - if (stringPtr->numChars == -1) { /* @@ -419,7 +408,6 @@ Tcl_GetUniChar(objPtr, index) stringPtr = GET_STRING(objPtr); } if (stringPtr->uallocated == 0) { - char *bytes; /* * All of the characters in the Utf string are 1 byte chars, @@ -427,8 +415,7 @@ Tcl_GetUniChar(objPtr, index) * and convert the index'th byte to a Unicode character. */ - bytes = Tcl_GetString(objPtr); - Tcl_UtfToUniChar(&bytes[index], &unichar); + Tcl_UtfToUniChar(&objPtr->bytes[index], &unichar); } else { unichar = stringPtr->unicode[index]; } @@ -463,12 +450,6 @@ Tcl_GetUnicode(objPtr) SetStringFromAny(NULL, objPtr); stringPtr = GET_STRING(objPtr); -/* if (objPtr->bytes == NULL) { */ -/* printf("called Tcl_GetUnicode with unicode str.\n"); */ -/* } else { */ -/* printf("called Tcl_GetUnicode with str = %s\n", objPtr->bytes); */ -/* } */ - if ((stringPtr->numChars == -1) || (stringPtr->uallocated == 0)) { /* @@ -557,8 +538,9 @@ Tcl_GetRange(objPtr, first, last) * can set it's numChars field. */ -/* stringPtr = GET_STRING(newObjPtr); */ -/* stringPtr->numChars = last-first+1; */ + SetStringFromAny(NULL, newObjPtr); + stringPtr = GET_STRING(newObjPtr); + stringPtr->numChars = last-first+1; } else { newObjPtr = Tcl_NewUnicodeObj(stringPtr->unicode + first, last-first+1); @@ -622,7 +604,6 @@ Tcl_SetStringObj(objPtr, bytes, length) length = (bytes? strlen(bytes) : 0); } TclInitStringRep(objPtr, bytes, length); -/* printf("called Tcl_SetStringObj with str = %s\n", objPtr->bytes); */ } /* @@ -684,7 +665,6 @@ Tcl_SetObjLength(objPtr, length) if (objPtr->bytes != NULL) { memcpy((VOID *) new, (VOID *) objPtr->bytes, (size_t) objPtr->length); -/* new[objPtr->length] = 0; */ Tcl_InvalidateStringRep(objPtr); } objPtr->bytes = new; @@ -891,7 +871,7 @@ Tcl_AppendObjToObj(objPtr, appendObjPtr) Tcl_Obj *appendObjPtr; /* Object to append. */ { String *stringPtr; - int length; + int length, numChars, allOneByteChars; char *bytes; SetStringFromAny(NULL, objPtr); @@ -931,11 +911,28 @@ Tcl_AppendObjToObj(objPtr, appendObjPtr) } /* - * Append to objPtr's UTF string rep. + * Append to objPtr's UTF string rep. If we know the number of + * characters in both objects before appending, then set the combined + * number of characters in the final (appended-to) object. */ + allOneByteChars = 0; + numChars = stringPtr->numChars; + if ((numChars >= 0) && (appendObjPtr->typePtr == &tclStringType)) { + stringPtr = GET_STRING(appendObjPtr); + if (stringPtr->numChars >= 0) { + numChars += stringPtr->numChars; + allOneByteChars = 1; + } + } + bytes = Tcl_GetStringFromObj(appendObjPtr, &length); AppendUtfToUtfRep(objPtr, bytes, length); + + if (allOneByteChars) { + stringPtr = GET_STRING(objPtr); + stringPtr->numChars = numChars; + } } /* @@ -973,7 +970,10 @@ AppendUnicodeToUnicodeRep(objPtr, unicode, appendNumChars) stringPtr = GET_STRING(objPtr); /* - * Make the buffer big enough for the result. + * If not enough space has been allocated for the unicode rep, + * reallocate the internal rep object with double the amount of + * space needed, so the unicode string can grow without being + * reallocated. */ numChars = stringPtr->numChars + appendNumChars; @@ -1124,14 +1124,12 @@ AppendUtfToUtfRep(objPtr, bytes, numBytes) /* * There isn't currently enough space in the string - * representation so allocate additional space. If the current - * string representation isn't empty (i.e. it looks like we're - * doing a series of appends) then overallocate the space so - * that we won't have to do as much reallocation in the future. + * representation so allocate additional space. Overallocate the + * space by doubling it so that we won't have to do as much + * reallocation in the future. */ - Tcl_SetObjLength(objPtr, - (oldLength == 0) ? newLength : 2*newLength); + Tcl_SetObjLength(objPtr, 2*newLength); } else { /* @@ -1313,13 +1311,21 @@ FillUnicodeRep(objPtr) if (uallocated > stringPtr->uallocated) { /* - * If not enought space has been allocated for the unicode rep, - * reallocate the internal rep object with double the amount of - * space needed, so the unicode string can grow without being - * reallocated. + * If not enough space has been allocated for the unicode rep, + * reallocate the internal rep object. + */ + + /* + * There isn't currently enough space in the Unicode + * representation so allocate additional space. If the current + * Unicode representation isn't empty (i.e. it looks like we've + * done some appends) then overallocate the space so + * that we won't have to do as much reallocation in the future. */ - uallocated *= 2; + if (stringPtr->uallocated > 0) { + uallocated *= 2; + } stringPtr = (String *) ckrealloc((char*) stringPtr, STRING_SIZE(uallocated)); stringPtr->uallocated = uallocated; @@ -1359,8 +1365,7 @@ FillUnicodeRep(objPtr) static void DupStringInternalRep(srcPtr, copyPtr) register Tcl_Obj *srcPtr; /* Object with internal rep to copy. Must - * have an internal representation of type - * "expandable string". */ + * have an internal rep of type "String". */ register Tcl_Obj *copyPtr; /* Object with internal rep to set. Must * not currently have an internal rep.*/ { @@ -1388,6 +1393,7 @@ DupStringInternalRep(srcPtr, copyPtr) copyStringPtr->unicode[srcStringPtr->numChars] = 0; } copyStringPtr->numChars = srcStringPtr->numChars; + copyStringPtr->allocated = srcStringPtr->allocated; /* * Tricky point: the string value was copied by generic object diff --git a/generic/tclTestObj.c b/generic/tclTestObj.c index 259fcbd..2733a8c 100644 --- a/generic/tclTestObj.c +++ b/generic/tclTestObj.c @@ -12,7 +12,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclTestObj.c,v 1.5 1999/06/15 03:14:45 hershey Exp $ + * RCS: @(#) $Id: tclTestObj.c,v 1.6 1999/06/15 22:06:17 hershey Exp $ */ #include "tclInt.h" @@ -883,7 +883,7 @@ TeststringobjCmd(clientData, interp, objc, objv) TestString *strPtr; static char *options[] = { "append", "appendstrings", "get", "get2", "length", "length2", - "set", "set2", "setlength", (char *) NULL + "set", "set2", "setlength", "ualloc", (char *) NULL }; if (objc < 3) { @@ -1032,6 +1032,19 @@ TeststringobjCmd(clientData, interp, objc, objv) Tcl_SetObjLength(varPtr[varIndex], length); } break; + case 9: /* ualloc */ + if (objc != 3) { + goto wrongNumArgs; + } + if (varPtr[varIndex] != NULL) { + strPtr = (TestString *) + (varPtr[varIndex])->internalRep.otherValuePtr; + length = (int) strPtr->uallocated; + } else { + length = -1; + } + Tcl_SetIntObj(Tcl_GetObjResult(interp), length); + break; } return TCL_OK; diff --git a/tests/stringObj.test b/tests/stringObj.test index 49af6e4..3ea2573 100644 --- a/tests/stringObj.test +++ b/tests/stringObj.test @@ -12,7 +12,7 @@ # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # -# RCS: @(#) $Id: stringObj.test,v 1.5 1999/06/15 03:22:31 hershey Exp $ +# RCS: @(#) $Id: stringObj.test,v 1.6 1999/06/15 22:06:18 hershey Exp $ if {[lsearch [namespace children] ::tcltest] == -1} { source [file join [pwd] [file dirname [info script]] defs.tcl] @@ -165,20 +165,30 @@ test stringObj-6.8 {Tcl_AppendStringsToObj procedure, object totally empty} { list [teststringobj length2 1] [teststringobj get 1] } {0 {}} -test stringObj-7.1 {ConvertToStringType procedure} { +test stringObj-7.1 {SetStringFromAny procedure} { testobj freeallvars teststringobj set2 1 [list a b] teststringobj append 1 x -1 list [teststringobj length 1] [teststringobj length2 1] \ [teststringobj get 1] } {4 8 {a bx}} -test stringObj-7.2 {ConvertToStringType procedure, null object} { +test stringObj-7.2 {SetStringFromAny procedure, null object} { testobj freeallvars testobj newobj 1 teststringobj appendstrings 1 {} list [teststringobj length 1] [teststringobj length2 1] \ [teststringobj get 1] } {0 0 {}} +test stringObj-7.3 {SetStringFromAny called with non-string obj} { + set x 2345 + list [incr x] [testobj objtype $x] [string index $x end] \ + [testobj objtype $x] +} {2346 int 6 string} +test stringObj-7.4 {SetStringFromAny called with string obj} { + set x "abcdef" + list [string length $x] [testobj objtype $x] \ + [string length $x] [testobj objtype $x] +} {6 string 6 string} test stringObj-8.1 {DupStringInternalRep procedure} { testobj freeallvars @@ -186,31 +196,32 @@ test stringObj-8.1 {DupStringInternalRep procedure} { teststringobj append 1 abcde -1 testobj duplicate 1 2 list [teststringobj length 1] [teststringobj length2 1] \ + [teststringobj ualloc 1] [teststringobj get 1] \ [teststringobj length 2] [teststringobj length2 2] \ - [teststringobj get 2] -} {5 10 5 5 abcde} -test string-8.2 {DupUnicodeInternalRep, mixed width chars} {testobj} { + [teststringobj ualloc 2] [teststringobj get 2] +} {5 10 0 abcde 5 5 0 abcde} +test stringObj-8.2 {DupUnicodeInternalRep, mixed width chars} { set x abcï¿®ghi string length $x set y $x list [testobj objtype $x] [testobj objtype $y] [append x "®¿ï"] \ [set y] [testobj objtype $x] [testobj objtype $y] } {string string abcï¿®ghi®¿ï abcï¿®ghi string string} -test string-8.3 {DupUnicodeInternalRep, mixed width chars} {testobj} { +test stringObj-8.3 {DupUnicodeInternalRep, mixed width chars} { set x abcï¿®ghi set y $x string length $x list [testobj objtype $x] [testobj objtype $y] [append x "®¿ï"] \ [set y] [testobj objtype $x] [testobj objtype $y] } {string string abcï¿®ghi®¿ï abcï¿®ghi string string} -test string-8.4 {DupUnicodeInternalRep, all byte-size chars} {testobj} { +test stringObj-8.4 {DupUnicodeInternalRep, all byte-size chars} { set x abcdefghi string length $x set y $x list [testobj objtype $x] [testobj objtype $y] [append x jkl] \ [set y] [testobj objtype $x] [testobj objtype $y] } {string string abcdefghijkl abcdefghi string string} -test string-8.5 {DupUnicodeInternalRep, all byte-size chars} {testobj} { +test stringObj-8.5 {DupUnicodeInternalRep, all byte-size chars} { set x abcdefghi set y $x string length $x @@ -218,14 +229,14 @@ test string-8.5 {DupUnicodeInternalRep, all byte-size chars} {testobj} { [set y] [testobj objtype $x] [testobj objtype $y] } {string string abcdefghijkl abcdefghi string string} -test string-9.1 {TclAppendObjToObj, mixed src & dest} {testobj} { +test stringObj-9.1 {TclAppendObjToObj, mixed src & dest} { set x abcï¿®ghi set y ®¿ï string length $x list [testobj objtype $x] [testobj objtype $y] [append x $y] \ [set y] [testobj objtype $x] [testobj objtype $y] -} {string none abcï¿®ghi®¿ï ®¿ï string string} -test string-9.2 {TclAppendObjToObj, mixed src & dest} {testobj} { +} {string none abcï¿®ghi®¿ï ®¿ï string none} +test stringObj-9.2 {TclAppendObjToObj, mixed src & dest} { set x abcï¿®ghi string length $x list [testobj objtype $x] [append x $x] [testobj objtype $x] \ @@ -233,54 +244,54 @@ test string-9.2 {TclAppendObjToObj, mixed src & dest} {testobj} { } {string abcï¿®ghiabcï¿®ghi string\ abcï¿®ghiabcï¿®ghiabcï¿®ghiabcï¿®ghi\ string} -test string-9.3 {TclAppendObjToObj, mixed src & 1-byte dest} {testobj} { +test stringObj-9.3 {TclAppendObjToObj, mixed src & 1-byte dest} { set x abcdefghi set y ®¿ï string length $x list [testobj objtype $x] [testobj objtype $y] [append x $y] \ [set y] [testobj objtype $x] [testobj objtype $y] -} {string none abcdefghi®¿ï ®¿ï string string} -test string-9.4 {TclAppendObjToObj, 1-byte src & dest} {testobj} { +} {string none abcdefghi®¿ï ®¿ï string none} +test stringObj-9.4 {TclAppendObjToObj, 1-byte src & dest} { set x abcdefghi set y jkl string length $x list [testobj objtype $x] [testobj objtype $y] [append x $y] \ [set y] [testobj objtype $x] [testobj objtype $y] -} {string none abcdefghijkl jkl string string} -test string-9.5 {TclAppendObjToObj, 1-byte src & dest} {testobj} { +} {string none abcdefghijkl jkl string none} +test stringObj-9.5 {TclAppendObjToObj, 1-byte src & dest} { set x abcdefghi string length $x list [testobj objtype $x] [append x $x] [testobj objtype $x] \ [append x $x] [testobj objtype $x] } {string abcdefghiabcdefghi string abcdefghiabcdefghiabcdefghiabcdefghi\ string} -test string-9.6 {TclAppendObjToObj, 1-byte src & mixed dest} {testobj} { +test stringObj-9.6 {TclAppendObjToObj, 1-byte src & mixed dest} { set x abcï¿®ghi set y jkl string length $x list [testobj objtype $x] [testobj objtype $y] [append x $y] \ [set y] [testobj objtype $x] [testobj objtype $y] -} {string none abcï¿®ghijkl jkl string string} -test string-9.7 {TclAppendObjToObj, integer src & dest} {testobj} { +} {string none abcï¿®ghijkl jkl string none} +test stringObj-9.7 {TclAppendObjToObj, integer src & dest} { set x [expr {4 * 5}] set y [expr {4 + 5}] list [testobj objtype $x] [testobj objtype $y] [append x $y] \ [testobj objtype $x] [append x $y] [testobj objtype $x] \ [testobj objtype $y] } {int int 209 string 2099 string int} -test string-9.8 {TclAppendObjToObj, integer src & dest} {testobj} { +test stringObj-9.8 {TclAppendObjToObj, integer src & dest} { set x [expr {4 * 5}] list [testobj objtype $x] [append x $x] [testobj objtype $x] \ [append x $x] [testobj objtype $x] } {int 2020 string 20202020 string} -test string-9.9 {TclAppendObjToObj, integer src & 1-byte dest} {testobj} { +test stringObj-9.9 {TclAppendObjToObj, integer src & 1-byte dest} { set x abcdefghi set y [expr {4 + 5}] string length $x list [testobj objtype $x] [testobj objtype $y] [append x $y] \ [set y] [testobj objtype $x] [testobj objtype $y] } {string int abcdefghi9 9 string int} -test string-9.10 {TclAppendObjToObj, integer src & mixed dest} {testobj} { +test stringObj-9.10 {TclAppendObjToObj, integer src & mixed dest} { set x abcï¿®ghi set y [expr {4 + 5}] string length $x @@ -288,71 +299,82 @@ test string-9.10 {TclAppendObjToObj, integer src & mixed dest} {testobj} { [set y] [testobj objtype $x] [testobj objtype $y] } {string int abcï¿®ghi9 9 string int} -test string-10.1 {SetStringFromAny called with non-string obj} {testobj} { - set x 2345 - list [incr x] [testobj objtype $x] [string index $x end] \ - [testobj objtype $x] -} {2346 int 6 string} -test string-10.2 {SetStringFromAny called with string obj} {testobj} { +test stringObj-10.1 {Tcl_GetRange with all byte-size chars} { set x "abcdef" - list [string length $x] [testobj objtype $x] \ - [string length $x] [testobj objtype $x] -} {6 string 6 string} + list [testobj objtype $x] [set y [string range $x 1 end-1]] \ + [testobj objtype $x] [testobj objtype $y] +} {none bcde string string} +test stringObj-10.2 {Tcl_GetRange with some mixed width chars} { + set x "abcïïdef" + list [testobj objtype $x] [set y [string range $x 1 end-1]] \ + [testobj objtype $x] [testobj objtype $y] +} {none bcïïde string string} +test stringObj-10.3 {Tcl_GetRange with some mixed width chars} { + set x "abcïïdef" + string length $x + list [testobj objtype $x] [set y [string range $x 1 end-1]] \ + [testobj objtype $x] [testobj objtype $y] +} {string bcïïde string string} +test stringObj-10.4 {Tcl_GetRange with some mixed width chars} { + set a "ïa¿b®cï¿d®" + set result [list] + while {[string length $a] > 0} { + set a [string range $a 1 end-1] + lappend result $a + } + set result +} {a¿b®cï¿d ¿b®cï¿ b®cï ®c {}} -test string-11.1 {UpdateStringOfString} {testobj} { +test stringObj-11.1 {UpdateStringOfString} { set x 2345 list [string index $x end] [testobj objtype $x] [incr x] \ [testobj objtype $x] } {5 string 2346 int} -test string-12.1 {TclGetUniCharFromObj with byte-size chars} { - string index "abcdefghi" 0 -} "a" -test string-12.2 {TclGetUniCharFromObj with byte-size chars} { - string index "abcdefghi" 3 -} "d" -test string-12.3 {TclGetUniCharFromObj with byte-size chars} { - string index "abcdefghi" end -} "i" -test string-12.4 {TclGetUniCharFromObj with mixed width chars} { +test stringObj-12.1 {Tcl_GetUniChar with byte-size chars} { + set x "abcdefghi" + list [string index $x 0] [string index $x 1] +} {a b} +test stringObj-12.2 {Tcl_GetUniChar with byte-size chars} { + set x "abcdefghi" + list [string index $x 3] [string index $x end] +} {d i} +test stringObj-12.3 {Tcl_GetUniChar with byte-size chars} { + set x "abcdefghi" + list [string index $x end] [string index $x end-1] +} {i h} +test stringObj-12.4 {Tcl_GetUniChar with mixed width chars} { string index "ïa¿b®c®¿dï" 0 } "ï" -test string-12.5 {TclGetUniCharFromObj} { - string index "ïa¿b®c®¿dï" 4 -} "®" -test string-12.6 {TclGetUniCharFromObj} { +test stringObj-12.5 {Tcl_GetUniChar} { + set x "ïa¿b®c®¿dï" + list [string index $x 4] [string index $x 0] +} {® ï} +test stringObj-12.6 {Tcl_GetUniChar} { string index "ïa¿b®cï¿d®" end } "®" -test string-13.1 {TclGetUnicodeLengthFromObj with byte-size chars} { - string length "" -} 0 -test string-13.2 {TclGetUnicodeLengthFromObj with byte-size chars} { +test stringObj-13.1 {Tcl_GetCharLength with byte-size chars} { + set a "" + list [string length $a] [string length $a] +} {0 0} +test stringObj-13.2 {Tcl_GetCharLength with byte-size chars} { string length "a" } 1 -test string-13.3 {TclGetUnicodeLengthFromObj with byte-size chars} { - string length "abcdef" -} 6 -test string-13.4 {TclGetUnicodeLengthFromObj with mixed width chars} { +test stringObj-13.3 {Tcl_GetCharLength with byte-size chars} { + set a "abcdef" + list [string length $a] [string length $a] +} {6 6} +test stringObj-13.4 {Tcl_GetCharLength with mixed width chars} { string length "®" } 1 -test string-13.5 {TclGetUnicodeLengthFromObj with mixed width chars} { +test stringObj-13.5 {Tcl_GetCharLength with mixed width chars} { string length "￮￮" } 6 -test string-13.6 {TclGetUnicodeLengthFromObj with mixed width chars} { - string length "ïa¿b®cï¿d®" -} 10 - -test string-14.1 {TclGetRangeFromObj with all byte-size chars} {testobj} { - set x "abcdef" - list [testobj objtype $x] [set y [string range $x 1 end-1]] \ - [testobj objtype $x] [testobj objtype $y] -} {none bcde string none} -test string-14.2 {TclGetRangeFromObj with some mixed width chars} {testobj} { - set x "abcïïdef" - list [testobj objtype $x] [set y [string range $x 1 end-1]] \ - [testobj objtype $x] [testobj objtype $y] -} {none bcïïde string string} +test stringObj-13.6 {Tcl_GetCharLength with mixed width chars} { + set a "ïa¿b®cï¿d®" + list [string length $a] [string length $a] +} {10 10} testobj freeallvars -- cgit v0.12