\n| <\/td>\n | \n TCL_CONVERT_UNKNOWN<\/b><\/p>\n<\/td>\n | <\/td>\n | \n The source buffer contained a character that could not be represented in the target encoding and TCL_ENCODING_STOPONERROR<\/b> was specified.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n Tcl_UtfToExternalDString<\/b> converts a source buffer src<\/i> from UTF-8 into the specified encoding<\/i>. The converted bytes are stored in dstPtr<\/i>, which is then terminated with the appropriate encoding-specific null. The caller should eventually call Tcl_DStringFree<\/b> to free any information stored in dstPtr<\/i>. When converting, if any of the characters in the source buffer cannot be represented in the target encoding, a default fallback character will be used. The return value is a pointer to the value stored in the DString.<\/p>\n Tcl_UtfToExternal<\/b> converts a source buffer src<\/i> from UTF-8 into the specified encoding<\/i>. Up to srcLen<\/i> bytes are converted from the source buffer and up to dstLen<\/i> converted bytes are stored in dst<\/i>. In all cases, *srcReadPtr<\/i> is filled with the number of bytes that were successfully converted from src<\/i> and *dstWrotePtr<\/i> is filled with the corresponding number of bytes that were stored in dst<\/i>. The return values are the same as the return values for Tcl_ExternalToUtf<\/b>.<\/p>\n Tcl_WinUtfToTChar<\/b> and Tcl_WinTCharToUtf<\/b> are Windows-only convenience functions for converting between UTF-8 and Windows strings based on the TCHAR type which is by convention a Unicode character on Windows NT.<\/p>\n Tcl_GetEncodingName<\/b> is roughly the inverse of Tcl_GetEncoding<\/b>. Given an encoding<\/i>, the return value is the name<\/i> argument that was used to create the encoding. The string returned by Tcl_GetEncodingName<\/b> is only guaranteed to persist until the encoding<\/i> is deleted. The caller must not modify this string.<\/p>\n Tcl_SetSystemEncoding<\/b> sets the default encoding that should be used whenever the user passes a NULL value for the encoding<\/i> argument to any of the other encoding functions. If name<\/i> is NULL, the system encoding is reset to the default system encoding, binary<\/b>. If the name did not refer to any known or loadable encoding, TCL_ERROR<\/b> is returned and an error message is left in interp<\/i>. Otherwise, this procedure increments the reference count of the new system encoding, decrements the reference count of the old system encoding, and returns TCL_OK<\/b>.<\/p>\n Tcl_GetEncodingNameFromEnvironment<\/b> provides a means for the Tcl library to report the encoding name it believes to be the correct one to use as the system encoding, based on system calls and examination of the environment suitable for the platform. It accepts bufPtr<\/i>, a pointer to an uninitialized or freed Tcl_DString<\/b> and writes the encoding name to it. The Tcl_DStringValue<\/b> is returned.<\/p>\n Tcl_GetEncodingNames<\/b> sets the interp<\/i> result to a list consisting of the names of all the encodings that are currently defined or can be dynamically loaded, searching the encoding path specified by Tcl_SetDefaultEncodingDir<\/b>. This procedure does not ensure that the dynamically-loadable encoding files contain valid data, but merely that they exist.<\/p>\n Tcl_CreateEncoding<\/b> defines a new encoding and registers the C procedures that are called back to convert between the encoding and UTF-8. Encodings created by Tcl_CreateEncoding<\/b> are thereafter visible in the database used by Tcl_GetEncoding<\/b>. Just as with the Tcl_GetEncoding<\/b> procedure, the return value is a token that represents the encoding and can be used in subsequent calls to other encoding functions. Tcl_CreateEncoding<\/b> returns an encoding with a reference count of 1. If an encoding with the specified name<\/i> already exists, then its entry in the database is replaced with the new encoding; the token for the old encoding will remain valid and continue to behave as before, but users of the new token will now call the new encoding procedures.<\/p>\n The typePtr<\/i> argument to Tcl_CreateEncoding<\/b> contains information about the name of the encoding and the procedures that will be called to convert between this encoding and UTF-8. It is defined as follows:<\/p>\n typedef struct Tcl_EncodingType {
const char *encodingName<\/i>;
Tcl_EncodingConvertProc *toUtfProc<\/i>;
Tcl_EncodingConvertProc *fromUtfProc<\/i>;
Tcl_EncodingFreeProc *freeProc<\/i>;
ClientData clientData<\/i>;
int nullSize<\/i>;
} Tcl_EncodingType<\/b>;<\/p>\n The encodingName<\/i> provides a string name for the encoding, by which it can be referred in other procedures such as Tcl_GetEncoding<\/b>. The toUtfProc<\/i> refers to a callback procedure to invoke to convert text from this encoding into UTF-8. The fromUtfProc<\/i> refers to a callback procedure to invoke to convert text from UTF-8 into this encoding. The freeProc<\/i> refers to a callback procedure to invoke when this encoding is deleted. The freeProc<\/i> field may be NULL. The clientData<\/i> contains an arbitrary one-word value passed to toUtfProc<\/i>, fromUtfProc<\/i>, and freeProc<\/i> whenever they are called. Typically, this is a pointer to a data structure containing encoding-specific information that can be used by the callback procedures. For instance, two very similar encodings such as ascii<\/b> and macRoman<\/b> may use the same callback procedure, but use different values of clientData<\/i> to control its behavior. The nullSize<\/i> specifies the number of zero bytes that signify end-of-string in this encoding. It must be 1<\/b> (for single-byte or multi-byte encodings like ASCII or Shift-JIS) or 2<\/b> (for double-byte encodings like Unicode). Constant-sized encodings with 3 or more bytes per character (such as CNS11643) are not accepted.<\/p>\n The callback procedures toUtfProc<\/i> and fromUtfProc<\/i> should match the type Tcl_EncodingConvertProc<\/b>:<\/p>\n typedef int Tcl_EncodingConvertProc<\/b>(
ClientData clientData<\/i>,
const char *src<\/i>,
int srcLen<\/i>,
int flags<\/i>,
Tcl_EncodingState *statePtr<\/i>,
char *dst<\/i>,
int dstLen<\/i>,
int *srcReadPtr<\/i>,
int *dstWrotePtr<\/i>,
int *dstCharsPtr<\/i>);<\/p>\n The toUtfProc<\/i> and fromUtfProc<\/i> procedures are called by the Tcl_ExternalToUtf<\/b> or Tcl_UtfToExternal<\/b> family of functions to perform the actual conversion. The clientData<\/i> parameter to these procedures is the same as the clientData<\/i> field specified to Tcl_CreateEncoding<\/b> when the encoding was created. The remaining arguments to the callback procedures are the same as the arguments, documented at the top, to Tcl_ExternalToUtf<\/b> or Tcl_UtfToExternal<\/b>, with the following exceptions. If the srcLen<\/i> argument to one of those high-level functions is negative, the value passed to the callback procedure will be the appropriate encoding-specific string length of src<\/i>. If any of the srcReadPtr<\/i>, dstWrotePtr<\/i>, or dstCharsPtr<\/i> arguments to one of the high-level functions is NULL, the corresponding value passed to the callback procedure will be a non-NULL location.<\/p>\n The callback procedure freeProc<\/i>, if non-NULL, should match the type Tcl_EncodingFreeProc<\/b>:<\/p>\n typedef void Tcl_EncodingFreeProc<\/b>(
ClientData clientData<\/i>);<\/p>\n This freeProc<\/i> function is called when the encoding is deleted. The clientData<\/i> parameter is the same as the clientData<\/i> field specified to Tcl_CreateEncoding<\/b> when the encoding was created.<\/p>\n Tcl_GetEncodingSearchPath<\/b> and Tcl_SetEncodingSearchPath<\/b> are called to access and set the list of filesystem directories searched for encoding data files.<\/p>\n The value returned by Tcl_GetEncodingSearchPath<\/b> is the value stored by the last successful call to Tcl_SetEncodingSearchPath<\/b>. If no calls to Tcl_SetEncodingSearchPath<\/b> have occurred, Tcl will compute an initial value based on the environment. There is one encoding search path for the entire process, shared by all threads in the process.<\/p>\n Tcl_SetEncodingSearchPath<\/b> stores searchPath<\/i> and returns TCL_OK<\/b>, unless searchPath<\/i> is not a valid Tcl list, which causes TCL_ERROR<\/b> to be returned. The elements of searchPath<\/i> are not verified as existing readable filesystem directories. When searching for encoding data files takes place, and non-existent or non-readable filesystem directories on the searchPath<\/i> are silently ignored.<\/p>\n Tcl_GetDefaultEncodingDir<\/b> and Tcl_SetDefaultEncodingDir<\/b> are obsolete interfaces best replaced with calls to Tcl_GetEncodingSearchPath<\/b> and Tcl_SetEncodingSearchPath<\/b>. They are called to access and set the first element of the searchPath<\/i> list. Since Tcl searches searchPath<\/i> for encoding data files in list order, these routines establish the \u201cdefault\u201d directory in which to find encoding data files.<\/p>\n\n\n| <\/td>\n | \n [1] S<\/b><\/p>\n<\/td>\n | <\/td>\n | \n A single-byte encoding, where one character is always one byte long in the encoding. An example is iso8859-1<\/b>, used by many European languages.<\/p>\n<\/td>\n<\/tr>\n\n| <\/td>\n | \n [2] D<\/b><\/p>\n<\/td>\n | <\/td>\n | \n A double-byte encoding, where one character is always two bytes long in the encoding. An example is big5<\/b>, used for Chinese text.<\/p>\n<\/td>\n<\/tr>\n\n| <\/td>\n | \n [3] M<\/b><\/p>\n<\/td>\n | <\/td>\n | \n A multi-byte encoding, where one character may be either one or two bytes long. Certain bytes are lead bytes, indicating that another byte must follow and that together the two bytes represent one character. Other bytes are not lead bytes and represent themselves. An example is shiftjis<\/b>, used by many Japanese computers.<\/p>\n<\/td>\n<\/tr>\n\n| <\/td>\n | \n [4] E<\/b><\/p>\n<\/td>\n | <\/td>\n | \n An escape-sequence encoding, specifying that certain sequences of bytes do not represent characters, but commands that describe how following bytes should be interpreted.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n The rest of the lines in the file depend on the type.<\/p>\n Cases [1], [2], and [3] are collectively referred to as table-based encoding files. The lines in a table-based encoding file are in the same format as this example taken from the shiftjis<\/b> encoding (this is not the complete file):<\/p>\n # Encoding file: shiftjis, multi-byte
M
003F 0 40
00
0000000100020003000400050006000700080009000A000B000C000D000E000F
0010001100120013001400150016001700180019001A001B001C001D001E001F
0020002100220023002400250026002700280029002A002B002C002D002E002F
0030003100320033003400350036003700380039003A003B003C003D003E003F
0040004100420043004400450046004700480049004A004B004C004D004E004F
0050005100520053005400550056005700580059005A005B005C005D005E005F
0060006100620063006400650066006700680069006A006B006C006D006E006F
0070007100720073007400750076007700780079007A007B007C007D203E007F
0080000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000FF61FF62FF63FF64FF65FF66FF67FF68FF69FF6AFF6BFF6CFF6DFF6EFF6F
FF70FF71FF72FF73FF74FF75FF76FF77FF78FF79FF7AFF7BFF7CFF7DFF7EFF7F
FF80FF81FF82FF83FF84FF85FF86FF87FF88FF89FF8AFF8BFF8CFF8DFF8EFF8F
FF90FF91FF92FF93FF94FF95FF96FF97FF98FF99FF9AFF9BFF9CFF9DFF9EFF9F
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
81
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
300030013002FF0CFF0E30FBFF1AFF1BFF1FFF01309B309C00B4FF4000A8FF3E
FFE3FF3F30FD30FE309D309E30034EDD30053006300730FC20152010FF0F005C
301C2016FF5C2026202520182019201C201DFF08FF0930143015FF3BFF3DFF5B
FF5D30083009300A300B300C300D300E300F30103011FF0B221200B100D70000
00F7FF1D2260FF1CFF1E22662267221E22342642264000B0203220332103FFE5
FF0400A200A3FF05FF03FF06FF0AFF2000A72606260525CB25CF25CE25C725C6
25A125A025B325B225BD25BC203B301221922190219121933013000000000000
000000000000000000000000000000002208220B2286228722822283222A2229
000000000000000000000000000000002227222800AC21D221D4220022030000
0000000000000000000000000000000000000000222022A52312220222072261
2252226A226B221A223D221D2235222B222C0000000000000000000000000000
212B2030266F266D266A2020202100B6000000000000000025EF000000000000<\/p>\n The third line of the file is three numbers. The first number is the fallback character (in base 16) to use when converting from UTF-8 to this encoding. The second number is a 1<\/b> if this file represents the encoding for a symbol font, or 0<\/b> otherwise. The last number (in base 10) is how many pages of data follow.<\/p>\n Subsequent lines in the example above are pages that describe how to map from the encoding into 2-byte Unicode. The first line in a page identifies the page number. Following it are 256 double-byte numbers, arranged as 16 rows of 16 numbers. Given a character in the encoding, the high byte of that character is used to select which page, and the low byte of that character is used as an index to select one of the double-byte numbers in that page \u2212 the value obtained being the corresponding Unicode character. By examination of the example above, one can see that the characters 0x7E and 0x8163 in shiftjis<\/b> map to 203E and 2026 in Unicode, respectively.<\/p>\n Following the first page will be all the other pages, each in the same format as the first: one number identifying the page followed by 256 double-byte Unicode characters. If a character in the encoding maps to the Unicode character 0000, it means that the character does not actually exist. If all characters on a page would map to 0000, that page can be omitted.<\/p>\n Case [4] is the escape-sequence encoding file. The lines in an this type of file are in the same format as this example taken from the iso2022-jp<\/b> encoding:<\/p>\n # Encoding file: iso2022-jp, escape-driven
E<\/p>\n \n\n| <\/td>\n | \n init<\/p>\n<\/td>\n | \n {}<\/p>\n<\/td>\n<\/tr>\n | \n| <\/td>\n | \n final<\/p>\n<\/td>\n | \n {}<\/p>\n<\/td>\n<\/tr>\n | \n| <\/td>\n | \n iso8859-1<\/p>\n<\/td>\n | \n x1b(B<\/p>\n<\/td>\n<\/tr>\n | \n| <\/td>\n | \n jis0201<\/p>\n<\/td>\n | \n x1b(J<\/p>\n<\/td>\n<\/tr>\n | \n| <\/td>\n | \n jis0208<\/p>\n<\/td>\n | \n x1b$@<\/p>\n<\/td>\n<\/tr>\n | \n| <\/td>\n | \n jis0208<\/p>\n<\/td>\n | \n x1b$B<\/p>\n<\/td>\n<\/tr>\n | \n| <\/td>\n | \n jis0212<\/p>\n<\/td>\n | \n x1b$(D<\/p>\n<\/td>\n<\/tr>\n | \n| <\/td>\n | \n gb2312<\/p>\n<\/td>\n | \n x1b$A<\/p>\n<\/td>\n<\/tr>\n | \n| <\/td>\n | \n ksc5601<\/p>\n<\/td>\n | \n x1b$(C<\/p>\n<\/td>\n<\/tr>\n<\/table>\n In the file, the first column represents an option and the second column is the associated value. init<\/b> is a string to emit or expect before the first character is converted, while final<\/b> is a string to emit or expect after the last character. All other options are names of table-based encodings; the associated value is the escape-sequence that marks that encoding. Tcl syntax is used for the values; in the above example, for instance, \u201c{}<\/b>\u201d represents the empty string and \u201cx1b<\/b>\u201d represents character 27.<\/p>\n When Tcl_GetEncoding<\/b> encounters an encoding name<\/i> that has not been loaded, it attempts to load an encoding file called name<\/i>.enc<\/b> from the encoding<\/b> subdirectory of each directory that Tcl searches for its script library. If the encoding file exists, but is malformed, an error message will be left in interp<\/i>.<\/p>\n | | | | | |