开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
tclUtf.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：46k
源码类别：

通讯编程

开发平台：

Visual C++

tclUtf.c：源码内容
  1. /*
  2.  * tclUtf.c --
  3.  *
  4.  * Routines for manipulating UTF-8 strings.
  5.  *
  6.  * Copyright (c) 1997-1998 Sun Microsystems, Inc.
  7.  *
  8.  * See the file "license.terms" for information on usage and redistribution
  9.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  10.  *
  11.  * RCS: @(#) $Id: tclUtf.c,v 1.30.2.3 2005/09/07 14:35:56 dgp Exp $
  12.  */
  14. #include "tclInt.h"
  16. /*
  17.  * Include the static character classification tables and macros.
  18.  */
  20. #include "tclUniData.c"
  22. /*
  23.  * The following macros are used for fast character category tests.  The
  24.  * x_BITS values are shifted right by the category value to determine whether
  25.  * the given category is included in the set.
  26.  */ 
  28. #define ALPHA_BITS ((1 << UPPERCASE_LETTER) | (1 << LOWERCASE_LETTER) 
  29.     | (1 << TITLECASE_LETTER) | (1 << MODIFIER_LETTER) | (1 << OTHER_LETTER))
  31. #define DIGIT_BITS (1 << DECIMAL_DIGIT_NUMBER)
  33. #define SPACE_BITS ((1 << SPACE_SEPARATOR) | (1 << LINE_SEPARATOR) 
  34.     | (1 << PARAGRAPH_SEPARATOR))
  36. #define CONNECTOR_BITS (1 << CONNECTOR_PUNCTUATION)
  38. #define PRINT_BITS (ALPHA_BITS | DIGIT_BITS | SPACE_BITS | 
  39.     (1 << NON_SPACING_MARK) | (1 << ENCLOSING_MARK) | 
  40.     (1 << COMBINING_SPACING_MARK) | (1 << LETTER_NUMBER) | 
  41.     (1 << OTHER_NUMBER) | (1 << CONNECTOR_PUNCTUATION) | 
  42.     (1 << DASH_PUNCTUATION) | (1 << OPEN_PUNCTUATION) | 
  43.     (1 << CLOSE_PUNCTUATION) | (1 << INITIAL_QUOTE_PUNCTUATION) | 
  44.     (1 << FINAL_QUOTE_PUNCTUATION) | (1 << OTHER_PUNCTUATION) | 
  45.     (1 << MATH_SYMBOL) | (1 << CURRENCY_SYMBOL) | 
  46.     (1 << MODIFIER_SYMBOL) | (1 << OTHER_SYMBOL))
  48. #define PUNCT_BITS ((1 << CONNECTOR_PUNCTUATION) | 
  49.     (1 << DASH_PUNCTUATION) | (1 << OPEN_PUNCTUATION) | 
  50.     (1 << CLOSE_PUNCTUATION) | (1 << INITIAL_QUOTE_PUNCTUATION) | 
  51.     (1 << FINAL_QUOTE_PUNCTUATION) | (1 << OTHER_PUNCTUATION))
  53. /*
  54.  * Unicode characters less than this value are represented by themselves 
  55.  * in UTF-8 strings. 
  56.  */
  58. #define UNICODE_SELF 0x80
  60. /*
  61.  * The following structures are used when mapping between Unicode (UCS-2)
  62.  * and UTF-8.
  63.  */
  65. static CONST unsigned char totalBytes[256] = {
  66.     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,
  67.     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,
  68.     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,
  69.     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,
  70.     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,
  71.     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,
  72.     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,
  73.     3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
  74. #if TCL_UTF_MAX > 3
  75.     4,4,4,4,4,4,4,4,
  76. #else
  77.     1,1,1,1,1,1,1,1,
  78. #endif
  79. #if TCL_UTF_MAX > 4
  80.     5,5,5,5,
  81. #else
  82.     1,1,1,1,
  83. #endif
  84. #if TCL_UTF_MAX > 5
  85.     6,6,6,6
  86. #else
  87.     1,1,1,1
  88. #endif
  89. };
  91. /*
  92.  * Procedures used only in this module.
  93.  */
  95. static int UtfCount _ANSI_ARGS_((int ch));
  98. /*
  99.  *---------------------------------------------------------------------------
  100.  *
  101.  * UtfCount --
  102.  *
  103.  * Find the number of bytes in the Utf character "ch".
  104.  *
  105.  * Results:
  106.  * The return values is the number of bytes in the Utf character "ch".
  107.  *
  108.  * Side effects:
  109.  * None.
  110.  *
  111.  *---------------------------------------------------------------------------
  112.  */
  113.  
  114. INLINE static int
  115. UtfCount(ch)
  116.     int ch; /* The Tcl_UniChar whose size is returned. */
  117. {
  118.     if ((ch > 0) && (ch < UNICODE_SELF)) {
  119. return 1;
  120.     }
  121.     if (ch <= 0x7FF) {
  122. return 2;
  123.     }
  124.     if (ch <= 0xFFFF) {
  125. return 3;
  126.     }
  127. #if TCL_UTF_MAX > 3
  128.     if (ch <= 0x1FFFFF) {
  129. return 4;
  130.     }
  131.     if (ch <= 0x3FFFFFF) {
  132. return 5;
  133.     }
  134.     if (ch <= 0x7FFFFFFF) {
  135. return 6;
  136.     }
  137. #endif
  138.     return 3;
  139. }
  141. /*
  142.  *---------------------------------------------------------------------------
  143.  *
  144.  * Tcl_UniCharToUtf --
  145.  *
  146.  * Store the given Tcl_UniChar as a sequence of UTF-8 bytes in the
  147.  * provided buffer.  Equivalent to Plan 9 runetochar().
  148.  *
  149.  * Results:
  150.  * The return values is the number of bytes in the buffer that
  151.  * were consumed.  
  152.  *
  153.  * Side effects:
  154.  * None.
  155.  *
  156.  *---------------------------------------------------------------------------
  157.  */
  158.  
  159. INLINE int
  160. Tcl_UniCharToUtf(ch, str)
  161.     int ch; /* The Tcl_UniChar to be stored in the
  162.  * buffer. */
  163.     char *str; /* Buffer in which the UTF-8 representation
  164.  * of the Tcl_UniChar is stored.  Buffer must
  165.  * be large enough to hold the UTF-8 character
  166.  * (at most TCL_UTF_MAX bytes). */
  167. {
  168.     if ((ch > 0) && (ch < UNICODE_SELF)) {
  169. str[0] = (char) ch;
  170. return 1;
  171.     }
  172.     if (ch >= 0) {
  173. if (ch <= 0x7FF) {
  174.     str[1] = (char) ((ch | 0x80) & 0xBF);
  175.     str[0] = (char) ((ch >> 6) | 0xC0);
  176.     return 2;
  177. }
  178. if (ch <= 0xFFFF) {
  179. three:
  180.     str[2] = (char) ((ch | 0x80) & 0xBF);
  181.     str[1] = (char) (((ch >> 6) | 0x80) & 0xBF);
  182.     str[0] = (char) ((ch >> 12) | 0xE0);
  183.     return 3;
  184. }
  186. #if TCL_UTF_MAX > 3
  187. if (ch <= 0x1FFFFF) {
  188.     str[3] = (char) ((ch | 0x80) & 0xBF);
  189.     str[2] = (char) (((ch >> 6) | 0x80) & 0xBF);
  190.     str[1] = (char) (((ch >> 12) | 0x80) & 0xBF);
  191.     str[0] = (char) ((ch >> 18) | 0xF0);
  192.     return 4;
  193. }
  194. if (ch <= 0x3FFFFFF) {
  195.     str[4] = (char) ((ch | 0x80) & 0xBF);
  196.     str[3] = (char) (((ch >> 6) | 0x80) & 0xBF);
  197.     str[2] = (char) (((ch >> 12) | 0x80) & 0xBF);
  198.     str[1] = (char) (((ch >> 18) | 0x80) & 0xBF);
  199.     str[0] = (char) ((ch >> 24) | 0xF8);
  200.     return 5;
  201. }
  202. if (ch <= 0x7FFFFFFF) {
  203.     str[5] = (char) ((ch | 0x80) & 0xBF);
  204.     str[4] = (char) (((ch >> 6) | 0x80) & 0xBF);
  205.     str[3] = (char) (((ch >> 12) | 0x80) & 0xBF);
  206.     str[2] = (char) (((ch >> 18) | 0x80) & 0xBF);
  207.     str[1] = (char) (((ch >> 24) | 0x80) & 0xBF);
  208.     str[0] = (char) ((ch >> 30) | 0xFC);
  209.     return 6;
  210. }
  211. #endif
  212.     }
  214.     ch = 0xFFFD;
  215.     goto three;
  216. }
  218. /*
  219.  *---------------------------------------------------------------------------
  220.  *
  221.  * Tcl_UniCharToUtfDString --
  222.  *
  223.  * Convert the given Unicode string to UTF-8.
  224.  *
  225.  * Results:
  226.  * The return value is a pointer to the UTF-8 representation of the
  227.  * Unicode string.  Storage for the return value is appended to the
  228.  * end of dsPtr.
  229.  *
  230.  * Side effects:
  231.  * None.
  232.  *
  233.  *---------------------------------------------------------------------------
  234.  */
  235.  
  236. char *
  237. Tcl_UniCharToUtfDString(wString, numChars, dsPtr)
  238.     CONST Tcl_UniChar *wString; /* Unicode string to convert to UTF-8. */
  239.     int numChars; /* Length of Unicode string in Tcl_UniChars
  240.  * (must be >= 0). */
  241.     Tcl_DString *dsPtr; /* UTF-8 representation of string is
  242.  * appended to this previously initialized
  243.  * DString. */
  244. {
  245.     CONST Tcl_UniChar *w, *wEnd;
  246.     char *p, *string;
  247.     int oldLength;
  249.     /*
  250.      * UTF-8 string length in bytes will be <= Unicode string length *
  251.      * TCL_UTF_MAX.
  252.      */
  254.     oldLength = Tcl_DStringLength(dsPtr);
  255.     Tcl_DStringSetLength(dsPtr, (oldLength + numChars + 1) * TCL_UTF_MAX);
  256.     string = Tcl_DStringValue(dsPtr) + oldLength;
  258.     p = string;
  259.     wEnd = wString + numChars;
  260.     for (w = wString; w < wEnd; ) {
  261. p += Tcl_UniCharToUtf(*w, p);
  262. w++;
  263.     }
  264.     Tcl_DStringSetLength(dsPtr, oldLength + (p - string));
  266.     return string;
  267. }
  269. /*
  270.  *---------------------------------------------------------------------------
  271.  *
  272.  * Tcl_UtfToUniChar --
  273.  *
  274.  * Extract the Tcl_UniChar represented by the UTF-8 string.  Bad
  275.  * UTF-8 sequences are converted to valid Tcl_UniChars and processing
  276.  * continues.  Equivalent to Plan 9 chartorune().
  277.  *
  278.  * The caller must ensure that the source buffer is long enough that
  279.  * this routine does not run off the end and dereference non-existent
  280.  * memory looking for trail bytes.  If the source buffer is known to
  281.  * be '' terminated, this cannot happen.  Otherwise, the caller
  282.  * should call Tcl_UtfCharComplete() before calling this routine to
  283.  * ensure that enough bytes remain in the string.
  284.  *
  285.  * Results:
  286.  * *chPtr is filled with the Tcl_UniChar, and the return value is the
  287.  * number of bytes from the UTF-8 string that were consumed.
  288.  *
  289.  * Side effects:
  290.  * None.
  291.  *
  292.  *---------------------------------------------------------------------------
  293.  */
  294.  
  295. int
  296. Tcl_UtfToUniChar(str, chPtr)
  297.     register CONST char *str;  /* The UTF-8 string. */
  298.     register Tcl_UniChar *chPtr; /* Filled with the Tcl_UniChar represented
  299.   * by the UTF-8 string. */
  300. {
  301.     register int byte;
  302.     
  303.     /*
  304.      * Unroll 1 to 3 byte UTF-8 sequences, use loop to handle longer ones.
  305.      */
  307.     byte = *((unsigned char *) str);
  308.     if (byte < 0xC0) {
  309. /*
  310.  * Handles properly formed UTF-8 characters between 0x01 and 0x7F.
  311.  * Also treats  and naked trail bytes 0x80 to 0xBF as valid
  312.  * characters representing themselves.
  313.  */
  315. *chPtr = (Tcl_UniChar) byte;
  316. return 1;
  317.     } else if (byte < 0xE0) {
  318. if ((str[1] & 0xC0) == 0x80) {
  319.     /*
  320.      * Two-byte-character lead-byte followed by a trail-byte.
  321.      */
  323.     *chPtr = (Tcl_UniChar) (((byte & 0x1F) << 6) | (str[1] & 0x3F));
  324.     return 2;
  325. }
  326. /*
  327.  * A two-byte-character lead-byte not followed by trail-byte
  328.  * represents itself.
  329.  */
  331. *chPtr = (Tcl_UniChar) byte;
  332. return 1;
  333.     } else if (byte < 0xF0) {
  334. if (((str[1] & 0xC0) == 0x80) && ((str[2] & 0xC0) == 0x80)) {
  335.     /*
  336.      * Three-byte-character lead byte followed by two trail bytes.
  337.      */
  339.     *chPtr = (Tcl_UniChar) (((byte & 0x0F) << 12) 
  340.     | ((str[1] & 0x3F) << 6) | (str[2] & 0x3F));
  341.     return 3;
  342. }
  343. /*
  344.  * A three-byte-character lead-byte not followed by two trail-bytes
  345.  * represents itself.
  346.  */
  348. *chPtr = (Tcl_UniChar) byte;
  349. return 1;
  350.     }
  351. #if TCL_UTF_MAX > 3
  352.     else {
  353. int ch, total, trail;
  355. total = totalBytes[byte];
  356. trail = total - 1;
  357. if (trail > 0) {
  358.     ch = byte & (0x3F >> trail);
  359.     do {
  360. str++;
  361. if ((*str & 0xC0) != 0x80) {
  362.     *chPtr = byte;
  363.     return 1;
  364. }
  365. ch <<= 6;
  366. ch |= (*str & 0x3F);
  367. trail--;
  368.     } while (trail > 0);
  369.     *chPtr = ch;
  370.     return total;
  371. }
  372.     }
  373. #endif
  375.     *chPtr = (Tcl_UniChar) byte;
  376.     return 1;
  377. }
  379. /*
  380.  *---------------------------------------------------------------------------
  381.  *
  382.  * Tcl_UtfToUniCharDString --
  383.  *
  384.  * Convert the UTF-8 string to Unicode.
  385.  *
  386.  * Results:
  387.  * The return value is a pointer to the Unicode representation of the
  388.  * UTF-8 string.  Storage for the return value is appended to the
  389.  * end of dsPtr.  The Unicode string is terminated with a Unicode
  390.  * NULL character.
  391.  *
  392.  * Side effects:
  393.  * None.
  394.  *
  395.  *---------------------------------------------------------------------------
  396.  */
  398. Tcl_UniChar *
  399. Tcl_UtfToUniCharDString(string, length, dsPtr)
  400.     CONST char *string; /* UTF-8 string to convert to Unicode. */
  401.     int length; /* Length of UTF-8 string in bytes, or -1
  402.  * for strlen(). */
  403.     Tcl_DString *dsPtr; /* Unicode representation of string is
  404.  * appended to this previously initialized
  405.  * DString. */
  406. {
  407.     Tcl_UniChar *w, *wString;
  408.     CONST char *p, *end;
  409.     int oldLength;
  411.     if (length < 0) {
  412. length = strlen(string);
  413.     }
  415.     /*
  416.      * Unicode string length in Tcl_UniChars will be <= UTF-8 string length
  417.      * in bytes.
  418.      */
  420.     oldLength = Tcl_DStringLength(dsPtr);
  421.     Tcl_DStringSetLength(dsPtr,
  422.     (int) ((oldLength + length + 1) * sizeof(Tcl_UniChar)));
  423.     wString = (Tcl_UniChar *) (Tcl_DStringValue(dsPtr) + oldLength);
  425.     w = wString;
  426.     end = string + length;
  427.     for (p = string; p < end; ) {
  428. p += TclUtfToUniChar(p, w);
  429. w++;
  430.     }
  431.     *w = '';
  432.     Tcl_DStringSetLength(dsPtr,
  433.     (oldLength + ((char *) w - (char *) wString)));
  435.     return wString;
  436. }
  438. /*
  439.  *---------------------------------------------------------------------------
  440.  *
  441.  * Tcl_UtfCharComplete --
  442.  *
  443.  * Determine if the UTF-8 string of the given length is long enough
  444.  * to be decoded by Tcl_UtfToUniChar().  This does not ensure that the
  445.  * UTF-8 string is properly formed.  Equivalent to Plan 9 fullrune().
  446.  *
  447.  * Results:
  448.  * The return value is 0 if the string is not long enough, non-zero
  449.  * otherwise.
  450.  *
  451.  * Side effects:
  452.  * None.
  453.  *
  454.  *---------------------------------------------------------------------------
  455.  */
  457. int
  458. Tcl_UtfCharComplete(str, len)
  459.     CONST char *str; /* String to check if first few bytes
  460.  * contain a complete UTF-8 character. */
  461.     int len; /* Length of above string in bytes. */
  462. {
  463.     int ch;
  465.     ch = *((unsigned char *) str);
  466.     return len >= totalBytes[ch];
  467. }
  469. /*
  470.  *---------------------------------------------------------------------------
  471.  *
  472.  * Tcl_NumUtfChars --
  473.  *
  474.  * Returns the number of characters (not bytes) in the UTF-8 string,
  475.  * not including the terminating NULL byte.  This is equivalent to
  476.  * Plan 9 utflen() and utfnlen().
  477.  *
  478.  * Results:
  479.  * As above.  
  480.  *
  481.  * Side effects:
  482.  * None.
  483.  *
  484.  *---------------------------------------------------------------------------
  485.  */
  486.  
  487. int 
  488. Tcl_NumUtfChars(str, len)
  489.     register CONST char *str; /* The UTF-8 string to measure. */
  490.     int len; /* The length of the string in bytes, or -1
  491.  * for strlen(string). */
  492. {
  493.     Tcl_UniChar ch;
  494.     register Tcl_UniChar *chPtr = &ch;
  495.     register int i;
  497.     /*
  498.      * The separate implementations are faster.
  499.      *
  500.      * Since this is a time-sensitive function, we also do the check for
  501.      * the single-byte char case specially.
  502.      */
  504.     i = 0;
  505.     if (len < 0) {
  506. while (*str != '') {
  507.     str += TclUtfToUniChar(str, chPtr);
  508.     i++;
  509. }
  510.     } else {
  511. register int n;
  513. while (len > 0) {
  514.     if (UCHAR(*str) < 0xC0) {
  515. len--;
  516. str++;
  517.     } else {
  518. n = Tcl_UtfToUniChar(str, chPtr);
  519. len -= n;
  520. str += n;
  521.     }
  522.     i++;
  523. }
  524.     }
  525.     return i;
  526. }
  528. /*
  529.  *---------------------------------------------------------------------------
  530.  *
  531.  * Tcl_UtfFindFirst --
  532.  *
  533.  * Returns a pointer to the first occurance of the given Tcl_UniChar
  534.  * in the NULL-terminated UTF-8 string.  The NULL terminator is
  535.  * considered part of the UTF-8 string.  Equivalent to Plan 9
  536.  * utfrune().
  537.  *
  538.  * Results:
  539.  * As above.  If the Tcl_UniChar does not exist in the given string,
  540.  * the return value is NULL.
  541.  *
  542.  * Side effects:
  543.  * None.
  544.  *
  545.  *---------------------------------------------------------------------------
  546.  */
  547. CONST char *
  548. Tcl_UtfFindFirst(string, ch)
  549.     CONST char *string; /* The UTF-8 string to be searched. */
  550.     int ch; /* The Tcl_UniChar to search for. */
  551. {
  552.     int len;
  553.     Tcl_UniChar find;
  554.     
  555.     while (1) {
  556. len = TclUtfToUniChar(string, &find);
  557. if (find == ch) {
  558.     return string;
  559. }
  560. if (*string == '') {
  561.     return NULL;
  562. }
  563. string += len;
  564.     }
  565. }
  567. /*
  568.  *---------------------------------------------------------------------------
  569.  *
  570.  * Tcl_UtfFindLast --
  571.  *
  572.  * Returns a pointer to the last occurance of the given Tcl_UniChar
  573.  * in the NULL-terminated UTF-8 string.  The NULL terminator is
  574.  * considered part of the UTF-8 string.  Equivalent to Plan 9
  575.  * utfrrune().
  576.  *
  577.  * Results:
  578.  * As above.  If the Tcl_UniChar does not exist in the given string,
  579.  * the return value is NULL.
  580.  *
  581.  * Side effects:
  582.  * None.
  583.  *
  584.  *---------------------------------------------------------------------------
  585.  */
  587. CONST char *
  588. Tcl_UtfFindLast(string, ch)
  589.     CONST char *string; /* The UTF-8 string to be searched. */
  590.     int ch; /* The Tcl_UniChar to search for. */
  591. {
  592.     int len;
  593.     Tcl_UniChar find;
  594.     CONST char *last;
  596.     last = NULL;
  597.     while (1) {
  598. len = TclUtfToUniChar(string, &find);
  599. if (find == ch) {
  600.     last = string;
  601. }
  602. if (*string == '') {
  603.     break;
  604. }
  605. string += len;
  606.     }
  607.     return last;
  608. }
  610. /*
  611.  *---------------------------------------------------------------------------
  612.  *
  613.  * Tcl_UtfNext --
  614.  *
  615.  * Given a pointer to some current location in a UTF-8 string,
  616.  * move forward one character.  The caller must ensure that they
  617.  * are not asking for the next character after the last character
  618.  * in the string.
  619.  *
  620.  * Results:
  621.  * The return value is the pointer to the next character in
  622.  * the UTF-8 string.
  623.  *
  624.  * Side effects:
  625.  * None.
  626.  *
  627.  *---------------------------------------------------------------------------
  628.  */
  629.  
  630. CONST char *
  631. Tcl_UtfNext(str) 
  632.     CONST char *str;     /* The current location in the string. */
  633. {
  634.     Tcl_UniChar ch;
  636.     return str + TclUtfToUniChar(str, &ch);
  637. }
  639. /*
  640.  *---------------------------------------------------------------------------
  641.  *
  642.  * Tcl_UtfPrev --
  643.  *
  644.  * Given a pointer to some current location in a UTF-8 string,
  645.  * move backwards one character.  This works correctly when the
  646.  * pointer is in the middle of a UTF-8 character.
  647.  *
  648.  * Results:
  649.  * The return value is a pointer to the previous character in the
  650.  * UTF-8 string.  If the current location was already at the
  651.  * beginning of the string, the return value will also be a
  652.  * pointer to the beginning of the string.
  653.  *
  654.  * Side effects:
  655.  * None.
  656.  *
  657.  *---------------------------------------------------------------------------
  658.  */
  660. CONST char *
  661. Tcl_UtfPrev(str, start)
  662.     CONST char *str;     /* The current location in the string. */
  663.     CONST char *start;     /* Pointer to the beginning of the
  664.      * string, to avoid going backwards too
  665.      * far. */
  666. {
  667.     CONST char *look;
  668.     int i, byte;
  669.     
  670.     str--;
  671.     look = str;
  672.     for (i = 0; i < TCL_UTF_MAX; i++) {
  673. if (look < start) {
  674.     if (str < start) {
  675. str = start;
  676.     }
  677.     break;
  678. }
  679. byte = *((unsigned char *) look);
  680. if (byte < 0x80) {
  681.     break;
  682. }
  683. if (byte >= 0xC0) {
  684.     return look;
  685. }
  686. look--;
  687.     }
  688.     return str;
  689. }
  691. /*
  692.  *---------------------------------------------------------------------------
  693.  *
  694.  * Tcl_UniCharAtIndex --
  695.  *
  696.  * Returns the Unicode character represented at the specified
  697.  * character (not byte) position in the UTF-8 string.
  698.  *
  699.  * Results:
  700.  * As above.
  701.  *
  702.  * Side effects:
  703.  * None.
  704.  *
  705.  *---------------------------------------------------------------------------
  706.  */
  707.  
  708. Tcl_UniChar
  709. Tcl_UniCharAtIndex(src, index)
  710.     register CONST char *src; /* The UTF-8 string to dereference. */
  711.     register int index; /* The position of the desired character. */
  712. {
  713.     Tcl_UniChar ch;
  715.     while (index >= 0) {
  716. index--;
  717. src += TclUtfToUniChar(src, &ch);
  718.     }
  719.     return ch;
  720. }
  722. /*
  723.  *---------------------------------------------------------------------------
  724.  *
  725.  * Tcl_UtfAtIndex --
  726.  *
  727.  * Returns a pointer to the specified character (not byte) position
  728.  * in the UTF-8 string.
  729.  *
  730.  * Results:
  731.  * As above.
  732.  *
  733.  * Side effects:
  734.  * None.
  735.  *
  736.  *---------------------------------------------------------------------------
  737.  */
  739. CONST char *
  740. Tcl_UtfAtIndex(src, index)
  741.     register CONST char *src; /* The UTF-8 string. */
  742.     register int index; /* The position of the desired character. */
  743. {
  744.     Tcl_UniChar ch;
  745.     
  746.     while (index > 0) {
  747. index--;
  748. src += TclUtfToUniChar(src, &ch);
  749.     }
  750.     return src;
  751. }
  753. /*
  754.  *---------------------------------------------------------------------------
  755.  *
  756.  * Tcl_UtfBackslash --
  757.  *
  758.  * Figure out how to handle a backslash sequence.
  759.  *
  760.  * Results:
  761.  * Stores the bytes represented by the backslash sequence in dst and
  762.  * returns the number of bytes written to dst.  At most TCL_UTF_MAX
  763.  * bytes are written to dst; dst must have been large enough to accept
  764.  * those bytes.  If readPtr isn't NULL then it is filled in with a
  765.  * count of the number of bytes in the backslash sequence.  
  766.  *
  767.  * Side effects:
  768.  * The maximum number of bytes it takes to represent a Unicode
  769.  * character in UTF-8 is guaranteed to be less than the number of
  770.  * bytes used to express the backslash sequence that represents
  771.  * that Unicode character.  If the target buffer into which the
  772.  * caller is going to store the bytes that represent the Unicode
  773.  * character is at least as large as the source buffer from which
  774.  * the backslashed sequence was extracted, no buffer overruns should
  775.  * occur.
  776.  *
  777.  *---------------------------------------------------------------------------
  778.  */
  780. int
  781. Tcl_UtfBackslash(src, readPtr, dst)
  782.     CONST char *src; /* Points to the backslash character of
  783.  * a backslash sequence. */
  784.     int *readPtr; /* Fill in with number of characters read
  785.  * from src, unless NULL. */
  786.     char *dst; /* Filled with the bytes represented by the
  787.  * backslash sequence. */
  788. {
  789. #define LINE_LENGTH 128
  790.     int numRead;
  791.     int result;
  793.     result = TclParseBackslash(src, LINE_LENGTH, &numRead, dst);
  794.     if (numRead == LINE_LENGTH) {
  795. /* We ate a whole line.  Pay the price of a strlen() */
  796. result = TclParseBackslash(src, (int)strlen(src), &numRead, dst);
  797.     }
  798.     if (readPtr != NULL) {
  799. *readPtr = numRead;
  800.     }
  801.     return result;
  802. }
  804. /*
  805.  *----------------------------------------------------------------------
  806.  *
  807.  * Tcl_UtfToUpper --
  808.  *
  809.  * Convert lowercase characters to uppercase characters in a UTF
  810.  * string in place.  The conversion may shrink the UTF string.
  811.  *
  812.  * Results:
  813.  * Returns the number of bytes in the resulting string
  814.  * excluding the trailing null.
  815.  *
  816.  * Side effects:
  817.  * Writes a terminating null after the last converted character.
  818.  *
  819.  *----------------------------------------------------------------------
  820.  */
  822. int
  823. Tcl_UtfToUpper(str)
  824.     char *str; /* String to convert in place. */
  825. {
  826.     Tcl_UniChar ch, upChar;
  827.     char *src, *dst;
  828.     int bytes;
  830.     /*
  831.      * Iterate over the string until we hit the terminating null.
  832.      */
  834.     src = dst = str;
  835.     while (*src) {
  836.         bytes = TclUtfToUniChar(src, &ch);
  837. upChar = Tcl_UniCharToUpper(ch);
  839. /*
  840.  * To keep badly formed Utf strings from getting inflated by
  841.  * the conversion (thereby causing a segfault), only copy the
  842.  * upper case char to dst if its size is <= the original char.
  843.  */
  845. if (bytes < UtfCount(upChar)) {
  846.     memcpy(dst, src, (size_t) bytes);
  847.     dst += bytes;
  848. } else {
  849.     dst += Tcl_UniCharToUtf(upChar, dst);
  850. }
  851. src += bytes;
  852.     }
  853.     *dst = '';
  854.     return (dst - str);
  855. }
  857. /*
  858.  *----------------------------------------------------------------------
  859.  *
  860.  * Tcl_UtfToLower --
  861.  *
  862.  * Convert uppercase characters to lowercase characters in a UTF
  863.  * string in place.  The conversion may shrink the UTF string.
  864.  *
  865.  * Results:
  866.  * Returns the number of bytes in the resulting string
  867.  * excluding the trailing null.
  868.  *
  869.  * Side effects:
  870.  * Writes a terminating null after the last converted character.
  871.  *
  872.  *----------------------------------------------------------------------
  873.  */
  875. int
  876. Tcl_UtfToLower(str)
  877.     char *str; /* String to convert in place. */
  878. {
  879.     Tcl_UniChar ch, lowChar;
  880.     char *src, *dst;
  881.     int bytes;
  882.     
  883.     /*
  884.      * Iterate over the string until we hit the terminating null.
  885.      */
  887.     src = dst = str;
  888.     while (*src) {
  889. bytes = TclUtfToUniChar(src, &ch);
  890. lowChar = Tcl_UniCharToLower(ch);
  892. /*
  893.  * To keep badly formed Utf strings from getting inflated by
  894.  * the conversion (thereby causing a segfault), only copy the
  895.  * lower case char to dst if its size is <= the original char.
  896.  */
  898. if (bytes < UtfCount(lowChar)) {
  899.     memcpy(dst, src, (size_t) bytes);
  900.     dst += bytes;
  901. } else {
  902.     dst += Tcl_UniCharToUtf(lowChar, dst);
  903. }
  904. src += bytes;
  905.     }
  906.     *dst = '';
  907.     return (dst - str);
  908. }
  910. /*
  911.  *----------------------------------------------------------------------
  912.  *
  913.  * Tcl_UtfToTitle --
  914.  *
  915.  * Changes the first character of a UTF string to title case or
  916.  * uppercase and the rest of the string to lowercase.  The
  917.  * conversion happens in place and may shrink the UTF string.
  918.  *
  919.  * Results:
  920.  * Returns the number of bytes in the resulting string
  921.  * excluding the trailing null.
  922.  *
  923.  * Side effects:
  924.  * Writes a terminating null after the last converted character.
  925.  *
  926.  *----------------------------------------------------------------------
  927.  */
  929. int
  930. Tcl_UtfToTitle(str)
  931.     char *str; /* String to convert in place. */
  932. {
  933.     Tcl_UniChar ch, titleChar, lowChar;
  934.     char *src, *dst;
  935.     int bytes;
  936.     
  937.     /*
  938.      * Capitalize the first character and then lowercase the rest of the
  939.      * characters until we get to a null.
  940.      */
  942.     src = dst = str;
  944.     if (*src) {
  945. bytes = TclUtfToUniChar(src, &ch);
  946. titleChar = Tcl_UniCharToTitle(ch);
  948. if (bytes < UtfCount(titleChar)) {
  949.     memcpy(dst, src, (size_t) bytes);
  950.     dst += bytes;
  951. } else {
  952.     dst += Tcl_UniCharToUtf(titleChar, dst);
  953. }
  954. src += bytes;
  955.     }
  956.     while (*src) {
  957. bytes = TclUtfToUniChar(src, &ch);
  958. lowChar = Tcl_UniCharToLower(ch);
  960. if (bytes < UtfCount(lowChar)) {
  961.     memcpy(dst, src, (size_t) bytes);
  962.     dst += bytes;
  963. } else {
  964.     dst += Tcl_UniCharToUtf(lowChar, dst);
  965. }
  966. src += bytes;
  967.     }
  968.     *dst = '';
  969.     return (dst - str);
  970. }
  972. /*
  973.  *----------------------------------------------------------------------
  974.  *
  975.  * TclpUtfNcmp2 --
  976.  *
  977.  * Compare at most n bytes of utf-8 strings cs and ct.  Both cs
  978.  * and ct are assumed to be at least n bytes long.
  979.  *
  980.  * Results:
  981.  * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
  982.  *
  983.  * Side effects:
  984.  * None.
  985.  *
  986.  *----------------------------------------------------------------------
  987.  */
  989. int
  990. TclpUtfNcmp2(cs, ct, n)
  991.     CONST char *cs; /* UTF string to compare to ct. */
  992.     CONST char *ct; /* UTF string cs is compared to. */
  993.     unsigned long n; /* Number of *bytes* to compare. */
  994. {
  995.     /*
  996.      * We can't simply call 'memcmp(cs, ct, n);' because we need to check
  997.      * for Tcl's xC0x80 non-utf-8 null encoding.
  998.      * Otherwise utf-8 lexes fine in the strcmp manner.
  999.      */
  1000.     register int result = 0;
  1002.     for ( ; n != 0; n--, cs++, ct++) {
  1003. if (*cs != *ct) {
  1004.     result = UCHAR(*cs) - UCHAR(*ct);
  1005.     break;
  1006. }
  1007.     }
  1008.     if (n && ((UCHAR(*cs) == 0xC0) || (UCHAR(*ct) == 0xC0))) {
  1009. unsigned char c1, c2;
  1010. c1 = ((UCHAR(*cs) == 0xC0) && (UCHAR(cs[1]) == 0x80)) ? 0 : UCHAR(*cs);
  1011. c2 = ((UCHAR(*ct) == 0xC0) && (UCHAR(ct[1]) == 0x80)) ? 0 : UCHAR(*ct);
  1012. result = (c1 - c2);
  1013.     }
  1014.     return result;
  1015. }
  1017. /*
  1018.  *----------------------------------------------------------------------
  1019.  *
  1020.  * Tcl_UtfNcmp --
  1021.  *
  1022.  * Compare at most n UTF chars of string cs to string ct.  Both cs
  1023.  * and ct are assumed to be at least n UTF chars long.
  1024.  *
  1025.  * Results:
  1026.  * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
  1027.  *
  1028.  * Side effects:
  1029.  * None.
  1030.  *
  1031.  *----------------------------------------------------------------------
  1032.  */
  1034. int
  1035. Tcl_UtfNcmp(cs, ct, n)
  1036.     CONST char *cs; /* UTF string to compare to ct. */
  1037.     CONST char *ct; /* UTF string cs is compared to. */
  1038.     unsigned long n; /* Number of UTF chars to compare. */
  1039. {
  1040.     Tcl_UniChar ch1, ch2;
  1041.     /*
  1042.      * Cannot use 'memcmp(cs, ct, n);' as byte representation of
  1043.      * u0000 (the pair of bytes 0xc0,0x80) is larger than byte
  1044.      * representation of u0001 (the byte 0x01.)
  1045.      */
  1046.     while (n-- > 0) {
  1047. /*
  1048.  * n must be interpreted as chars, not bytes.
  1049.  * This should be called only when both strings are of
  1050.  * at least n chars long (no need for  check)
  1051.  */
  1052. cs += TclUtfToUniChar(cs, &ch1);
  1053. ct += TclUtfToUniChar(ct, &ch2);
  1054. if (ch1 != ch2) {
  1055.     return (ch1 - ch2);
  1056. }
  1057.     }
  1058.     return 0;
  1059. }
  1061. /*
  1062.  *----------------------------------------------------------------------
  1063.  *
  1064.  * Tcl_UtfNcasecmp --
  1065.  *
  1066.  * Compare at most n UTF chars of string cs to string ct case
  1067.  * insensitive.  Both cs and ct are assumed to be at least n
  1068.  * UTF chars long.
  1069.  *
  1070.  * Results:
  1071.  * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
  1072.  *
  1073.  * Side effects:
  1074.  * None.
  1075.  *
  1076.  *----------------------------------------------------------------------
  1077.  */
  1079. int
  1080. Tcl_UtfNcasecmp(cs, ct, n)
  1081.     CONST char *cs; /* UTF string to compare to ct. */
  1082.     CONST char *ct; /* UTF string cs is compared to. */
  1083.     unsigned long n; /* Number of UTF chars to compare. */
  1084. {
  1085.     Tcl_UniChar ch1, ch2;
  1086.     while (n-- > 0) {
  1087. /*
  1088.  * n must be interpreted as chars, not bytes.
  1089.  * This should be called only when both strings are of
  1090.  * at least n chars long (no need for  check)
  1091.  */
  1092. cs += TclUtfToUniChar(cs, &ch1);
  1093. ct += TclUtfToUniChar(ct, &ch2);
  1094. if (ch1 != ch2) {
  1095.     ch1 = Tcl_UniCharToLower(ch1);
  1096.     ch2 = Tcl_UniCharToLower(ch2);
  1097.     if (ch1 != ch2) {
  1098. return (ch1 - ch2);
  1099.     }
  1100. }
  1101.     }
  1102.     return 0;
  1103. }
  1105. /*
  1106.  *----------------------------------------------------------------------
  1107.  *
  1108.  * Tcl_UniCharToUpper --
  1109.  *
  1110.  * Compute the uppercase equivalent of the given Unicode character.
  1111.  *
  1112.  * Results:
  1113.  * Returns the uppercase Unicode character.
  1114.  *
  1115.  * Side effects:
  1116.  * None.
  1117.  *
  1118.  *----------------------------------------------------------------------
  1119.  */
  1121. Tcl_UniChar
  1122. Tcl_UniCharToUpper(ch)
  1123.     int ch; /* Unicode character to convert. */
  1124. {
  1125.     int info = GetUniCharInfo(ch);
  1127.     if (GetCaseType(info) & 0x04) {
  1128. return (Tcl_UniChar) (ch - GetDelta(info));
  1129.     } else {
  1130. return ch;
  1131.     }
  1132. }
  1134. /*
  1135.  *----------------------------------------------------------------------
  1136.  *
  1137.  * Tcl_UniCharToLower --
  1138.  *
  1139.  * Compute the lowercase equivalent of the given Unicode character.
  1140.  *
  1141.  * Results:
  1142.  * Returns the lowercase Unicode character.
  1143.  *
  1144.  * Side effects:
  1145.  * None.
  1146.  *
  1147.  *----------------------------------------------------------------------
  1148.  */
  1150. Tcl_UniChar
  1151. Tcl_UniCharToLower(ch)
  1152.     int ch; /* Unicode character to convert. */
  1153. {
  1154.     int info = GetUniCharInfo(ch);
  1156.     if (GetCaseType(info) & 0x02) {
  1157. return (Tcl_UniChar) (ch + GetDelta(info));
  1158.     } else {
  1159. return ch;
  1160.     }
  1161. }
  1163. /*
  1164.  *----------------------------------------------------------------------
  1165.  *
  1166.  * Tcl_UniCharToTitle --
  1167.  *
  1168.  * Compute the titlecase equivalent of the given Unicode character.
  1169.  *
  1170.  * Results:
  1171.  * Returns the titlecase Unicode character.
  1172.  *
  1173.  * Side effects:
  1174.  * None.
  1175.  *
  1176.  *----------------------------------------------------------------------
  1177.  */
  1179. Tcl_UniChar
  1180. Tcl_UniCharToTitle(ch)
  1181.     int ch; /* Unicode character to convert. */
  1182. {
  1183.     int info = GetUniCharInfo(ch);
  1184.     int mode = GetCaseType(info);
  1186.     if (mode & 0x1) {
  1187. /*
  1188.  * Subtract or add one depending on the original case.
  1189.  */
  1191. return (Tcl_UniChar) (ch + ((mode & 0x4) ? -1 : 1));
  1192.     } else if (mode == 0x4) {
  1193. return (Tcl_UniChar) (ch - GetDelta(info));
  1194.     } else {
  1195. return ch;
  1196.     }
  1197. }
  1199. /*
  1200.  *----------------------------------------------------------------------
  1201.  *
  1202.  * Tcl_UniCharLen --
  1203.  *
  1204.  * Find the length of a UniChar string.  The str input must be null
  1205.  * terminated.
  1206.  *
  1207.  * Results:
  1208.  * Returns the length of str in UniChars (not bytes).
  1209.  *
  1210.  * Side effects:
  1211.  * None.
  1212.  *
  1213.  *----------------------------------------------------------------------
  1214.  */
  1216. int
  1217. Tcl_UniCharLen(str)
  1218.     CONST Tcl_UniChar *str; /* Unicode string to find length of. */
  1219. {
  1220.     int len = 0;
  1221.     
  1222.     while (*str != '') {
  1223. len++;
  1224. str++;
  1225.     }
  1226.     return len;
  1227. }
  1229. /*
  1230.  *----------------------------------------------------------------------
  1231.  *
  1232.  * Tcl_UniCharNcmp --
  1233.  *
  1234.  * Compare at most n unichars of string cs to string ct.  Both cs
  1235.  * and ct are assumed to be at least n unichars long.
  1236.  *
  1237.  * Results:
  1238.  * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
  1239.  *
  1240.  * Side effects:
  1241.  * None.
  1242.  *
  1243.  *----------------------------------------------------------------------
  1244.  */
  1246. int
  1247. Tcl_UniCharNcmp(cs, ct, n)
  1248.     CONST Tcl_UniChar *cs; /* Unicode string to compare to ct. */
  1249.     CONST Tcl_UniChar *ct; /* Unicode string cs is compared to. */
  1250.     unsigned long n; /* Number of unichars to compare. */
  1251. {
  1252. #ifdef WORDS_BIGENDIAN
  1253.     /*
  1254.      * We are definitely on a big-endian machine; memcmp() is safe
  1255.      */
  1256.     return memcmp(cs, ct, n*sizeof(Tcl_UniChar));
  1258. #else /* !WORDS_BIGENDIAN */
  1259.     /*
  1260.      * We can't simply call memcmp() because that is not lexically correct.
  1261.      */
  1262.     for ( ; n != 0; cs++, ct++, n--) {
  1263. if (*cs != *ct) {
  1264.     return (*cs - *ct);
  1265. }
  1266.     }
  1267.     return 0;
  1268. #endif /* WORDS_BIGENDIAN */
  1269. }
  1271. /*
  1272.  *----------------------------------------------------------------------
  1273.  *
  1274.  * Tcl_UniCharNcasecmp --
  1275.  *
  1276.  * Compare at most n unichars of string cs to string ct case
  1277.  * insensitive.  Both cs and ct are assumed to be at least n
  1278.  * unichars long.
  1279.  *
  1280.  * Results:
  1281.  * Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
  1282.  *
  1283.  * Side effects:
  1284.  * None.
  1285.  *
  1286.  *----------------------------------------------------------------------
  1287.  */
  1289. int
  1290. Tcl_UniCharNcasecmp(cs, ct, n)
  1291.     CONST Tcl_UniChar *cs; /* Unicode string to compare to ct. */
  1292.     CONST Tcl_UniChar *ct; /* Unicode string cs is compared to. */
  1293.     unsigned long n; /* Number of unichars to compare. */
  1294. {
  1295.     for ( ; n != 0; n--, cs++, ct++) {
  1296. if (*cs != *ct) {
  1297.     Tcl_UniChar lcs = Tcl_UniCharToLower(*cs);
  1298.     Tcl_UniChar lct = Tcl_UniCharToLower(*ct);
  1299.     if (lcs != lct) {
  1300. return (lcs - lct);
  1301.     }
  1302. }
  1303.     }
  1304.     return 0;
  1305. }
  1307. /*
  1308.  *----------------------------------------------------------------------
  1309.  *
  1310.  * Tcl_UniCharIsAlnum --
  1311.  *
  1312.  * Test if a character is an alphanumeric Unicode character.
  1313.  *
  1314.  * Results:
  1315.  * Returns 1 if character is alphanumeric.
  1316.  *
  1317.  * Side effects:
  1318.  * None.
  1319.  *
  1320.  *----------------------------------------------------------------------
  1321.  */
  1323. int
  1324. Tcl_UniCharIsAlnum(ch)
  1325.     int ch; /* Unicode character to test. */
  1326. {
  1327.     register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK);
  1329.     return (((ALPHA_BITS | DIGIT_BITS) >> category) & 1);
  1330. }
  1332. /*
  1333.  *----------------------------------------------------------------------
  1334.  *
  1335.  * Tcl_UniCharIsAlpha --
  1336.  *
  1337.  * Test if a character is an alphabetic Unicode character.
  1338.  *
  1339.  * Results:
  1340.  * Returns 1 if character is alphabetic.
  1341.  *
  1342.  * Side effects:
  1343.  * None.
  1344.  *
  1345.  *----------------------------------------------------------------------
  1346.  */
  1348. int
  1349. Tcl_UniCharIsAlpha(ch)
  1350.     int ch; /* Unicode character to test. */
  1351. {
  1352.     register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK);
  1353.     return ((ALPHA_BITS >> category) & 1);
  1354. }
  1356. /*
  1357.  *----------------------------------------------------------------------
  1358.  *
  1359.  * Tcl_UniCharIsControl --
  1360.  *
  1361.  * Test if a character is a Unicode control character.
  1362.  *
  1363.  * Results:
  1364.  * Returns non-zero if character is a control.
  1365.  *
  1366.  * Side effects:
  1367.  * None.
  1368.  *
  1369.  *----------------------------------------------------------------------
  1370.  */
  1372. int
  1373. Tcl_UniCharIsControl(ch)
  1374.     int ch; /* Unicode character to test. */
  1375. {
  1376.     return ((GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK) == CONTROL);
  1377. }
  1379. /*
  1380.  *----------------------------------------------------------------------
  1381.  *
  1382.  * Tcl_UniCharIsDigit --
  1383.  *
  1384.  * Test if a character is a numeric Unicode character.
  1385.  *
  1386.  * Results:
  1387.  * Returns non-zero if character is a digit.
  1388.  *
  1389.  * Side effects:
  1390.  * None.
  1391.  *
  1392.  *----------------------------------------------------------------------
  1393.  */
  1395. int
  1396. Tcl_UniCharIsDigit(ch)
  1397.     int ch; /* Unicode character to test. */
  1398. {
  1399.     return ((GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK)
  1400.     == DECIMAL_DIGIT_NUMBER);
  1401. }
  1403. /*
  1404.  *----------------------------------------------------------------------
  1405.  *
  1406.  * Tcl_UniCharIsGraph --
  1407.  *
  1408.  * Test if a character is any Unicode print character except space.
  1409.  *
  1410.  * Results:
  1411.  * Returns non-zero if character is printable, but not space.
  1412.  *
  1413.  * Side effects:
  1414.  * None.
  1415.  *
  1416.  *----------------------------------------------------------------------
  1417.  */
  1419. int
  1420. Tcl_UniCharIsGraph(ch)
  1421.     int ch; /* Unicode character to test. */
  1422. {
  1423.     register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK);
  1424.     return (((PRINT_BITS >> category) & 1) && ((unsigned char) ch != ' '));
  1425. }
  1427. /*
  1428.  *----------------------------------------------------------------------
  1429.  *
  1430.  * Tcl_UniCharIsLower --
  1431.  *
  1432.  * Test if a character is a lowercase Unicode character.
  1433.  *
  1434.  * Results:
  1435.  * Returns non-zero if character is lowercase.
  1436.  *
  1437.  * Side effects:
  1438.  * None.
  1439.  *
  1440.  *----------------------------------------------------------------------
  1441.  */
  1443. int
  1444. Tcl_UniCharIsLower(ch)
  1445.     int ch; /* Unicode character to test. */
  1446. {
  1447.     return ((GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK) == LOWERCASE_LETTER);
  1448. }
  1450. /*
  1451.  *----------------------------------------------------------------------
  1452.  *
  1453.  * Tcl_UniCharIsPrint --
  1454.  *
  1455.  * Test if a character is a Unicode print character.
  1456.  *
  1457.  * Results:
  1458.  * Returns non-zero if character is printable.
  1459.  *
  1460.  * Side effects:
  1461.  * None.
  1462.  *
  1463.  *----------------------------------------------------------------------
  1464.  */
  1466. int
  1467. Tcl_UniCharIsPrint(ch)
  1468.     int ch; /* Unicode character to test. */
  1469. {
  1470.     register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK);
  1471.     return ((PRINT_BITS >> category) & 1);
  1472. }
  1474. /*
  1475.  *----------------------------------------------------------------------
  1476.  *
  1477.  * Tcl_UniCharIsPunct --
  1478.  *
  1479.  * Test if a character is a Unicode punctuation character.
  1480.  *
  1481.  * Results:
  1482.  * Returns non-zero if character is punct.
  1483.  *
  1484.  * Side effects:
  1485.  * None.
  1486.  *
  1487.  *----------------------------------------------------------------------
  1488.  */
  1490. int
  1491. Tcl_UniCharIsPunct(ch)
  1492.     int ch; /* Unicode character to test. */
  1493. {
  1494.     register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK);
  1495.     return ((PUNCT_BITS >> category) & 1);
  1496. }
  1498. /*
  1499.  *----------------------------------------------------------------------
  1500.  *
  1501.  * Tcl_UniCharIsSpace --
  1502.  *
  1503.  * Test if a character is a whitespace Unicode character.
  1504.  *
  1505.  * Results:
  1506.  * Returns non-zero if character is a space.
  1507.  *
  1508.  * Side effects:
  1509.  * None.
  1510.  *
  1511.  *----------------------------------------------------------------------
  1512.  */
  1514. int
  1515. Tcl_UniCharIsSpace(ch)
  1516.     int ch; /* Unicode character to test. */
  1517. {
  1518.     register int category;
  1520.     /*
  1521.      * If the character is within the first 127 characters, just use the
  1522.      * standard C function, otherwise consult the Unicode table.
  1523.      */
  1525.     if (ch < 0x80) {
  1526. return isspace(UCHAR(ch)); /* INTL: ISO space */
  1527.     } else {
  1528. category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK);
  1529. return ((SPACE_BITS >> category) & 1);
  1530.     }
  1531. }
  1533. /*
  1534.  *----------------------------------------------------------------------
  1535.  *
  1536.  * Tcl_UniCharIsUpper --
  1537.  *
  1538.  * Test if a character is a uppercase Unicode character.
  1539.  *
  1540.  * Results:
  1541.  * Returns non-zero if character is uppercase.
  1542.  *
  1543.  * Side effects:
  1544.  * None.
  1545.  *
  1546.  *----------------------------------------------------------------------
  1547.  */
  1549. int
  1550. Tcl_UniCharIsUpper(ch)
  1551.     int ch; /* Unicode character to test. */
  1552. {
  1553.     return ((GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK) == UPPERCASE_LETTER);
  1554. }
  1556. /*
  1557.  *----------------------------------------------------------------------
  1558.  *
  1559.  * Tcl_UniCharIsWordChar --
  1560.  *
  1561.  * Test if a character is alphanumeric or a connector punctuation
  1562.  * mark.
  1563.  *
  1564.  * Results:
  1565.  * Returns 1 if character is a word character.
  1566.  *
  1567.  * Side effects:
  1568.  * None.
  1569.  *
  1570.  *----------------------------------------------------------------------
  1571.  */
  1573. int
  1574. Tcl_UniCharIsWordChar(ch)
  1575.     int ch; /* Unicode character to test. */
  1576. {
  1577.     register int category = (GetUniCharInfo(ch) & UNICODE_CATEGORY_MASK);
  1579.     return (((ALPHA_BITS | DIGIT_BITS | CONNECTOR_BITS) >> category) & 1);
  1580. }
  1582. /*
  1583.  *----------------------------------------------------------------------
  1584.  *
  1585.  * Tcl_UniCharCaseMatch --
  1586.  *
  1587.  * See if a particular Unicode string matches a particular pattern.
  1588.  * Allows case insensitivity.  This is the Unicode equivalent of
  1589.  * the char* Tcl_StringCaseMatch.  The UniChar strings must be
  1590.  * NULL-terminated.  This has no provision for counted UniChar
  1591.  * strings, thus should not be used where NULLs are expected in the
  1592.  * UniChar string.  Use TclUniCharMatch where possible.
  1593.  *
  1594.  * Results:
  1595.  * The return value is 1 if string matches pattern, and
  1596.  * 0 otherwise.  The matching operation permits the following
  1597.  * special characters in the pattern: *?[] (see the manual
  1598.  * entry for details on what these mean).
  1599.  *
  1600.  * Side effects:
  1601.  * None.
  1602.  *
  1603.  *----------------------------------------------------------------------
  1604.  */
  1606. int
  1607. Tcl_UniCharCaseMatch(string, pattern, nocase)
  1608.     CONST Tcl_UniChar *string; /* Unicode String. */
  1609.     CONST Tcl_UniChar *pattern; /* Pattern, which may contain special
  1610.  * characters. */
  1611.     int nocase; /* 0 for case sensitive, 1 for insensitive */
  1612. {
  1613.     Tcl_UniChar ch1, p;
  1614.     
  1615.     while (1) {
  1616. p = *pattern;
  1618. /*
  1619.  * See if we're at the end of both the pattern and the string.  If
  1620.  * so, we succeeded.  If we're at the end of the pattern but not at
  1621.  * the end of the string, we failed.
  1622.  */
  1624. if (p == 0) {
  1625.     return (*string == 0);
  1626. }
  1627. if ((*string == 0) && (p != '*')) {
  1628.     return 0;
  1629. }
  1631. /*
  1632.  * Check for a "*" as the next pattern character.  It matches any
  1633.  * substring.  We handle this by skipping all the characters up to the
  1634.  * next matching one in the pattern, and then calling ourselves
  1635.  * recursively for each postfix of string, until either we match or we
  1636.  * reach the end of the string.
  1637.  */
  1639. if (p == '*') {
  1640.     /*
  1641.      * Skip all successive *'s in the pattern
  1642.      */
  1643.     while (*(++pattern) == '*') {}
  1644.     p = *pattern;
  1645.     if (p == 0) {
  1646. return 1;
  1647.     }
  1648.     if (nocase) {
  1649. p = Tcl_UniCharToLower(p);
  1650.     }
  1651.     while (1) {
  1652. /*
  1653.  * Optimization for matching - cruise through the string
  1654.  * quickly if the next char in the pattern isn't a special
  1655.  * character
  1656.  */
  1657. if ((p != '[') && (p != '?') && (p != '\')) {
  1658.     if (nocase) {
  1659. while (*string && (p != *string)
  1660. && (p != Tcl_UniCharToLower(*string))) {
  1661.     string++;
  1662. }
  1663.     } else {
  1664. while (*string && (p != *string)) { string++; }
  1665.     }
  1666. }
  1667. if (Tcl_UniCharCaseMatch(string, pattern, nocase)) {
  1668.     return 1;
  1669. }
  1670. if (*string == 0) {
  1671.     return 0;
  1672. }
  1673. string++;
  1674.     }
  1675. }
  1677. /*
  1678.  * Check for a "?" as the next pattern character.  It matches
  1679.  * any single character.
  1680.  */
  1682. if (p == '?') {
  1683.     pattern++;
  1684.     string++;
  1685.     continue;
  1686. }
  1688. /*
  1689.  * Check for a "[" as the next pattern character.  It is followed
  1690.  * by a list of characters that are acceptable, or by a range
  1691.  * (two characters separated by "-").
  1692.  */
  1694. if (p == '[') {
  1695.     Tcl_UniChar startChar, endChar;
  1697.     pattern++;
  1698.     ch1 = (nocase ? Tcl_UniCharToLower(*string) : *string);
  1699.     string++;
  1700.     while (1) {
  1701. if ((*pattern == ']') || (*pattern == 0)) {
  1702.     return 0;
  1703. }
  1704. startChar = (nocase ? Tcl_UniCharToLower(*pattern) : *pattern);
  1705. pattern++;
  1706. if (*pattern == '-') {
  1707.     pattern++;
  1708.     if (*pattern == 0) {
  1709. return 0;
  1710.     }
  1711.     endChar = (nocase ? Tcl_UniCharToLower(*pattern)
  1712.     : *pattern);
  1713.     pattern++;
  1714.     if (((startChar <= ch1) && (ch1 <= endChar))
  1715.     || ((endChar <= ch1) && (ch1 <= startChar))) {
  1716. /*
  1717.  * Matches ranges of form [a-z] or [z-a].
  1718.  */
  1719. break;
  1720.     }
  1721. } else if (startChar == ch1) {
  1722.     break;
  1723. }
  1724.     }
  1725.     while (*pattern != ']') {
  1726. if (*pattern == 0) {
  1727.     pattern--;
  1728.     break;
  1729. }
  1730. pattern++;
  1731.     }
  1732.     pattern++;
  1733.     continue;
  1734. }
  1736. /*
  1737.  * If the next pattern character is '', just strip off the ''
  1738.  * so we do exact matching on the character that follows.
  1739.  */
  1741. if (p == '\') {
  1742.     if (*(++pattern) == '') {
  1743. return 0;
  1744.     }
  1745. }
  1747. /*
  1748.  * There's no special character.  Just make sure that the next
  1749.  * bytes of each string match.
  1750.  */
  1752. if (nocase) {
  1753.     if (Tcl_UniCharToLower(*string) != Tcl_UniCharToLower(*pattern)) {
  1754. return 0;
  1755.     }
  1756. } else if (*string != *pattern) {
  1757.     return 0;
  1758. }
  1759. string++;
  1760. pattern++;
  1761.     }
  1762. }
  1764. /*
  1765.  *----------------------------------------------------------------------
  1766.  *
  1767.  * TclUniCharMatch --
  1768.  *
  1769.  * See if a particular Unicode string matches a particular pattern.
  1770.  * Allows case insensitivity.  This is the Unicode equivalent of the
  1771.  * char* Tcl_StringCaseMatch.  This variant of Tcl_UniCharCaseMatch
  1772.  * uses counted Strings, so embedded NULLs are allowed.
  1773.  *
  1774.  * Results:
  1775.  * The return value is 1 if string matches pattern, and
  1776.  * 0 otherwise.  The matching operation permits the following
  1777.  * special characters in the pattern: *?[] (see the manual
  1778.  * entry for details on what these mean).
  1779.  *
  1780.  * Side effects:
  1781.  * None.
  1782.  *
  1783.  *----------------------------------------------------------------------
  1784.  */
  1786. int
  1787. TclUniCharMatch(string, strLen, pattern, ptnLen, nocase)
  1788.     CONST Tcl_UniChar *string; /* Unicode String. */
  1789.     int strLen; /* length of String */
  1790.     CONST Tcl_UniChar *pattern; /* Pattern, which may contain special
  1791.  * characters. */
  1792.     int ptnLen; /* length of Pattern */
  1793.     int nocase; /* 0 for case sensitive, 1 for insensitive */
  1794. {
  1795.     CONST Tcl_UniChar *stringEnd, *patternEnd;
  1796.     Tcl_UniChar p;
  1798.     stringEnd  = string + strLen;
  1799.     patternEnd = pattern + ptnLen;
  1801.     while (1) {
  1802. /*
  1803.  * See if we're at the end of both the pattern and the string.  If
  1804.  * so, we succeeded.  If we're at the end of the pattern but not at
  1805.  * the end of the string, we failed.
  1806.  */
  1808. if (pattern == patternEnd) {
  1809.     return (string == stringEnd);
  1810. }
  1811. p = *pattern;
  1812. if ((string == stringEnd) && (p != '*')) {
  1813.     return 0;
  1814. }
  1816. /*
  1817.  * Check for a "*" as the next pattern character.  It matches any
  1818.  * substring.  We handle this by skipping all the characters up to the
  1819.  * next matching one in the pattern, and then calling ourselves
  1820.  * recursively for each postfix of string, until either we match or we
  1821.  * reach the end of the string.
  1822.  */
  1824. if (p == '*') {
  1825.     /*
  1826.      * Skip all successive *'s in the pattern
  1827.      */
  1828.     while (*(++pattern) == '*') {}
  1829.     if (pattern == patternEnd) {
  1830. return 1;
  1831.     }
  1832.     p = *pattern;
  1833.     if (nocase) {
  1834. p = Tcl_UniCharToLower(p);
  1835.     }
  1836.     while (1) {
  1837. /*
  1838.  * Optimization for matching - cruise through the string
  1839.  * quickly if the next char in the pattern isn't a special
  1840.  * character
  1841.  */
  1842. if ((p != '[') && (p != '?') && (p != '\')) {
  1843.     if (nocase) {
  1844. while ((string < stringEnd) && (p != *string)
  1845. && (p != Tcl_UniCharToLower(*string))) {
  1846.     string++;
  1847. }
  1848.     } else {
  1849. while ((string < stringEnd) && (p != *string)) {
  1850.     string++;
  1851. }
  1852.     }
  1853. }
  1854. if (TclUniCharMatch(string, stringEnd - string,
  1855. pattern, patternEnd - pattern, nocase)) {
  1856.     return 1;
  1857. }
  1858. if (string == stringEnd) {
  1859.     return 0;
  1860. }
  1861. string++;
  1862.     }
  1863. }
  1865. /*
  1866.  * Check for a "?" as the next pattern character.  It matches
  1867.  * any single character.
  1868.  */
  1870. if (p == '?') {
  1871.     pattern++;
  1872.     string++;
  1873.     continue;
  1874. }
  1876. /*
  1877.  * Check for a "[" as the next pattern character.  It is followed
  1878.  * by a list of characters that are acceptable, or by a range
  1879.  * (two characters separated by "-").
  1880.  */
  1882. if (p == '[') {
  1883.     Tcl_UniChar ch1, startChar, endChar;
  1885.     pattern++;
  1886.     ch1 = (nocase ? Tcl_UniCharToLower(*string) : *string);
  1887.     string++;
  1888.     while (1) {
  1889. if ((*pattern == ']') || (pattern == patternEnd)) {
  1890.     return 0;
  1891. }
  1892. startChar = (nocase ? Tcl_UniCharToLower(*pattern) : *pattern);
  1893. pattern++;
  1894. if (*pattern == '-') {
  1895.     pattern++;
  1896.     if (pattern == patternEnd) {
  1897. return 0;
  1898.     }
  1899.     endChar = (nocase ? Tcl_UniCharToLower(*pattern)
  1900.     : *pattern);
  1901.     pattern++;
  1902.     if (((startChar <= ch1) && (ch1 <= endChar))
  1903.     || ((endChar <= ch1) && (ch1 <= startChar))) {
  1904. /*
  1905.  * Matches ranges of form [a-z] or [z-a].
  1906.  */
  1907. break;
  1908.     }
  1909. } else if (startChar == ch1) {
  1910.     break;
  1911. }
  1912.     }
  1913.     while (*pattern != ']') {
  1914. if (pattern == patternEnd) {
  1915.     pattern--;
  1916.     break;
  1917. }
  1918. pattern++;
  1919.     }
  1920.     pattern++;
  1921.     continue;
  1922. }
  1924. /*
  1925.  * If the next pattern character is '', just strip off the ''
  1926.  * so we do exact matching on the character that follows.
  1927.  */
  1929. if (p == '\') {
  1930.     if (++pattern == patternEnd) {
  1931. return 0;
  1932.     }
  1933. }
  1935. /*
  1936.  * There's no special character.  Just make sure that the next
  1937.  * bytes of each string match.
  1938.  */
  1940. if (nocase) {
  1941.     if (Tcl_UniCharToLower(*string) != Tcl_UniCharToLower(*pattern)) {
  1942. return 0;
  1943.     }
  1944. } else if (*string != *pattern) {
  1945.     return 0;
  1946. }
  1947. string++;
  1948. pattern++;
  1949.     }
  1950. }