| ︙ | | |
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
-
+
|
*
* Side effects:
* None.
*
*---------------------------------------------------------------------------
*/
int
|
| ︙ | | |
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
|
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
|
+
-
+
|
*/
const char *
Tcl_UtfFindFirst(
const char *src, /* The UTF-8 string to be searched. */
int ch) /* The Unicode character to search for. */
{
size_t len;
int len, fullchar;
int fullchar;
Tcl_UniChar find = 0;
while (1) {
len = TclUtfToUniChar(src, &find);
fullchar = find;
#if TCL_UTF_MAX <= 4
if (!len) {
|
| ︙ | | |
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
|
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
|
+
-
+
|
*/
const char *
Tcl_UtfFindLast(
const char *src, /* The UTF-8 string to be searched. */
int ch) /* The Unicode character to search for. */
{
size_t len;
int len, fullchar;
int fullchar;
Tcl_UniChar find = 0;
const char *last;
last = NULL;
while (1) {
len = TclUtfToUniChar(src, &find);
fullchar = find;
|
| ︙ | | |
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
|
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
|
-
+
|
*/
const char *
Tcl_UtfNext(
const char *src) /* The current location in the string. */
{
Tcl_UniChar ch = 0;
int len = TclUtfToUniChar(src, &ch);
size_t len = TclUtfToUniChar(src, &ch);
#if TCL_UTF_MAX <= 4
if (len == 0) {
len = TclUtfToUniChar(src, &ch);
}
#endif
return src + len;
|
| ︙ | | |
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
|
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
|
-
+
|
Tcl_UniCharAtIndex(
register const char *src, /* The UTF-8 string to dereference. */
register size_t index) /* The position of the desired character. */
{
Tcl_UniChar ch = 0;
int fullchar = 0;
#if TCL_UTF_MAX <= 4
int len = 1;
size_t len = 1;
#endif
src += TclUtfToUniChar(src, &ch);
while (index--) {
#if TCL_UTF_MAX <= 4
src += (len = TclUtfToUniChar(src, &ch));
#else
|
| ︙ | | |
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
|
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
|
-
+
|
const char *
Tcl_UtfAtIndex(
register const char *src, /* The UTF-8 string. */
register size_t index) /* The position of the desired character. */
{
Tcl_UniChar ch = 0;
#if TCL_UTF_MAX <= 4
int len = 1;
size_t len = 1;
#endif
if (index != TCL_AUTO_LENGTH) {
while (index--) {
#if TCL_UTF_MAX <= 4
src += (len = TclUtfToUniChar(src, &ch));
#else
|
| ︙ | | |
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
|
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
|
-
+
|
int
Tcl_UtfToUpper(
char *str) /* String to convert in place. */
{
Tcl_UniChar ch = 0;
int upChar;
char *src, *dst;
int bytes;
size_t bytes;
/*
* Iterate over the string until we hit the terminating null.
*/
src = dst = str;
while (*src) {
|
| ︙ | | |
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
|
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
|
-
+
|
/*
* 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 < TclUtfCount(upChar)) || ((upChar & 0xF800) == 0xD800)) {
memcpy(dst, src, (size_t) bytes);
memcpy(dst, src, bytes);
dst += bytes;
} else {
dst += Tcl_UniCharToUtf(upChar, dst);
}
src += bytes;
}
*dst = '\0';
|
| ︙ | | |
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
|
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
|
-
+
|
int
Tcl_UtfToLower(
char *str) /* String to convert in place. */
{
Tcl_UniChar ch = 0;
int lowChar;
char *src, *dst;
int bytes;
size_t bytes;
/*
* Iterate over the string until we hit the terminating null.
*/
src = dst = str;
while (*src) {
|
| ︙ | | |
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
|
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
|
-
+
|
/*
* 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 < TclUtfCount(lowChar)) || ((lowChar & 0xF800) == 0xD800)) {
memcpy(dst, src, (size_t) bytes);
memcpy(dst, src, bytes);
dst += bytes;
} else {
dst += Tcl_UniCharToUtf(lowChar, dst);
}
src += bytes;
}
*dst = '\0';
|
| ︙ | | |
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
|
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
|
-
+
|
int
Tcl_UtfToTitle(
char *str) /* String to convert in place. */
{
Tcl_UniChar ch = 0;
int titleChar, lowChar;
char *src, *dst;
int bytes;
size_t bytes;
/*
* Capitalize the first character and then lowercase the rest of the
* characters until we get to a null.
*/
src = dst = str;
|
| ︙ | | |
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
|
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
|
-
+
|
/* Combine surrogates */
titleChar = (((titleChar & 0x3ff) << 10) | (ch & 0x3ff)) + 0x10000;
}
#endif
titleChar = Tcl_UniCharToTitle(titleChar);
if ((bytes < TclUtfCount(titleChar)) || ((titleChar & 0xF800) == 0xD800)) {
memcpy(dst, src, (size_t) bytes);
memcpy(dst, src, bytes);
dst += bytes;
} else {
dst += Tcl_UniCharToUtf(titleChar, dst);
}
src += bytes;
}
while (*src) {
|
| ︙ | | |
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
|
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
|
-
+
|
#endif
/* Special exception for Georgian Asomtavruli chars, no titlecase. */
if ((unsigned)(lowChar - 0x1C90) >= 0x30) {
lowChar = Tcl_UniCharToLower(lowChar);
}
if ((bytes < TclUtfCount(lowChar)) || ((lowChar & 0xF800) == 0xD800)) {
memcpy(dst, src, (size_t) bytes);
memcpy(dst, src, bytes);
dst += bytes;
} else {
dst += Tcl_UniCharToUtf(lowChar, dst);
}
src += bytes;
}
*dst = '\0';
|
| ︙ | | |