diff options
Diffstat (limited to 'generic/tclUtf.c')
| -rw-r--r-- | generic/tclUtf.c | 881 |
1 files changed, 428 insertions, 453 deletions
diff --git a/generic/tclUtf.c b/generic/tclUtf.c index f0d08e7..b6da7c3 100644 --- a/generic/tclUtf.c +++ b/generic/tclUtf.c @@ -5,8 +5,8 @@ * * Copyright (c) 1997-1998 Sun Microsystems, Inc. * - * See the file "license.terms" for information on usage and redistribution of - * this file, and for a DISCLAIMER OF ALL WARRANTIES. + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. */ #include "tclInt.h" @@ -18,48 +18,48 @@ #include "tclUniData.c" /* - * The following macros are used for fast character category tests. The x_BITS - * values are shifted right by the category value to determine whether the - * given category is included in the set. + * The following macros are used for fast character category tests. The + * x_BITS values are shifted right by the category value to determine whether + * the given category is included in the set. */ #define ALPHA_BITS ((1 << UPPERCASE_LETTER) | (1 << LOWERCASE_LETTER) \ - | (1 << TITLECASE_LETTER) | (1 << MODIFIER_LETTER) | (1<<OTHER_LETTER)) + | (1 << TITLECASE_LETTER) | (1 << MODIFIER_LETTER) | (1 << OTHER_LETTER)) #define CONTROL_BITS ((1 << CONTROL) | (1 << FORMAT) | (1 << PRIVATE_USE)) #define DIGIT_BITS (1 << DECIMAL_DIGIT_NUMBER) #define SPACE_BITS ((1 << SPACE_SEPARATOR) | (1 << LINE_SEPARATOR) \ - | (1 << PARAGRAPH_SEPARATOR)) + | (1 << PARAGRAPH_SEPARATOR)) #define WORD_BITS (ALPHA_BITS | DIGIT_BITS | (1 << CONNECTOR_PUNCTUATION)) #define PUNCT_BITS ((1 << CONNECTOR_PUNCTUATION) | \ - (1 << DASH_PUNCTUATION) | (1 << OPEN_PUNCTUATION) | \ - (1 << CLOSE_PUNCTUATION) | (1 << INITIAL_QUOTE_PUNCTUATION) | \ - (1 << FINAL_QUOTE_PUNCTUATION) | (1 << OTHER_PUNCTUATION)) + (1 << DASH_PUNCTUATION) | (1 << OPEN_PUNCTUATION) | \ + (1 << CLOSE_PUNCTUATION) | (1 << INITIAL_QUOTE_PUNCTUATION) | \ + (1 << FINAL_QUOTE_PUNCTUATION) | (1 << OTHER_PUNCTUATION)) #define GRAPH_BITS (WORD_BITS | PUNCT_BITS | \ - (1 << NON_SPACING_MARK) | (1 << ENCLOSING_MARK) | \ - (1 << COMBINING_SPACING_MARK) | (1 << LETTER_NUMBER) | \ - (1 << OTHER_NUMBER) | \ - (1 << MATH_SYMBOL) | (1 << CURRENCY_SYMBOL) | \ - (1 << MODIFIER_SYMBOL) | (1 << OTHER_SYMBOL)) + (1 << NON_SPACING_MARK) | (1 << ENCLOSING_MARK) | \ + (1 << COMBINING_SPACING_MARK) | (1 << LETTER_NUMBER) | \ + (1 << OTHER_NUMBER) | \ + (1 << MATH_SYMBOL) | (1 << CURRENCY_SYMBOL) | \ + (1 << MODIFIER_SYMBOL) | (1 << OTHER_SYMBOL)) /* - * Unicode characters less than this value are represented by themselves in - * UTF-8 strings. + * Unicode characters less than this value are represented by themselves + * in UTF-8 strings. */ #define UNICODE_SELF 0x80 /* - * The following structures are used when mapping between Unicode (UCS-2) and - * UTF-8. + * The following structures are used when mapping between Unicode (UCS-2) + * and UTF-8. */ -static const unsigned char totalBytes[256] = { +static CONST unsigned char totalBytes[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, @@ -86,10 +86,11 @@ static const unsigned char totalBytes[256] = { }; /* - * Functions used only in this module. + * Procedures used only in this module. */ -static int UtfCount(int ch); +static int UtfCount _ANSI_ARGS_((int ch)); + /* *--------------------------------------------------------------------------- @@ -108,8 +109,8 @@ static int UtfCount(int ch); */ INLINE static int -UtfCount( - int ch) /* The Tcl_UniChar whose size is returned. */ +UtfCount(ch) + int ch; /* The Tcl_UniChar whose size is returned. */ { if ((ch > 0) && (ch < UNICODE_SELF)) { return 1; @@ -140,11 +141,11 @@ UtfCount( * Tcl_UniCharToUtf -- * * Store the given Tcl_UniChar as a sequence of UTF-8 bytes in the - * provided buffer. Equivalent to Plan 9 runetochar(). + * provided buffer. Equivalent to Plan 9 runetochar(). * * Results: - * The return values is the number of bytes in the buffer that were - * consumed. + * The return values is the number of bytes in the buffer that + * were consumed. * * Side effects: * None. @@ -153,55 +154,55 @@ UtfCount( */ INLINE int -Tcl_UniCharToUtf( - int ch, /* The Tcl_UniChar to be stored in the +Tcl_UniCharToUtf(ch, str) + 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 + char *str; /* 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 TCL_UTF_MAX bytes). */ { if ((ch > 0) && (ch < UNICODE_SELF)) { - buf[0] = (char) ch; + str[0] = (char) ch; return 1; } if (ch >= 0) { if (ch <= 0x7FF) { - buf[1] = (char) ((ch | 0x80) & 0xBF); - buf[0] = (char) ((ch >> 6) | 0xC0); + str[1] = (char) ((ch | 0x80) & 0xBF); + str[0] = (char) ((ch >> 6) | 0xC0); return 2; } if (ch <= 0xFFFF) { three: - buf[2] = (char) ((ch | 0x80) & 0xBF); - buf[1] = (char) (((ch >> 6) | 0x80) & 0xBF); - buf[0] = (char) ((ch >> 12) | 0xE0); + str[2] = (char) ((ch | 0x80) & 0xBF); + str[1] = (char) (((ch >> 6) | 0x80) & 0xBF); + str[0] = (char) ((ch >> 12) | 0xE0); return 3; } #if TCL_UTF_MAX > 3 if (ch <= 0x1FFFFF) { - 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); + str[3] = (char) ((ch | 0x80) & 0xBF); + str[2] = (char) (((ch >> 6) | 0x80) & 0xBF); + str[1] = (char) (((ch >> 12) | 0x80) & 0xBF); + str[0] = (char) ((ch >> 18) | 0xF0); return 4; } if (ch <= 0x3FFFFFF) { - buf[4] = (char) ((ch | 0x80) & 0xBF); - buf[3] = (char) (((ch >> 6) | 0x80) & 0xBF); - buf[2] = (char) (((ch >> 12) | 0x80) & 0xBF); - buf[1] = (char) (((ch >> 18) | 0x80) & 0xBF); - buf[0] = (char) ((ch >> 24) | 0xF8); + str[4] = (char) ((ch | 0x80) & 0xBF); + str[3] = (char) (((ch >> 6) | 0x80) & 0xBF); + str[2] = (char) (((ch >> 12) | 0x80) & 0xBF); + str[1] = (char) (((ch >> 18) | 0x80) & 0xBF); + str[0] = (char) ((ch >> 24) | 0xF8); return 5; } if (ch <= 0x7FFFFFFF) { - buf[5] = (char) ((ch | 0x80) & 0xBF); - buf[4] = (char) (((ch >> 6) | 0x80) & 0xBF); - buf[3] = (char) (((ch >> 12) | 0x80) & 0xBF); - buf[2] = (char) (((ch >> 18) | 0x80) & 0xBF); - buf[1] = (char) (((ch >> 24) | 0x80) & 0xBF); - buf[0] = (char) ((ch >> 30) | 0xFC); + str[5] = (char) ((ch | 0x80) & 0xBF); + str[4] = (char) (((ch >> 6) | 0x80) & 0xBF); + str[3] = (char) (((ch >> 12) | 0x80) & 0xBF); + str[2] = (char) (((ch >> 18) | 0x80) & 0xBF); + str[1] = (char) (((ch >> 24) | 0x80) & 0xBF); + str[0] = (char) ((ch >> 30) | 0xFC); return 6; } #endif @@ -220,8 +221,8 @@ Tcl_UniCharToUtf( * * Results: * The return value is a pointer to the UTF-8 representation of the - * Unicode string. Storage for the return value is appended to the end of - * dsPtr. + * Unicode string. Storage for the return value is appended to the + * end of dsPtr. * * Side effects: * None. @@ -230,14 +231,15 @@ Tcl_UniCharToUtf( */ char * -Tcl_UniCharToUtfDString( - const Tcl_UniChar *uniStr, /* Unicode string to convert to UTF-8. */ - int uniLength, /* Length of Unicode string in Tcl_UniChars +Tcl_UniCharToUtfDString(wString, numChars, dsPtr) + CONST Tcl_UniChar *wString; /* Unicode string to convert to UTF-8. */ + int numChars; /* Length of Unicode string in Tcl_UniChars * (must be >= 0). */ - Tcl_DString *dsPtr) /* UTF-8 representation of string is appended - * to this previously initialized DString. */ + Tcl_DString *dsPtr; /* UTF-8 representation of string is + * appended to this previously initialized + * DString. */ { - const Tcl_UniChar *w, *wEnd; + CONST Tcl_UniChar *w, *wEnd; char *p, *string; int oldLength; @@ -247,12 +249,12 @@ Tcl_UniCharToUtfDString( */ oldLength = Tcl_DStringLength(dsPtr); - Tcl_DStringSetLength(dsPtr, (oldLength + uniLength + 1) * TCL_UTF_MAX); + Tcl_DStringSetLength(dsPtr, (oldLength + numChars + 1) * TCL_UTF_MAX); string = Tcl_DStringValue(dsPtr) + oldLength; p = string; - wEnd = uniStr + uniLength; - for (w = uniStr; w < wEnd; ) { + wEnd = wString + numChars; + for (w = wString; w < wEnd; ) { p += Tcl_UniCharToUtf(*w, p); w++; } @@ -266,16 +268,16 @@ Tcl_UniCharToUtfDString( * * Tcl_UtfToUniChar -- * - * Extract the Tcl_UniChar represented by the UTF-8 string. Bad UTF-8 - * sequences are converted to valid Tcl_UniChars and processing - * continues. Equivalent to Plan 9 chartorune(). + * Extract the Tcl_UniChar represented by the UTF-8 string. Bad + * UTF-8 sequences are converted to valid Tcl_UniChars and processing + * continues. Equivalent to Plan 9 chartorune(). * - * The caller must ensure that the source buffer is long enough that this - * routine does not run off the end and dereference non-existent memory - * looking for trail bytes. If the source buffer is known to be '\0' - * terminated, this cannot happen. Otherwise, the caller should call - * Tcl_UtfCharComplete() before calling this routine to ensure that - * enough bytes remain in the string. + * The caller must ensure that the source buffer is long enough that + * this routine does not run off the end and dereference non-existent + * memory looking for trail bytes. If the source buffer is known to + * be '\0' terminated, this cannot happen. Otherwise, the caller + * should call Tcl_UtfCharComplete() before calling this routine to + * ensure that enough bytes remain in the string. * * Results: * *chPtr is filled with the Tcl_UniChar, and the return value is the @@ -288,10 +290,10 @@ Tcl_UniCharToUtfDString( */ int -Tcl_UtfToUniChar( - register const char *src, /* The UTF-8 string. */ - register Tcl_UniChar *chPtr)/* Filled with the Tcl_UniChar represented by - * the UTF-8 string. */ +Tcl_UtfToUniChar(str, chPtr) + register CONST char *str; /* The UTF-8 string. */ + register Tcl_UniChar *chPtr; /* Filled with the Tcl_UniChar represented + * by the UTF-8 string. */ { register int byte; @@ -299,7 +301,7 @@ Tcl_UtfToUniChar( * Unroll 1 to 3 byte UTF-8 sequences, use loop to handle longer ones. */ - byte = *((unsigned char *) src); + byte = *((unsigned char *) str); if (byte < 0xC0) { /* * Handles properly formed UTF-8 characters between 0x01 and 0x7F. @@ -310,15 +312,14 @@ Tcl_UtfToUniChar( *chPtr = (Tcl_UniChar) byte; return 1; } else if (byte < 0xE0) { - if ((src[1] & 0xC0) == 0x80) { + if ((str[1] & 0xC0) == 0x80) { /* * Two-byte-character lead-byte followed by a trail-byte. */ - *chPtr = (Tcl_UniChar) (((byte & 0x1F) << 6) | (src[1] & 0x3F)); + *chPtr = (Tcl_UniChar) (((byte & 0x1F) << 6) | (str[1] & 0x3F)); return 2; } - /* * A two-byte-character lead-byte not followed by trail-byte * represents itself. @@ -327,16 +328,15 @@ Tcl_UtfToUniChar( *chPtr = (Tcl_UniChar) byte; return 1; } else if (byte < 0xF0) { - if (((src[1] & 0xC0) == 0x80) && ((src[2] & 0xC0) == 0x80)) { + if (((str[1] & 0xC0) == 0x80) && ((str[2] & 0xC0) == 0x80)) { /* * Three-byte-character lead byte followed by two trail bytes. */ *chPtr = (Tcl_UniChar) (((byte & 0x0F) << 12) - | ((src[1] & 0x3F) << 6) | (src[2] & 0x3F)); + | ((str[1] & 0x3F) << 6) | (str[2] & 0x3F)); return 3; } - /* * A three-byte-character lead-byte not followed by two trail-bytes * represents itself. @@ -346,7 +346,7 @@ Tcl_UtfToUniChar( return 1; } #if TCL_UTF_MAX > 3 - { + else { int ch, total, trail; total = totalBytes[byte]; @@ -354,13 +354,13 @@ Tcl_UtfToUniChar( if (trail > 0) { ch = byte & (0x3F >> trail); do { - src++; - if ((*src & 0xC0) != 0x80) { + str++; + if ((*str & 0xC0) != 0x80) { *chPtr = byte; return 1; } ch <<= 6; - ch |= (*src & 0x3F); + ch |= (*str & 0x3F); trail--; } while (trail > 0); *chPtr = ch; @@ -382,8 +382,9 @@ Tcl_UtfToUniChar( * * Results: * The return value is a pointer to the Unicode representation of the - * UTF-8 string. Storage for the return value is appended to the end of - * dsPtr. The Unicode string is terminated with a Unicode NULL character. + * UTF-8 string. Storage for the return value is appended to the + * end of dsPtr. The Unicode string is terminated with a Unicode + * NULL character. * * Side effects: * None. @@ -392,36 +393,35 @@ Tcl_UtfToUniChar( */ Tcl_UniChar * -Tcl_UtfToUniCharDString( - const char *src, /* UTF-8 string to convert to Unicode. */ - int length, /* Length of UTF-8 string in bytes, or -1 for - * strlen(). */ - Tcl_DString *dsPtr) /* Unicode representation of string is +Tcl_UtfToUniCharDString(string, length, dsPtr) + CONST char *string; /* UTF-8 string to convert to Unicode. */ + int length; /* Length of UTF-8 string in bytes, or -1 + * for strlen(). */ + Tcl_DString *dsPtr; /* Unicode representation of string is * appended to this previously initialized * DString. */ { Tcl_UniChar *w, *wString; - const char *p, *end; + CONST char *p, *end; int oldLength; if (length < 0) { - length = strlen(src); + length = strlen(string); } /* - * Unicode string length in Tcl_UniChars will be <= UTF-8 string length in - * bytes. + * Unicode string length in Tcl_UniChars will be <= UTF-8 string length + * in bytes. */ oldLength = Tcl_DStringLength(dsPtr); -/* TODO: fix overreach! */ Tcl_DStringSetLength(dsPtr, (int) ((oldLength + length + 1) * sizeof(Tcl_UniChar))); wString = (Tcl_UniChar *) (Tcl_DStringValue(dsPtr) + oldLength); w = wString; - end = src + length; - for (p = src; p < end; ) { + end = string + length; + for (p = string; p < end; ) { p += TclUtfToUniChar(p, w); w++; } @@ -437,9 +437,9 @@ Tcl_UtfToUniCharDString( * * Tcl_UtfCharComplete -- * - * Determine if the UTF-8 string of the given length is long enough to be - * decoded by Tcl_UtfToUniChar(). This does not ensure that the UTF-8 - * string is properly formed. Equivalent to Plan 9 fullrune(). + * Determine if the UTF-8 string of the given length is long enough + * to be decoded by Tcl_UtfToUniChar(). This does not ensure that the + * UTF-8 string is properly formed. Equivalent to Plan 9 fullrune(). * * Results: * The return value is 0 if the string is not long enough, non-zero @@ -452,15 +452,15 @@ Tcl_UtfToUniCharDString( */ int -Tcl_UtfCharComplete( - const char *src, /* String to check if first few bytes contain - * a complete UTF-8 character. */ - int length) /* Length of above string in bytes. */ +Tcl_UtfCharComplete(str, len) + CONST char *str; /* String to check if first few bytes + * contain a complete UTF-8 character. */ + int len; /* Length of above string in bytes. */ { int ch; - ch = *((unsigned char *) src); - return length >= totalBytes[ch]; + ch = *((unsigned char *) str); + return len >= totalBytes[ch]; } /* @@ -468,9 +468,9 @@ Tcl_UtfCharComplete( * * Tcl_NumUtfChars -- * - * Returns the number of characters (not bytes) in the UTF-8 string, not - * including the terminating NULL byte. This is equivalent to Plan 9 - * utflen() and utfnlen(). + * Returns the number of characters (not bytes) in the UTF-8 string, + * not including the terminating NULL byte. This is equivalent to + * Plan 9 utflen() and utfnlen(). * * Results: * As above. @@ -482,9 +482,9 @@ Tcl_UtfCharComplete( */ int -Tcl_NumUtfChars( - register const char *src, /* The UTF-8 string to measure. */ - int length) /* The length of the string in bytes, or -1 +Tcl_NumUtfChars(str, len) + register CONST char *str; /* The UTF-8 string to measure. */ + int len; /* The length of the string in bytes, or -1 * for strlen(string). */ { Tcl_UniChar ch; @@ -494,27 +494,27 @@ Tcl_NumUtfChars( /* * The separate implementations are faster. * - * Since this is a time-sensitive function, we also do the check for the - * single-byte char case specially. + * Since this is a time-sensitive function, we also do the check for + * the single-byte char case specially. */ i = 0; - if (length < 0) { - while (*src != '\0') { - src += TclUtfToUniChar(src, chPtr); + if (len < 0) { + while (*str != '\0') { + str += TclUtfToUniChar(str, chPtr); i++; } } else { register int n; - while (length > 0) { - if (UCHAR(*src) < 0xC0) { - length--; - src++; + while (len > 0) { + if (UCHAR(*str) < 0xC0) { + len--; + str++; } else { - n = Tcl_UtfToUniChar(src, chPtr); - length -= n; - src += n; + n = Tcl_UtfToUniChar(str, chPtr); + len -= n; + str += n; } i++; } @@ -527,37 +527,37 @@ Tcl_NumUtfChars( * * Tcl_UtfFindFirst -- * - * Returns a pointer to the first occurance of the given Tcl_UniChar in - * the NULL-terminated UTF-8 string. The NULL terminator is considered - * part of the UTF-8 string. Equivalent to Plan 9 utfrune(). + * Returns a pointer to the first occurance of the given Tcl_UniChar + * in the NULL-terminated UTF-8 string. The NULL terminator is + * considered part of the UTF-8 string. Equivalent to Plan 9 + * utfrune(). * * Results: - * As above. If the Tcl_UniChar does not exist in the given string, the - * return value is NULL. + * As above. If the Tcl_UniChar does not exist in the given string, + * the return value is NULL. * * Side effects: * None. * *--------------------------------------------------------------------------- */ - -const char * -Tcl_UtfFindFirst( - const char *src, /* The UTF-8 string to be searched. */ - int ch) /* The Tcl_UniChar to search for. */ +CONST char * +Tcl_UtfFindFirst(string, ch) + CONST char *string; /* The UTF-8 string to be searched. */ + int ch; /* The Tcl_UniChar to search for. */ { int len; Tcl_UniChar find; while (1) { - len = TclUtfToUniChar(src, &find); + len = TclUtfToUniChar(string, &find); if (find == ch) { - return src; + return string; } - if (*src == '\0') { + if (*string == '\0') { return NULL; } - src += len; + string += len; } } @@ -566,13 +566,14 @@ Tcl_UtfFindFirst( * * Tcl_UtfFindLast -- * - * Returns a pointer to the last occurance of the given Tcl_UniChar in - * the NULL-terminated UTF-8 string. The NULL terminator is considered - * part of the UTF-8 string. Equivalent to Plan 9 utfrrune(). + * Returns a pointer to the last occurance of the given Tcl_UniChar + * in the NULL-terminated UTF-8 string. The NULL terminator is + * considered part of the UTF-8 string. Equivalent to Plan 9 + * utfrrune(). * * Results: - * As above. If the Tcl_UniChar does not exist in the given string, the - * return value is NULL. + * As above. If the Tcl_UniChar does not exist in the given string, + * the return value is NULL. * * Side effects: * None. @@ -580,25 +581,25 @@ Tcl_UtfFindFirst( *--------------------------------------------------------------------------- */ -const char * -Tcl_UtfFindLast( - const char *src, /* The UTF-8 string to be searched. */ - int ch) /* The Tcl_UniChar to search for. */ +CONST char * +Tcl_UtfFindLast(string, ch) + CONST char *string; /* The UTF-8 string to be searched. */ + int ch; /* The Tcl_UniChar to search for. */ { int len; Tcl_UniChar find; - const char *last; + CONST char *last; last = NULL; while (1) { - len = TclUtfToUniChar(src, &find); + len = TclUtfToUniChar(string, &find); if (find == ch) { - last = src; + last = string; } - if (*src == '\0') { + if (*string == '\0') { break; } - src += len; + string += len; } return last; } @@ -608,13 +609,14 @@ Tcl_UtfFindLast( * * Tcl_UtfNext -- * - * Given a pointer to some current location in a UTF-8 string, move - * forward one character. The caller must ensure that they are not asking - * for the next character after the last character in the string. + * Given a pointer to some current location in a UTF-8 string, + * move forward one character. The caller must ensure that they + * are not asking for the next character after the last character + * in the string. * * Results: - * The return value is the pointer to the next character in the UTF-8 - * string. + * The return value is the pointer to the next character in + * the UTF-8 string. * * Side effects: * None. @@ -622,13 +624,13 @@ Tcl_UtfFindLast( *--------------------------------------------------------------------------- */ -const char * -Tcl_UtfNext( - const char *src) /* The current location in the string. */ +CONST char * +Tcl_UtfNext(str) + CONST char *str; /* The current location in the string. */ { Tcl_UniChar ch; - return src + TclUtfToUniChar(src, &ch); + return str + TclUtfToUniChar(str, &ch); } /* @@ -636,15 +638,15 @@ Tcl_UtfNext( * * Tcl_UtfPrev -- * - * Given a pointer to some current location in a UTF-8 string, move - * backwards one character. This works correctly when the pointer is in - * the middle of a UTF-8 character. + * Given a pointer to some current location in a UTF-8 string, + * move backwards one character. This works correctly when the + * pointer is in the middle of a UTF-8 character. * * Results: - * The return value is a pointer to the previous character in the UTF-8 - * string. If the current location was already at the beginning of the - * string, the return value will also be a pointer to the beginning of - * the string. + * The return value is a pointer to the previous character in the + * UTF-8 string. If the current location was already at the + * beginning of the string, the return value will also be a + * pointer to the beginning of the string. * * Side effects: * None. @@ -652,21 +654,22 @@ Tcl_UtfNext( *--------------------------------------------------------------------------- */ -const char * -Tcl_UtfPrev( - const char *src, /* The current location in the string. */ - const char *start) /* Pointer to the beginning of the string, to - * avoid going backwards too far. */ +CONST char * +Tcl_UtfPrev(str, start) + CONST char *str; /* The current location in the string. */ + CONST char *start; /* Pointer to the beginning of the + * string, to avoid going backwards too + * far. */ { - const char *look; + CONST char *look; int i, byte; - src--; - look = src; + str--; + look = str; for (i = 0; i < TCL_UTF_MAX; i++) { if (look < start) { - if (src < start) { - src = start; + if (str < start) { + str = start; } break; } @@ -679,7 +682,7 @@ Tcl_UtfPrev( } look--; } - return src; + return str; } /* @@ -687,8 +690,8 @@ Tcl_UtfPrev( * * Tcl_UniCharAtIndex -- * - * Returns the Unicode character represented at the specified character - * (not byte) position in the UTF-8 string. + * Returns the Unicode character represented at the specified + * character (not byte) position in the UTF-8 string. * * Results: * As above. @@ -700,11 +703,11 @@ Tcl_UtfPrev( */ Tcl_UniChar -Tcl_UniCharAtIndex( - register const char *src, /* The UTF-8 string to dereference. */ - register int index) /* The position of the desired character. */ +Tcl_UniCharAtIndex(src, index) + register CONST char *src; /* The UTF-8 string to dereference. */ + register int index; /* The position of the desired character. */ { - Tcl_UniChar ch = 0; + Tcl_UniChar ch; while (index >= 0) { index--; @@ -718,8 +721,8 @@ Tcl_UniCharAtIndex( * * Tcl_UtfAtIndex -- * - * Returns a pointer to the specified character (not byte) position in - * the UTF-8 string. + * Returns a pointer to the specified character (not byte) position + * in the UTF-8 string. * * Results: * As above. @@ -730,10 +733,10 @@ Tcl_UniCharAtIndex( *--------------------------------------------------------------------------- */ -const char * -Tcl_UtfAtIndex( - register const char *src, /* The UTF-8 string. */ - register int index) /* The position of the desired character. */ +CONST char * +Tcl_UtfAtIndex(src, index) + register CONST char *src; /* The UTF-8 string. */ + register int index; /* The position of the desired character. */ { Tcl_UniChar ch; @@ -753,30 +756,31 @@ Tcl_UtfAtIndex( * * Results: * Stores the bytes represented by the backslash sequence in dst and - * returns the number of bytes written to dst. At most TCL_UTF_MAX bytes - * are written to dst; dst must have been large enough to accept those - * bytes. If readPtr isn't NULL then it is filled in with a count of the - * number of bytes in the backslash sequence. + * returns the number of bytes written to dst. At most TCL_UTF_MAX + * bytes are written to dst; dst must have been large enough to accept + * those bytes. If readPtr isn't NULL then it is filled in with a + * count of the number of bytes in the backslash sequence. * * Side effects: - * The maximum number of bytes it takes to represent a Unicode character - * in UTF-8 is guaranteed to be less than the number of bytes used to - * express the backslash sequence that represents that Unicode character. - * If the target buffer into which the caller is going to store the bytes - * that represent the Unicode character is at least as large as the - * source buffer from which the backslashed sequence was extracted, no - * buffer overruns should occur. + * The maximum number of bytes it takes to represent a Unicode + * character in UTF-8 is guaranteed to be less than the number of + * bytes used to express the backslash sequence that represents + * that Unicode character. If the target buffer into which the + * caller is going to store the bytes that represent the Unicode + * character is at least as large as the source buffer from which + * the backslashed sequence was extracted, no buffer overruns should + * occur. * *--------------------------------------------------------------------------- */ int -Tcl_UtfBackslash( - const char *src, /* Points to the backslash character of a - * backslash sequence. */ - int *readPtr, /* Fill in with number of characters read from - * src, unless NULL. */ - char *dst) /* Filled with the bytes represented by the +Tcl_UtfBackslash(src, readPtr, dst) + CONST char *src; /* Points to the backslash character of + * a backslash sequence. */ + int *readPtr; /* Fill in with number of characters read + * from src, unless NULL. */ + char *dst; /* Filled with the bytes represented by the * backslash sequence. */ { #define LINE_LENGTH 128 @@ -785,10 +789,7 @@ Tcl_UtfBackslash( result = TclParseBackslash(src, LINE_LENGTH, &numRead, dst); if (numRead == LINE_LENGTH) { - /* - * We ate a whole line. Pay the price of a strlen() - */ - + /* We ate a whole line. Pay the price of a strlen() */ result = TclParseBackslash(src, (int)strlen(src), &numRead, dst); } if (readPtr != NULL) { @@ -802,12 +803,12 @@ Tcl_UtfBackslash( * * Tcl_UtfToUpper -- * - * Convert lowercase characters to uppercase characters in a UTF string - * in place. The conversion may shrink the UTF string. + * Convert lowercase characters to uppercase characters in a UTF + * string in place. The conversion may shrink the UTF string. * * Results: - * Returns the number of bytes in the resulting string excluding the - * trailing null. + * Returns the number of bytes in the resulting string + * excluding the trailing null. * * Side effects: * Writes a terminating null after the last converted character. @@ -816,8 +817,8 @@ Tcl_UtfBackslash( */ int -Tcl_UtfToUpper( - char *str) /* String to convert in place. */ +Tcl_UtfToUpper(str) + char *str; /* String to convert in place. */ { Tcl_UniChar ch, upChar; char *src, *dst; @@ -829,13 +830,13 @@ Tcl_UtfToUpper( src = dst = str; while (*src) { - bytes = TclUtfToUniChar(src, &ch); + bytes = TclUtfToUniChar(src, &ch); upChar = Tcl_UniCharToUpper(ch); /* - * To keep badly formed Utf strings from getting inflated by the - * conversion (thereby causing a segfault), only copy the upper case - * char to dst if its size is <= the original char. + * To keep badly formed Utf strings from getting inflated by + * the conversion (thereby causing a segfault), only copy the + * upper case char to dst if its size is <= the original char. */ if (bytes < UtfCount(upChar)) { @@ -855,12 +856,12 @@ Tcl_UtfToUpper( * * Tcl_UtfToLower -- * - * Convert uppercase characters to lowercase characters in a UTF string - * in place. The conversion may shrink the UTF string. + * Convert uppercase characters to lowercase characters in a UTF + * string in place. The conversion may shrink the UTF string. * * Results: - * Returns the number of bytes in the resulting string excluding the - * trailing null. + * Returns the number of bytes in the resulting string + * excluding the trailing null. * * Side effects: * Writes a terminating null after the last converted character. @@ -869,8 +870,8 @@ Tcl_UtfToUpper( */ int -Tcl_UtfToLower( - char *str) /* String to convert in place. */ +Tcl_UtfToLower(str) + char *str; /* String to convert in place. */ { Tcl_UniChar ch, lowChar; char *src, *dst; @@ -886,9 +887,9 @@ Tcl_UtfToLower( lowChar = Tcl_UniCharToLower(ch); /* - * To keep badly formed Utf strings from getting inflated by the - * conversion (thereby causing a segfault), only copy the lower case - * char to dst if its size is <= the original char. + * To keep badly formed Utf strings from getting inflated by + * the conversion (thereby causing a segfault), only copy the + * lower case char to dst if its size is <= the original char. */ if (bytes < UtfCount(lowChar)) { @@ -908,13 +909,13 @@ Tcl_UtfToLower( * * Tcl_UtfToTitle -- * - * Changes the first character of a UTF string to title case or uppercase - * and the rest of the string to lowercase. The conversion happens in - * place and may shrink the UTF string. + * Changes the first character of a UTF string to title case or + * uppercase and the rest of the string to lowercase. The + * conversion happens in place and may shrink the UTF string. * * Results: - * Returns the number of bytes in the resulting string excluding the - * trailing null. + * Returns the number of bytes in the resulting string + * excluding the trailing null. * * Side effects: * Writes a terminating null after the last converted character. @@ -923,8 +924,8 @@ Tcl_UtfToLower( */ int -Tcl_UtfToTitle( - char *str) /* String to convert in place. */ +Tcl_UtfToTitle(str) + char *str; /* String to convert in place. */ { Tcl_UniChar ch, titleChar, lowChar; char *src, *dst; @@ -970,8 +971,8 @@ Tcl_UtfToTitle( * * TclpUtfNcmp2 -- * - * Compare at most numBytes bytes of utf-8 strings cs and ct. Both cs and - * ct are assumed to be at least numBytes bytes long. + * Compare at most n bytes of utf-8 strings cs and ct. Both cs + * and ct are assumed to be at least n bytes long. * * Results: * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct. @@ -983,28 +984,26 @@ Tcl_UtfToTitle( */ int -TclpUtfNcmp2( - const char *cs, /* UTF string to compare to ct. */ - const char *ct, /* UTF string cs is compared to. */ - unsigned long numBytes) /* Number of *bytes* to compare. */ +TclpUtfNcmp2(cs, ct, n) + CONST char *cs; /* UTF string to compare to ct. */ + CONST char *ct; /* UTF string cs is compared to. */ + unsigned long n; /* Number of *bytes* to compare. */ { /* - * We can't simply call 'memcmp(cs, ct, numBytes);' because we need to - * check for Tcl's \xC0\x80 non-utf-8 null encoding. Otherwise utf-8 lexes - * fine in the strcmp manner. + * We can't simply call 'memcmp(cs, ct, n);' because we need to check + * for Tcl's \xC0\x80 non-utf-8 null encoding. + * Otherwise utf-8 lexes fine in the strcmp manner. */ - register int result = 0; - for ( ; numBytes != 0; numBytes--, cs++, ct++) { + for ( ; n != 0; n--, cs++, ct++) { if (*cs != *ct) { result = UCHAR(*cs) - UCHAR(*ct); break; } } - if (numBytes && ((UCHAR(*cs) == 0xC0) || (UCHAR(*ct) == 0xC0))) { + if (n && ((UCHAR(*cs) == 0xC0) || (UCHAR(*ct) == 0xC0))) { unsigned char c1, c2; - c1 = ((UCHAR(*cs) == 0xC0) && (UCHAR(cs[1]) == 0x80)) ? 0 : UCHAR(*cs); c2 = ((UCHAR(*ct) == 0xC0) && (UCHAR(ct[1]) == 0x80)) ? 0 : UCHAR(*ct); result = (c1 - c2); @@ -1017,8 +1016,8 @@ TclpUtfNcmp2( * * Tcl_UtfNcmp -- * - * Compare at most numChars UTF chars of string cs to string ct. Both cs - * and ct are assumed to be at least numChars UTF chars long. + * Compare at most n UTF chars of string cs to string ct. Both cs + * and ct are assumed to be at least n UTF chars long. * * Results: * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct. @@ -1030,26 +1029,23 @@ TclpUtfNcmp2( */ int -Tcl_UtfNcmp( - const char *cs, /* UTF string to compare to ct. */ - const char *ct, /* UTF string cs is compared to. */ - unsigned long numChars) /* Number of UTF chars to compare. */ +Tcl_UtfNcmp(cs, ct, n) + CONST char *cs; /* UTF string to compare to ct. */ + CONST char *ct; /* UTF string cs is compared to. */ + unsigned long n; /* Number of UTF chars to compare. */ { Tcl_UniChar ch1, ch2; - /* - * Cannot use 'memcmp(cs, ct, n);' as byte representation of \u0000 (the - * pair of bytes 0xc0,0x80) is larger than byte representation of \u0001 - * (the byte 0x01.) + * Cannot use 'memcmp(cs, ct, n);' as byte representation of + * \u0000 (the pair of bytes 0xc0,0x80) is larger than byte + * representation of \u0001 (the byte 0x01.) */ - - while (numChars-- > 0) { + while (n-- > 0) { /* - * n must be interpreted as chars, not bytes. This should be called - * only when both strings are of at least n chars long (no need for \0 - * check) + * n must be interpreted as chars, not bytes. + * This should be called only when both strings are of + * at least n chars long (no need for \0 check) */ - cs += TclUtfToUniChar(cs, &ch1); ct += TclUtfToUniChar(ct, &ch2); if (ch1 != ch2) { @@ -1064,9 +1060,9 @@ Tcl_UtfNcmp( * * Tcl_UtfNcasecmp -- * - * Compare at most numChars UTF chars of string cs to string ct case - * insensitive. Both cs and ct are assumed to be at least numChars UTF - * chars long. + * Compare at most n UTF chars of string cs to string ct case + * insensitive. Both cs and ct are assumed to be at least n + * UTF chars long. * * Results: * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct. @@ -1078,13 +1074,13 @@ Tcl_UtfNcmp( */ int -Tcl_UtfNcasecmp( - const char *cs, /* UTF string to compare to ct. */ - const char *ct, /* UTF string cs is compared to. */ - unsigned long numChars) /* Number of UTF chars to compare. */ +Tcl_UtfNcasecmp(cs, ct, n) + CONST char *cs; /* UTF string to compare to ct. */ + CONST char *ct; /* UTF string cs is compared to. */ + unsigned long n; /* Number of UTF chars to compare. */ { Tcl_UniChar ch1, ch2; - while (numChars-- > 0) { + while (n-- > 0) { /* * n must be interpreted as chars, not bytes. * This should be called only when both strings are of @@ -1120,8 +1116,8 @@ Tcl_UtfNcasecmp( */ Tcl_UniChar -Tcl_UniCharToUpper( - int ch) /* Unicode character to convert. */ +Tcl_UniCharToUpper(ch) + int ch; /* Unicode character to convert. */ { int info = GetUniCharInfo(ch); @@ -1148,8 +1144,8 @@ Tcl_UniCharToUpper( */ Tcl_UniChar -Tcl_UniCharToLower( - int ch) /* Unicode character to convert. */ +Tcl_UniCharToLower(ch) + int ch; /* Unicode character to convert. */ { int info = GetUniCharInfo(ch); @@ -1176,8 +1172,8 @@ Tcl_UniCharToLower( */ Tcl_UniChar -Tcl_UniCharToTitle( - int ch) /* Unicode character to convert. */ +Tcl_UniCharToTitle(ch) + int ch; /* Unicode character to convert. */ { int info = GetUniCharInfo(ch); int mode = GetCaseType(info); @@ -1199,7 +1195,7 @@ Tcl_UniCharToTitle( * * Tcl_UniCharLen -- * - * Find the length of a UniChar string. The str input must be null + * Find the length of a UniChar string. The str input must be null * terminated. * * Results: @@ -1212,14 +1208,14 @@ Tcl_UniCharToTitle( */ int -Tcl_UniCharLen( - const Tcl_UniChar *uniStr) /* Unicode string to find length of. */ +Tcl_UniCharLen(str) + CONST Tcl_UniChar *str; /* Unicode string to find length of. */ { int len = 0; - while (*uniStr != '\0') { + while (*str != '\0') { len++; - uniStr++; + str++; } return len; } @@ -1229,11 +1225,11 @@ Tcl_UniCharLen( * * Tcl_UniCharNcmp -- * - * Compare at most numChars unichars of string ucs to string uct. - * Both ucs and uct are assumed to be at least numChars unichars long. + * Compare at most n unichars of string cs to string ct. Both cs + * and ct are assumed to be at least n unichars long. * * Results: - * Return <0 if ucs < uct, 0 if ucs == uct, or >0 if ucs > uct. + * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct. * * Side effects: * None. @@ -1242,26 +1238,24 @@ Tcl_UniCharLen( */ int -Tcl_UniCharNcmp( - const Tcl_UniChar *ucs, /* Unicode string to compare to uct. */ - const Tcl_UniChar *uct, /* Unicode string ucs is compared to. */ - unsigned long numChars) /* Number of unichars to compare. */ +Tcl_UniCharNcmp(cs, ct, n) + CONST Tcl_UniChar *cs; /* Unicode string to compare to ct. */ + CONST Tcl_UniChar *ct; /* Unicode string cs is compared to. */ + unsigned long n; /* Number of unichars to compare. */ { #ifdef WORDS_BIGENDIAN /* * We are definitely on a big-endian machine; memcmp() is safe */ - - return memcmp(ucs, uct, numChars*sizeof(Tcl_UniChar)); + return memcmp(cs, ct, n*sizeof(Tcl_UniChar)); #else /* !WORDS_BIGENDIAN */ /* * We can't simply call memcmp() because that is not lexically correct. */ - - for ( ; numChars != 0; ucs++, uct++, numChars--) { - if (*ucs != *uct) { - return (*ucs - *uct); + for ( ; n != 0; cs++, ct++, n--) { + if (*cs != *ct) { + return (*cs - *ct); } } return 0; @@ -1273,12 +1267,12 @@ Tcl_UniCharNcmp( * * Tcl_UniCharNcasecmp -- * - * Compare at most numChars unichars of string ucs to string uct case - * insensitive. Both ucs and uct are assumed to be at least numChars + * Compare at most n unichars of string cs to string ct case + * insensitive. Both cs and ct are assumed to be at least n * unichars long. * * Results: - * Return <0 if ucs < uct, 0 if ucs == uct, or >0 if ucs > uct. + * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct. * * Side effects: * None. @@ -1287,16 +1281,15 @@ Tcl_UniCharNcmp( */ int -Tcl_UniCharNcasecmp( - const Tcl_UniChar *ucs, /* Unicode string to compare to uct. */ - const Tcl_UniChar *uct, /* Unicode string ucs is compared to. */ - unsigned long numChars) /* Number of unichars to compare. */ +Tcl_UniCharNcasecmp(cs, ct, n) + CONST Tcl_UniChar *cs; /* Unicode string to compare to ct. */ + CONST Tcl_UniChar *ct; /* Unicode string cs is compared to. */ + unsigned long n; /* Number of unichars to compare. */ { - for ( ; numChars != 0; numChars--, ucs++, uct++) { - if (*ucs != *uct) { - Tcl_UniChar lcs = Tcl_UniCharToLower(*ucs); - Tcl_UniChar lct = Tcl_UniCharToLower(*uct); - + for ( ; n != 0; n--, cs++, ct++) { + if (*cs != *ct) { + Tcl_UniChar lcs = Tcl_UniCharToLower(*cs); + Tcl_UniChar lct = Tcl_UniCharToLower(*ct); if (lcs != lct) { return (lcs - lct); } @@ -1322,8 +1315,8 @@ Tcl_UniCharNcasecmp( */ int -Tcl_UniCharIsAlnum( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsAlnum(ch) + int ch; /* Unicode character to test. */ { return (((ALPHA_BITS | DIGIT_BITS) >> GetCategory(ch)) & 1); } @@ -1345,8 +1338,8 @@ Tcl_UniCharIsAlnum( */ int -Tcl_UniCharIsAlpha( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsAlpha(ch) + int ch; /* Unicode character to test. */ { return ((ALPHA_BITS >> GetCategory(ch)) & 1); } @@ -1368,8 +1361,8 @@ Tcl_UniCharIsAlpha( */ int -Tcl_UniCharIsControl( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsControl(ch) + int ch; /* Unicode character to test. */ { return ((CONTROL_BITS >> GetCategory(ch)) & 1); } @@ -1391,8 +1384,8 @@ Tcl_UniCharIsControl( */ int -Tcl_UniCharIsDigit( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsDigit(ch) + int ch; /* Unicode character to test. */ { return (GetCategory(ch) == DECIMAL_DIGIT_NUMBER); } @@ -1414,8 +1407,8 @@ Tcl_UniCharIsDigit( */ int -Tcl_UniCharIsGraph( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsGraph(ch) + int ch; /* Unicode character to test. */ { return ((GRAPH_BITS >> GetCategory(ch)) & 1); } @@ -1437,8 +1430,8 @@ Tcl_UniCharIsGraph( */ int -Tcl_UniCharIsLower( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsLower(ch) + int ch; /* Unicode character to test. */ { return (GetCategory(ch) == LOWERCASE_LETTER); } @@ -1460,8 +1453,8 @@ Tcl_UniCharIsLower( */ int -Tcl_UniCharIsPrint( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsPrint(ch) + int ch; /* Unicode character to test. */ { return (((GRAPH_BITS|SPACE_BITS) >> GetCategory(ch)) & 1); } @@ -1483,8 +1476,8 @@ Tcl_UniCharIsPrint( */ int -Tcl_UniCharIsPunct( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsPunct(ch) + int ch; /* Unicode character to test. */ { return ((PUNCT_BITS >> GetCategory(ch)) & 1); } @@ -1506,8 +1499,8 @@ Tcl_UniCharIsPunct( */ int -Tcl_UniCharIsSpace( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsSpace(ch) + int ch; /* Unicode character to test. */ { /* * If the character is within the first 127 characters, just use the @@ -1538,8 +1531,8 @@ Tcl_UniCharIsSpace( */ int -Tcl_UniCharIsUpper( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsUpper(ch) + int ch; /* Unicode character to test. */ { return (GetCategory(ch) == UPPERCASE_LETTER); } @@ -1549,7 +1542,8 @@ Tcl_UniCharIsUpper( * * Tcl_UniCharIsWordChar -- * - * Test if a character is alphanumeric or a connector punctuation mark. + * Test if a character is alphanumeric or a connector punctuation + * mark. * * Results: * Returns 1 if character is a word character. @@ -1561,8 +1555,8 @@ Tcl_UniCharIsUpper( */ int -Tcl_UniCharIsWordChar( - int ch) /* Unicode character to test. */ +Tcl_UniCharIsWordChar(ch) + int ch; /* Unicode character to test. */ { return ((WORD_BITS >> GetCategory(ch)) & 1); } @@ -1573,16 +1567,17 @@ Tcl_UniCharIsWordChar( * Tcl_UniCharCaseMatch -- * * See if a particular Unicode string matches a particular pattern. - * Allows case insensitivity. This is the Unicode equivalent of the char* - * Tcl_StringCaseMatch. The UniChar strings must be NULL-terminated. - * This has no provision for counted UniChar strings, thus should not be - * used where NULLs are expected in the UniChar string. Use - * TclUniCharMatch where possible. + * Allows case insensitivity. This is the Unicode equivalent of + * the char* Tcl_StringCaseMatch. The UniChar strings must be + * NULL-terminated. This has no provision for counted UniChar + * strings, thus should not be used where NULLs are expected in the + * UniChar string. Use TclUniCharMatch where possible. * * Results: - * The return value is 1 if string matches pattern, and 0 otherwise. The - * matching operation permits the following special characters in the - * pattern: *?\[] (see the manual entry for details on what these mean). + * The return value is 1 if string matches pattern, and + * 0 otherwise. The matching operation permits the following + * special characters in the pattern: *?\[] (see the manual + * entry for details on what these mean). * * Side effects: * None. @@ -1591,34 +1586,33 @@ Tcl_UniCharIsWordChar( */ int -Tcl_UniCharCaseMatch( - const Tcl_UniChar *uniStr, /* Unicode String. */ - const Tcl_UniChar *uniPattern, - /* Pattern, which may contain special +Tcl_UniCharCaseMatch(string, pattern, nocase) + CONST Tcl_UniChar *string; /* Unicode String. */ + CONST Tcl_UniChar *pattern; /* Pattern, which may contain special * characters. */ - int nocase) /* 0 for case sensitive, 1 for insensitive */ + int nocase; /* 0 for case sensitive, 1 for insensitive */ { Tcl_UniChar ch1, p; while (1) { - p = *uniPattern; + p = *pattern; /* - * See if we're at the end of both the pattern and the string. If so, - * we succeeded. If we're at the end of the pattern but not at the end - * of the string, we failed. + * See if we're at the end of both the pattern and the string. If + * so, we succeeded. If we're at the end of the pattern but not at + * the end of the string, we failed. */ if (p == 0) { - return (*uniStr == 0); + return (*string == 0); } - if ((*uniStr == 0) && (p != '*')) { + if ((*string == 0) && (p != '*')) { return 0; } /* - * Check for a "*" as the next pattern character. It matches any - * substring. We handle this by skipping all the characters up to the + * Check for a "*" as the next pattern character. It matches any + * substring. We handle this by skipping all the characters up to the * next matching one in the pattern, and then calling ourselves * recursively for each postfix of string, until either we match or we * reach the end of the string. @@ -1628,11 +1622,8 @@ Tcl_UniCharCaseMatch( /* * Skip all successive *'s in the pattern */ - - while (*(++uniPattern) == '*') { - /* empty body */ - } - p = *uniPattern; + while (*(++pattern) == '*') {} + p = *pattern; if (p == 0) { return 1; } @@ -1645,67 +1636,63 @@ Tcl_UniCharCaseMatch( * quickly if the next char in the pattern isn't a special * character */ - if ((p != '[') && (p != '?') && (p != '\\')) { if (nocase) { - while (*uniStr && (p != *uniStr) - && (p != Tcl_UniCharToLower(*uniStr))) { - uniStr++; + while (*string && (p != *string) + && (p != Tcl_UniCharToLower(*string))) { + string++; } } else { - while (*uniStr && (p != *uniStr)) { - uniStr++; - } + while (*string && (p != *string)) { string++; } } } - if (Tcl_UniCharCaseMatch(uniStr, uniPattern, nocase)) { + if (Tcl_UniCharCaseMatch(string, pattern, nocase)) { return 1; } - if (*uniStr == 0) { + if (*string == 0) { return 0; } - uniStr++; + string++; } } /* - * Check for a "?" as the next pattern character. It matches any - * single character. + * Check for a "?" as the next pattern character. It matches + * any single character. */ if (p == '?') { - uniPattern++; - uniStr++; + pattern++; + string++; continue; } /* - * Check for a "[" as the next pattern character. It is followed by a - * list of characters that are acceptable, or by a range (two - * characters separated by "-"). + * Check for a "[" as the next pattern character. It is followed + * by a list of characters that are acceptable, or by a range + * (two characters separated by "-"). */ if (p == '[') { Tcl_UniChar startChar, endChar; - uniPattern++; - ch1 = (nocase ? Tcl_UniCharToLower(*uniStr) : *uniStr); - uniStr++; + pattern++; + ch1 = (nocase ? Tcl_UniCharToLower(*string) : *string); + string++; while (1) { - if ((*uniPattern == ']') || (*uniPattern == 0)) { + if ((*pattern == ']') || (*pattern == 0)) { return 0; } - startChar = (nocase ? Tcl_UniCharToLower(*uniPattern) - : *uniPattern); - uniPattern++; - if (*uniPattern == '-') { - uniPattern++; - if (*uniPattern == 0) { + startChar = (nocase ? Tcl_UniCharToLower(*pattern) : *pattern); + pattern++; + if (*pattern == '-') { + pattern++; + if (*pattern == 0) { return 0; } - endChar = (nocase ? Tcl_UniCharToLower(*uniPattern) - : *uniPattern); - uniPattern++; + endChar = (nocase ? Tcl_UniCharToLower(*pattern) + : *pattern); + pattern++; if (((startChar <= ch1) && (ch1 <= endChar)) || ((endChar <= ch1) && (ch1 <= startChar))) { /* @@ -1717,43 +1704,42 @@ Tcl_UniCharCaseMatch( break; } } - while (*uniPattern != ']') { - if (*uniPattern == 0) { - uniPattern--; + while (*pattern != ']') { + if (*pattern == 0) { + pattern--; break; } - uniPattern++; + pattern++; } - uniPattern++; + pattern++; continue; } /* - * If the next pattern character is '\', just strip off the '\' so we - * do exact matching on the character that follows. + * If the next pattern character is '\', just strip off the '\' + * so we do exact matching on the character that follows. */ if (p == '\\') { - if (*(++uniPattern) == '\0') { + if (*(++pattern) == '\0') { return 0; } } /* - * There's no special character. Just make sure that the next bytes of - * each string match. + * There's no special character. Just make sure that the next + * bytes of each string match. */ if (nocase) { - if (Tcl_UniCharToLower(*uniStr) != - Tcl_UniCharToLower(*uniPattern)) { + if (Tcl_UniCharToLower(*string) != Tcl_UniCharToLower(*pattern)) { return 0; } - } else if (*uniStr != *uniPattern) { + } else if (*string != *pattern) { return 0; } - uniStr++; - uniPattern++; + string++; + pattern++; } } @@ -1763,14 +1749,15 @@ Tcl_UniCharCaseMatch( * TclUniCharMatch -- * * See if a particular Unicode string matches a particular pattern. - * Allows case insensitivity. This is the Unicode equivalent of the char* - * Tcl_StringCaseMatch. This variant of Tcl_UniCharCaseMatch uses counted - * Strings, so embedded NULLs are allowed. + * Allows case insensitivity. This is the Unicode equivalent of the + * char* Tcl_StringCaseMatch. This variant of Tcl_UniCharCaseMatch + * uses counted Strings, so embedded NULLs are allowed. * * Results: - * The return value is 1 if string matches pattern, and 0 otherwise. The - * matching operation permits the following special characters in the - * pattern: *?\[] (see the manual entry for details on what these mean). + * The return value is 1 if string matches pattern, and + * 0 otherwise. The matching operation permits the following + * special characters in the pattern: *?\[] (see the manual + * entry for details on what these mean). * * Side effects: * None. @@ -1779,25 +1766,25 @@ Tcl_UniCharCaseMatch( */ int -TclUniCharMatch( - const Tcl_UniChar *string, /* Unicode String. */ - int strLen, /* Length of String */ - const Tcl_UniChar *pattern, /* Pattern, which may contain special +TclUniCharMatch(string, strLen, pattern, ptnLen, nocase) + CONST Tcl_UniChar *string; /* Unicode String. */ + int strLen; /* length of String */ + CONST Tcl_UniChar *pattern; /* Pattern, which may contain special * characters. */ - int ptnLen, /* Length of Pattern */ - int nocase) /* 0 for case sensitive, 1 for insensitive */ + int ptnLen; /* length of Pattern */ + int nocase; /* 0 for case sensitive, 1 for insensitive */ { - const Tcl_UniChar *stringEnd, *patternEnd; + CONST Tcl_UniChar *stringEnd, *patternEnd; Tcl_UniChar p; - stringEnd = string + strLen; + stringEnd = string + strLen; patternEnd = pattern + ptnLen; while (1) { /* - * See if we're at the end of both the pattern and the string. If so, - * we succeeded. If we're at the end of the pattern but not at the end - * of the string, we failed. + * See if we're at the end of both the pattern and the string. If + * so, we succeeded. If we're at the end of the pattern but not at + * the end of the string, we failed. */ if (pattern == patternEnd) { @@ -1809,8 +1796,8 @@ TclUniCharMatch( } /* - * Check for a "*" as the next pattern character. It matches any - * substring. We handle this by skipping all the characters up to the + * Check for a "*" as the next pattern character. It matches any + * substring. We handle this by skipping all the characters up to the * next matching one in the pattern, and then calling ourselves * recursively for each postfix of string, until either we match or we * reach the end of the string. @@ -1818,12 +1805,9 @@ TclUniCharMatch( if (p == '*') { /* - * Skip all successive *'s in the pattern. + * Skip all successive *'s in the pattern */ - - while (*(++pattern) == '*') { - /* empty body */ - } + while (*(++pattern) == '*') {} if (pattern == patternEnd) { return 1; } @@ -1835,9 +1819,8 @@ TclUniCharMatch( /* * Optimization for matching - cruise through the string * quickly if the next char in the pattern isn't a special - * character. + * character */ - if ((p != '[') && (p != '?') && (p != '\\')) { if (nocase) { while ((string < stringEnd) && (p != *string) @@ -1862,8 +1845,8 @@ TclUniCharMatch( } /* - * Check for a "?" as the next pattern character. It matches any - * single character. + * Check for a "?" as the next pattern character. It matches + * any single character. */ if (p == '?') { @@ -1873,9 +1856,9 @@ TclUniCharMatch( } /* - * Check for a "[" as the next pattern character. It is followed by a - * list of characters that are acceptable, or by a range (two - * characters separated by "-"). + * Check for a "[" as the next pattern character. It is followed + * by a list of characters that are acceptable, or by a range + * (two characters separated by "-"). */ if (p == '[') { @@ -1921,8 +1904,8 @@ TclUniCharMatch( } /* - * If the next pattern character is '\', just strip off the '\' so we - * do exact matching on the character that follows. + * If the next pattern character is '\', just strip off the '\' + * so we do exact matching on the character that follows. */ if (p == '\\') { @@ -1932,8 +1915,8 @@ TclUniCharMatch( } /* - * There's no special character. Just make sure that the next bytes of - * each string match. + * There's no special character. Just make sure that the next + * bytes of each string match. */ if (nocase) { @@ -1947,11 +1930,3 @@ TclUniCharMatch( pattern++; } } - -/* - * Local Variables: - * mode: c - * c-basic-offset: 4 - * fill-column: 78 - * End: - */ |