/[dtapublic]/projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclencoding.c
ViewVC logotype

Annotation of /projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclencoding.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 25 - (hide annotations) (download)
Sat Oct 8 06:43:03 2016 UTC (7 years, 9 months ago) by dashley
Original Path: sf_code/esrgpcpj/shared/tcl_base/tclencoding.c
File MIME type: text/plain
File size: 82943 byte(s)
Initial commit.
1 dashley 25 /* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tclencoding.c,v 1.1.1.1 2001/06/13 04:37:49 dtashley Exp $ */
2    
3     /*
4     * tclEncoding.c --
5     *
6     * Contains the implementation of the encoding conversion package.
7     *
8     * Copyright (c) 1996-1998 Sun Microsystems, Inc.
9     *
10     * See the file "license.terms" for information on usage and redistribution
11     * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
12     *
13     * RCS: @(#) $Id: tclencoding.c,v 1.1.1.1 2001/06/13 04:37:49 dtashley Exp $
14     */
15    
16     #include "tclInt.h"
17     #include "tclPort.h"
18    
19     typedef size_t (LengthProc)_ANSI_ARGS_((CONST char *src));
20    
21     /*
22     * The following data structure represents an encoding, which describes how
23     * to convert between various character sets and UTF-8.
24     */
25    
26     typedef struct Encoding {
27     char *name; /* Name of encoding. Malloced because (1)
28     * hash table entry that owns this encoding
29     * may be freed prior to this encoding being
30     * freed, (2) string passed in the
31     * Tcl_EncodingType structure may not be
32     * persistent. */
33     Tcl_EncodingConvertProc *toUtfProc;
34     /* Procedure to convert from external
35     * encoding into UTF-8. */
36     Tcl_EncodingConvertProc *fromUtfProc;
37     /* Procedure to convert from UTF-8 into
38     * external encoding. */
39     Tcl_EncodingFreeProc *freeProc;
40     /* If non-NULL, procedure to call when this
41     * encoding is deleted. */
42     int nullSize; /* Number of 0x00 bytes that signify
43     * end-of-string in this encoding. This
44     * number is used to determine the source
45     * string length when the srcLen argument is
46     * negative. This number can be 1 or 2. */
47     ClientData clientData; /* Arbitrary value associated with encoding
48     * type. Passed to conversion procedures. */
49     LengthProc *lengthProc; /* Function to compute length of
50     * null-terminated strings in this encoding.
51     * If nullSize is 1, this is strlen; if
52     * nullSize is 2, this is a function that
53     * returns the number of bytes in a 0x0000
54     * terminated string. */
55     int refCount; /* Number of uses of this structure. */
56     Tcl_HashEntry *hPtr; /* Hash table entry that owns this encoding. */
57     } Encoding;
58    
59     /*
60     * The following structure is the clientData for a dynamically-loaded,
61     * table-driven encoding created by LoadTableEncoding(). It maps between
62     * Unicode and a single-byte, double-byte, or multibyte (1 or 2 bytes only)
63     * encoding.
64     */
65    
66     typedef struct TableEncodingData {
67     int fallback; /* Character (in this encoding) to
68     * substitute when this encoding cannot
69     * represent a UTF-8 character. */
70     char prefixBytes[256]; /* If a byte in the input stream is a lead
71     * byte for a 2-byte sequence, the
72     * corresponding entry in this array is 1,
73     * otherwise it is 0. */
74     unsigned short **toUnicode; /* Two dimensional sparse matrix to map
75     * characters from the encoding to Unicode.
76     * Each element of the toUnicode array points
77     * to an array of 256 shorts. If there is no
78     * corresponding character in Unicode, the
79     * value in the matrix is 0x0000. malloc'd. */
80     unsigned short **fromUnicode;
81     /* Two dimensional sparse matrix to map
82     * characters from Unicode to the encoding.
83     * Each element of the fromUnicode array
84     * points to an array of 256 shorts. If there
85     * is no corresponding character the encoding,
86     * the value in the matrix is 0x0000.
87     * malloc'd. */
88     } TableEncodingData;
89    
90     /*
91     * The following structures is the clientData for a dynamically-loaded,
92     * escape-driven encoding that is itself comprised of other simpler
93     * encodings. An example is "iso-2022-jp", which uses escape sequences to
94     * switch between ascii, jis0208, jis0212, gb2312, and ksc5601. Note that
95     * "escape-driven" does not necessarily mean that the ESCAPE character is
96     * the character used for switching character sets.
97     */
98    
99     typedef struct EscapeSubTable {
100     unsigned int sequenceLen; /* Length of following string. */
101     char sequence[16]; /* Escape code that marks this encoding. */
102     char name[32]; /* Name for encoding. */
103     Encoding *encodingPtr; /* Encoding loaded using above name, or NULL
104     * if this sub-encoding has not been needed
105     * yet. */
106     } EscapeSubTable;
107    
108     typedef struct EscapeEncodingData {
109     int fallback; /* Character (in this encoding) to
110     * substitute when this encoding cannot
111     * represent a UTF-8 character. */
112     unsigned int initLen; /* Length of following string. */
113     char init[16]; /* String to emit or expect before first char
114     * in conversion. */
115     unsigned int finalLen; /* Length of following string. */
116     char final[16]; /* String to emit or expect after last char
117     * in conversion. */
118     char prefixBytes[256]; /* If a byte in the input stream is the
119     * first character of one of the escape
120     * sequences in the following array, the
121     * corresponding entry in this array is 1,
122     * otherwise it is 0. */
123     int numSubTables; /* Length of following array. */
124     EscapeSubTable subTables[1];/* Information about each EscapeSubTable
125     * used by this encoding type. The actual
126     * size will be as large as necessary to
127     * hold all EscapeSubTables. */
128     } EscapeEncodingData;
129    
130     /*
131     * Constants used when loading an encoding file to identify the type of the
132     * file.
133     */
134    
135     #define ENCODING_SINGLEBYTE 0
136     #define ENCODING_DOUBLEBYTE 1
137     #define ENCODING_MULTIBYTE 2
138     #define ENCODING_ESCAPE 3
139    
140     /*
141     * Initialize the default encoding directory. If this variable contains
142     * a non NULL value, it will be the first path used to locate the
143     * system encoding files.
144     */
145    
146     char *tclDefaultEncodingDir = NULL;
147    
148     static int encodingsInitialized = 0;
149    
150     /*
151     * Hash table that keeps track of all loaded Encodings. Keys are
152     * the string names that represent the encoding, values are (Encoding *).
153     */
154    
155     static Tcl_HashTable encodingTable;
156     TCL_DECLARE_MUTEX(encodingMutex)
157    
158     /*
159     * The following are used to hold the default and current system encodings.
160     * If NULL is passed to one of the conversion routines, the current setting
161     * of the system encoding will be used to perform the conversion.
162     */
163    
164     static Tcl_Encoding defaultEncoding;
165     static Tcl_Encoding systemEncoding;
166    
167     /*
168     * The following variable is used in the sparse matrix code for a
169     * TableEncoding to represent a page in the table that has no entries.
170     */
171    
172     static unsigned short emptyPage[256];
173    
174     /*
175     * Procedures used only in this module.
176     */
177    
178     static int BinaryProc _ANSI_ARGS_((ClientData clientData,
179     CONST char *src, int srcLen, int flags,
180     Tcl_EncodingState *statePtr, char *dst, int dstLen,
181     int *srcReadPtr, int *dstWrotePtr,
182     int *dstCharsPtr));
183     static void EscapeFreeProc _ANSI_ARGS_((ClientData clientData));
184     static int EscapeFromUtfProc _ANSI_ARGS_((ClientData clientData,
185     CONST char *src, int srcLen, int flags,
186     Tcl_EncodingState *statePtr, char *dst, int dstLen,
187     int *srcReadPtr, int *dstWrotePtr,
188     int *dstCharsPtr));
189     static int EscapeToUtfProc _ANSI_ARGS_((ClientData clientData,
190     CONST char *src, int srcLen, int flags,
191     Tcl_EncodingState *statePtr, char *dst, int dstLen,
192     int *srcReadPtr, int *dstWrotePtr,
193     int *dstCharsPtr));
194     static void FreeEncoding _ANSI_ARGS_((Tcl_Encoding encoding));
195     static Encoding * GetTableEncoding _ANSI_ARGS_((
196     EscapeEncodingData *dataPtr, int state));
197     static Tcl_Encoding LoadEncodingFile _ANSI_ARGS_((Tcl_Interp *interp,
198     CONST char *name));
199     static Tcl_Encoding LoadTableEncoding _ANSI_ARGS_((Tcl_Interp *interp,
200     CONST char *name, int type, Tcl_Channel chan));
201     static Tcl_Encoding LoadEscapeEncoding _ANSI_ARGS_((CONST char *name,
202     Tcl_Channel chan));
203     static Tcl_Channel OpenEncodingFile _ANSI_ARGS_((CONST char *dir,
204     CONST char *name));
205     static void TableFreeProc _ANSI_ARGS_((ClientData clientData));
206     static int TableFromUtfProc _ANSI_ARGS_((ClientData clientData,
207     CONST char *src, int srcLen, int flags,
208     Tcl_EncodingState *statePtr, char *dst, int dstLen,
209     int *srcReadPtr, int *dstWrotePtr,
210     int *dstCharsPtr));
211     static int TableToUtfProc _ANSI_ARGS_((ClientData clientData,
212     CONST char *src, int srcLen, int flags,
213     Tcl_EncodingState *statePtr, char *dst, int dstLen,
214     int *srcReadPtr, int *dstWrotePtr,
215     int *dstCharsPtr));
216     static size_t unilen _ANSI_ARGS_((CONST char *src));
217     static int UnicodeToUtfProc _ANSI_ARGS_((ClientData clientData,
218     CONST char *src, int srcLen, int flags,
219     Tcl_EncodingState *statePtr, char *dst, int dstLen,
220     int *srcReadPtr, int *dstWrotePtr,
221     int *dstCharsPtr));
222     static int UtfToUnicodeProc _ANSI_ARGS_((ClientData clientData,
223     CONST char *src, int srcLen, int flags,
224     Tcl_EncodingState *statePtr, char *dst, int dstLen,
225     int *srcReadPtr, int *dstWrotePtr,
226     int *dstCharsPtr));
227     static int UtfToUtfProc _ANSI_ARGS_((ClientData clientData,
228     CONST char *src, int srcLen, int flags,
229     Tcl_EncodingState *statePtr, char *dst, int dstLen,
230     int *srcReadPtr, int *dstWrotePtr,
231     int *dstCharsPtr));
232    
233    
234     /*
235     *---------------------------------------------------------------------------
236     *
237     * TclInitEncodingSubsystem --
238     *
239     * Initialize all resources used by this subsystem on a per-process
240     * basis.
241     *
242     * Results:
243     * None.
244     *
245     * Side effects:
246     * Depends on the memory, object, and IO subsystems.
247     *
248     *---------------------------------------------------------------------------
249     */
250    
251     void
252     TclInitEncodingSubsystem()
253     {
254     Tcl_EncodingType type;
255    
256     Tcl_MutexLock(&encodingMutex);
257     Tcl_InitHashTable(&encodingTable, TCL_STRING_KEYS);
258     Tcl_MutexUnlock(&encodingMutex);
259    
260     /*
261     * Create a few initial encodings. Note that the UTF-8 to UTF-8
262     * translation is not a no-op, because it will turn a stream of
263     * improperly formed UTF-8 into a properly formed stream.
264     */
265    
266     type.encodingName = "identity";
267     type.toUtfProc = BinaryProc;
268     type.fromUtfProc = BinaryProc;
269     type.freeProc = NULL;
270     type.nullSize = 1;
271     type.clientData = NULL;
272    
273     defaultEncoding = Tcl_CreateEncoding(&type);
274     systemEncoding = Tcl_GetEncoding(NULL, type.encodingName);
275    
276     type.encodingName = "utf-8";
277     type.toUtfProc = UtfToUtfProc;
278     type.fromUtfProc = UtfToUtfProc;
279     type.freeProc = NULL;
280     type.nullSize = 1;
281     type.clientData = NULL;
282     Tcl_CreateEncoding(&type);
283    
284     type.encodingName = "unicode";
285     type.toUtfProc = UnicodeToUtfProc;
286     type.fromUtfProc = UtfToUnicodeProc;
287     type.freeProc = NULL;
288     type.nullSize = 2;
289     type.clientData = NULL;
290     Tcl_CreateEncoding(&type);
291     }
292    
293    
294     /*
295     *----------------------------------------------------------------------
296     *
297     * TclFinalizeEncodingSubsystem --
298     *
299     * Release the state associated with the encoding subsystem.
300     *
301     * Results:
302     * None.
303     *
304     * Side effects:
305     * Frees all of the encodings.
306     *
307     *----------------------------------------------------------------------
308     */
309    
310     void
311     TclFinalizeEncodingSubsystem()
312     {
313     Tcl_HashSearch search;
314     Tcl_HashEntry *hPtr;
315     Encoding *encodingPtr;
316    
317     Tcl_MutexLock(&encodingMutex);
318     encodingsInitialized = 0;
319     hPtr = Tcl_FirstHashEntry(&encodingTable, &search);
320     while (hPtr != NULL) {
321     encodingPtr = (Encoding *) Tcl_GetHashValue(hPtr);
322     if (encodingPtr->freeProc != NULL) {
323     (*encodingPtr->freeProc)(encodingPtr->clientData);
324     }
325     ckfree((char *) encodingPtr->name);
326     ckfree((char *) encodingPtr);
327     hPtr = Tcl_NextHashEntry(&search);
328     }
329     Tcl_DeleteHashTable(&encodingTable);
330     Tcl_MutexUnlock(&encodingMutex);
331     }
332    
333     /*
334     *-------------------------------------------------------------------------
335     *
336     * Tcl_GetDefaultEncodingDir --
337     *
338     *
339     * Results:
340     *
341     * Side effects:
342     *
343     *-------------------------------------------------------------------------
344     */
345    
346     char *
347     Tcl_GetDefaultEncodingDir()
348     {
349     return tclDefaultEncodingDir;
350     }
351    
352     /*
353     *-------------------------------------------------------------------------
354     *
355     * Tcl_SetDefaultEncodingDir --
356     *
357     *
358     * Results:
359     *
360     * Side effects:
361     *
362     *-------------------------------------------------------------------------
363     */
364    
365     void
366     Tcl_SetDefaultEncodingDir(path)
367     char *path;
368     {
369     tclDefaultEncodingDir = (char *)ckalloc((unsigned) strlen(path) + 1);
370     strcpy(tclDefaultEncodingDir, path);
371     }
372    
373     /*
374     *-------------------------------------------------------------------------
375     *
376     * Tcl_GetEncoding --
377     *
378     * Given the name of a encoding, find the corresponding Tcl_Encoding
379     * token. If the encoding did not already exist, Tcl attempts to
380     * dynamically load an encoding by that name.
381     *
382     * Results:
383     * Returns a token that represents the encoding. If the name didn't
384     * refer to any known or loadable encoding, NULL is returned. If
385     * NULL was returned, an error message is left in interp's result
386     * object, unless interp was NULL.
387     *
388     * Side effects:
389     * The new encoding type is entered into a table visible to all
390     * interpreters, keyed off the encoding's name. For each call to
391     * this procedure, there should eventually be a call to
392     * Tcl_FreeEncoding, so that the database can be cleaned up when
393     * encodings aren't needed anymore.
394     *
395     *-------------------------------------------------------------------------
396     */
397    
398     Tcl_Encoding
399     Tcl_GetEncoding(interp, name)
400     Tcl_Interp *interp; /* Interp for error reporting, if not NULL. */
401     CONST char *name; /* The name of the desired encoding. */
402     {
403     Tcl_HashEntry *hPtr;
404     Encoding *encodingPtr;
405    
406     Tcl_MutexLock(&encodingMutex);
407     if (name == NULL) {
408     encodingPtr = (Encoding *) systemEncoding;
409     encodingPtr->refCount++;
410     Tcl_MutexUnlock(&encodingMutex);
411     return systemEncoding;
412     }
413    
414     hPtr = Tcl_FindHashEntry(&encodingTable, name);
415     if (hPtr != NULL) {
416     encodingPtr = (Encoding *) Tcl_GetHashValue(hPtr);
417     encodingPtr->refCount++;
418     Tcl_MutexUnlock(&encodingMutex);
419     return (Tcl_Encoding) encodingPtr;
420     }
421     Tcl_MutexUnlock(&encodingMutex);
422     return LoadEncodingFile(interp, name);
423     }
424    
425     /*
426     *---------------------------------------------------------------------------
427     *
428     * Tcl_FreeEncoding --
429     *
430     * This procedure is called to release an encoding allocated by
431     * Tcl_CreateEncoding() or Tcl_GetEncoding().
432     *
433     * Results:
434     * None.
435     *
436     * Side effects:
437     * The reference count associated with the encoding is decremented
438     * and the encoding may be deleted if nothing is using it anymore.
439     *
440     *---------------------------------------------------------------------------
441     */
442    
443     void
444     Tcl_FreeEncoding(encoding)
445     Tcl_Encoding encoding;
446     {
447     Tcl_MutexLock(&encodingMutex);
448     FreeEncoding(encoding);
449     Tcl_MutexUnlock(&encodingMutex);
450     }
451    
452     /*
453     *----------------------------------------------------------------------
454     *
455     * FreeEncoding --
456     *
457     * This procedure is called to release an encoding by procedures
458     * that already have the encodingMutex.
459     *
460     * Results:
461     * None.
462     *
463     * Side effects:
464     * The reference count associated with the encoding is decremented
465     * and the encoding may be deleted if nothing is using it anymore.
466     *
467     *----------------------------------------------------------------------
468     */
469    
470     static void
471     FreeEncoding(encoding)
472     Tcl_Encoding encoding;
473     {
474     Encoding *encodingPtr;
475    
476     encodingPtr = (Encoding *) encoding;
477     if (encodingPtr == NULL) {
478     return;
479     }
480     encodingPtr->refCount--;
481     if (encodingPtr->refCount == 0) {
482     if (encodingPtr->freeProc != NULL) {
483     (*encodingPtr->freeProc)(encodingPtr->clientData);
484     }
485     if (encodingPtr->hPtr != NULL) {
486     Tcl_DeleteHashEntry(encodingPtr->hPtr);
487     }
488     ckfree((char *) encodingPtr->name);
489     ckfree((char *) encodingPtr);
490     }
491     }
492    
493     /*
494     *-------------------------------------------------------------------------
495     *
496     * Tcl_GetEncodingName --
497     *
498     * Given an encoding, return the name that was used to constuct
499     * the encoding.
500     *
501     * Results:
502     * The name of the encoding.
503     *
504     * Side effects:
505     * None.
506     *
507     *---------------------------------------------------------------------------
508     */
509    
510     char *
511     Tcl_GetEncodingName(encoding)
512     Tcl_Encoding encoding; /* The encoding whose name to fetch. */
513     {
514     Encoding *encodingPtr;
515    
516     if (encoding == NULL) {
517     encoding = systemEncoding;
518     }
519     encodingPtr = (Encoding *) encoding;
520     return encodingPtr->name;
521     }
522    
523     /*
524     *-------------------------------------------------------------------------
525     *
526     * Tcl_GetEncodingNames --
527     *
528     * Get the list of all known encodings, including the ones stored
529     * as files on disk in the encoding path.
530     *
531     * Results:
532     * Modifies interp's result object to hold a list of all the available
533     * encodings.
534     *
535     * Side effects:
536     * None.
537     *
538     *-------------------------------------------------------------------------
539     */
540    
541     void
542     Tcl_GetEncodingNames(interp)
543     Tcl_Interp *interp; /* Interp to hold result. */
544     {
545     Tcl_HashSearch search;
546     Tcl_HashEntry *hPtr;
547     Tcl_Obj *pathPtr, *resultPtr;
548     int dummy;
549    
550     Tcl_HashTable table;
551    
552     Tcl_MutexLock(&encodingMutex);
553     Tcl_InitHashTable(&table, TCL_STRING_KEYS);
554     hPtr = Tcl_FirstHashEntry(&encodingTable, &search);
555     while (hPtr != NULL) {
556     Encoding *encodingPtr;
557    
558     encodingPtr = (Encoding *) Tcl_GetHashValue(hPtr);
559     Tcl_CreateHashEntry(&table, encodingPtr->name, &dummy);
560     hPtr = Tcl_NextHashEntry(&search);
561     }
562     Tcl_MutexUnlock(&encodingMutex);
563    
564     pathPtr = TclGetLibraryPath();
565     if (pathPtr != NULL) {
566     int i, objc;
567     Tcl_Obj **objv;
568     Tcl_DString pwdString;
569     char globArgString[10];
570    
571     objc = 0;
572     Tcl_ListObjGetElements(NULL, pathPtr, &objc, &objv);
573    
574     Tcl_GetCwd(interp, &pwdString);
575    
576     for (i = 0; i < objc; i++) {
577     char *string;
578     int j, objc2, length;
579     Tcl_Obj **objv2;
580    
581     string = Tcl_GetStringFromObj(objv[i], NULL);
582     Tcl_ResetResult(interp);
583    
584     /*
585     * TclGlob() changes the contents of globArgString, which causes
586     * a segfault if we pass in a pointer to non-writeable memory.
587     * TclGlob() puts its results directly into interp.
588     */
589    
590     strcpy(globArgString, "*.enc");
591     if ((Tcl_Chdir(string) == 0)
592     && (Tcl_Chdir("encoding") == 0)
593     && (TclGlob(interp, globArgString, NULL, 0, NULL) == TCL_OK)) {
594     objc2 = 0;
595    
596     Tcl_ListObjGetElements(NULL, Tcl_GetObjResult(interp), &objc2,
597     &objv2);
598    
599     for (j = 0; j < objc2; j++) {
600     string = Tcl_GetStringFromObj(objv2[j], &length);
601     length -= 4;
602     if (length > 0) {
603     string[length] = '\0';
604     Tcl_CreateHashEntry(&table, string, &dummy);
605     string[length] = '.';
606     }
607     }
608     }
609     Tcl_Chdir(Tcl_DStringValue(&pwdString));
610     }
611     Tcl_DStringFree(&pwdString);
612     }
613    
614     /*
615     * Clear any values placed in the result by globbing.
616     */
617    
618     Tcl_ResetResult(interp);
619     resultPtr = Tcl_GetObjResult(interp);
620    
621     hPtr = Tcl_FirstHashEntry(&table, &search);
622     while (hPtr != NULL) {
623     Tcl_Obj *strPtr;
624    
625     strPtr = Tcl_NewStringObj(Tcl_GetHashKey(&table, hPtr), -1);
626     Tcl_ListObjAppendElement(NULL, resultPtr, strPtr);
627     hPtr = Tcl_NextHashEntry(&search);
628     }
629     Tcl_DeleteHashTable(&table);
630     }
631    
632     /*
633     *------------------------------------------------------------------------
634     *
635     * Tcl_SetSystemEncoding --
636     *
637     * Sets the default encoding that should be used whenever the user
638     * passes a NULL value in to one of the conversion routines.
639     * If the supplied name is NULL, the system encoding is reset to the
640     * default system encoding.
641     *
642     * Results:
643     * The return value is TCL_OK if the system encoding was successfully
644     * set to the encoding specified by name, TCL_ERROR otherwise. If
645     * TCL_ERROR is returned, an error message is left in interp's result
646     * object, unless interp was NULL.
647     *
648     * Side effects:
649     * The reference count of the new system encoding is incremented.
650     * The reference count of the old system encoding is decremented and
651     * it may be freed.
652     *
653     *------------------------------------------------------------------------
654     */
655    
656     int
657     Tcl_SetSystemEncoding(interp, name)
658     Tcl_Interp *interp; /* Interp for error reporting, if not NULL. */
659     CONST char *name; /* The name of the desired encoding, or NULL
660     * to reset to default encoding. */
661     {
662     Tcl_Encoding encoding;
663     Encoding *encodingPtr;
664    
665     if (name == NULL) {
666     Tcl_MutexLock(&encodingMutex);
667     encoding = defaultEncoding;
668     encodingPtr = (Encoding *) encoding;
669     encodingPtr->refCount++;
670     Tcl_MutexUnlock(&encodingMutex);
671     } else {
672     encoding = Tcl_GetEncoding(interp, name);
673     if (encoding == NULL) {
674     return TCL_ERROR;
675     }
676     }
677    
678     Tcl_MutexLock(&encodingMutex);
679     FreeEncoding(systemEncoding);
680     systemEncoding = encoding;
681     Tcl_MutexUnlock(&encodingMutex);
682    
683     return TCL_OK;
684     }
685    
686     /*
687     *---------------------------------------------------------------------------
688     *
689     * Tcl_CreateEncoding --
690     *
691     * This procedure is called to define a new encoding and the procedures
692     * that are used to convert between the specified encoding and Unicode.
693     *
694     * Results:
695     * Returns a token that represents the encoding. If an encoding with
696     * the same name already existed, the old encoding token remains
697     * valid and continues to behave as it used to, and will eventually
698     * be garbage collected when the last reference to it goes away. Any
699     * subsequent calls to Tcl_GetEncoding with the specified name will
700     * retrieve the most recent encoding token.
701     *
702     * Side effects:
703     * The new encoding type is entered into a table visible to all
704     * interpreters, keyed off the encoding's name. For each call to
705     * this procedure, there should eventually be a call to
706     * Tcl_FreeEncoding, so that the database can be cleaned up when
707     * encodings aren't needed anymore.
708     *
709     *---------------------------------------------------------------------------
710     */
711    
712     Tcl_Encoding
713     Tcl_CreateEncoding(typePtr)
714     Tcl_EncodingType *typePtr; /* The encoding type. */
715     {
716     Tcl_HashEntry *hPtr;
717     int new;
718     Encoding *encodingPtr;
719     char *name;
720    
721     Tcl_MutexLock(&encodingMutex);
722     hPtr = Tcl_CreateHashEntry(&encodingTable, typePtr->encodingName, &new);
723     if (new == 0) {
724     /*
725     * Remove old encoding from hash table, but don't delete it until
726     * last reference goes away.
727     */
728    
729     encodingPtr = (Encoding *) Tcl_GetHashValue(hPtr);
730     encodingPtr->hPtr = NULL;
731     }
732    
733     name = ckalloc((unsigned) strlen(typePtr->encodingName) + 1);
734    
735     encodingPtr = (Encoding *) ckalloc(sizeof(Encoding));
736     encodingPtr->name = strcpy(name, typePtr->encodingName);
737     encodingPtr->toUtfProc = typePtr->toUtfProc;
738     encodingPtr->fromUtfProc = typePtr->fromUtfProc;
739     encodingPtr->freeProc = typePtr->freeProc;
740     encodingPtr->nullSize = typePtr->nullSize;
741     encodingPtr->clientData = typePtr->clientData;
742     if (typePtr->nullSize == 1) {
743     encodingPtr->lengthProc = (LengthProc *) strlen;
744     } else {
745     encodingPtr->lengthProc = (LengthProc *) unilen;
746     }
747     encodingPtr->refCount = 1;
748     encodingPtr->hPtr = hPtr;
749     Tcl_SetHashValue(hPtr, encodingPtr);
750    
751     Tcl_MutexUnlock(&encodingMutex);
752    
753     return (Tcl_Encoding) encodingPtr;
754     }
755    
756     /*
757     *-------------------------------------------------------------------------
758     *
759     * Tcl_ExternalToUtfDString --
760     *
761     * Convert a source buffer from the specified encoding into UTF-8.
762     * If any of the bytes in the source buffer are invalid or cannot
763     * be represented in the target encoding, a default fallback
764     * character will be substituted.
765     *
766     * Results:
767     * The converted bytes are stored in the DString, which is then NULL
768     * terminated. The return value is a pointer to the value stored
769     * in the DString.
770     *
771     * Side effects:
772     * None.
773     *
774     *-------------------------------------------------------------------------
775     */
776    
777     char *
778     Tcl_ExternalToUtfDString(encoding, src, srcLen, dstPtr)
779     Tcl_Encoding encoding; /* The encoding for the source string, or
780     * NULL for the default system encoding. */
781     CONST char *src; /* Source string in specified encoding. */
782     int srcLen; /* Source string length in bytes, or < 0 for
783     * encoding-specific string length. */
784     Tcl_DString *dstPtr; /* Uninitialized or free DString in which
785     * the converted string is stored. */
786     {
787     char *dst;
788     Tcl_EncodingState state;
789     Encoding *encodingPtr;
790     int flags, dstLen, result, soFar, srcRead, dstWrote, dstChars;
791    
792     Tcl_DStringInit(dstPtr);
793     dst = Tcl_DStringValue(dstPtr);
794     dstLen = dstPtr->spaceAvl - 1;
795    
796     if (encoding == NULL) {
797     encoding = systemEncoding;
798     }
799     encodingPtr = (Encoding *) encoding;
800    
801     if (src == NULL) {
802     srcLen = 0;
803     } else if (srcLen < 0) {
804     srcLen = (*encodingPtr->lengthProc)(src);
805     }
806     flags = TCL_ENCODING_START | TCL_ENCODING_END;
807     while (1) {
808     result = (*encodingPtr->toUtfProc)(encodingPtr->clientData, src,
809     srcLen, flags, &state, dst, dstLen, &srcRead, &dstWrote,
810     &dstChars);
811     soFar = dst + dstWrote - Tcl_DStringValue(dstPtr);
812     if (result != TCL_CONVERT_NOSPACE) {
813     Tcl_DStringSetLength(dstPtr, soFar);
814     return Tcl_DStringValue(dstPtr);
815     }
816     flags &= ~TCL_ENCODING_START;
817     src += srcRead;
818     srcLen -= srcRead;
819     if (Tcl_DStringLength(dstPtr) == 0) {
820     Tcl_DStringSetLength(dstPtr, dstLen);
821     }
822     Tcl_DStringSetLength(dstPtr, 2 * Tcl_DStringLength(dstPtr) + 1);
823     dst = Tcl_DStringValue(dstPtr) + soFar;
824     dstLen = Tcl_DStringLength(dstPtr) - soFar - 1;
825     }
826     }
827    
828     /*
829     *-------------------------------------------------------------------------
830     *
831     * Tcl_ExternalToUtf --
832     *
833     * Convert a source buffer from the specified encoding into UTF-8,
834     *
835     * Results:
836     * The return value is one of TCL_OK, TCL_CONVERT_MULTIBYTE,
837     * TCL_CONVERT_SYNTAX, TCL_CONVERT_UNKNOWN, or TCL_CONVERT_NOSPACE,
838     * as documented in tcl.h.
839     *
840     * Side effects:
841     * The converted bytes are stored in the output buffer.
842     *
843     *-------------------------------------------------------------------------
844     */
845    
846     int
847     Tcl_ExternalToUtf(interp, encoding, src, srcLen, flags, statePtr, dst,
848     dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr)
849     Tcl_Interp *interp; /* Interp for error return, if not NULL. */
850     Tcl_Encoding encoding; /* The encoding for the source string, or
851     * NULL for the default system encoding. */
852     CONST char *src; /* Source string in specified encoding. */
853     int srcLen; /* Source string length in bytes, or < 0 for
854     * encoding-specific string length. */
855     int flags; /* Conversion control flags. */
856     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
857     * state information used during a piecewise
858     * conversion. Contents of statePtr are
859     * initialized and/or reset by conversion
860     * routine under control of flags argument. */
861     char *dst; /* Output buffer in which converted string
862     * is stored. */
863     int dstLen; /* The maximum length of output buffer in
864     * bytes. */
865     int *srcReadPtr; /* Filled with the number of bytes from the
866     * source string that were converted. This
867     * may be less than the original source length
868     * if there was a problem converting some
869     * source characters. */
870     int *dstWrotePtr; /* Filled with the number of bytes that were
871     * stored in the output buffer as a result of
872     * the conversion. */
873     int *dstCharsPtr; /* Filled with the number of characters that
874     * correspond to the bytes stored in the
875     * output buffer. */
876     {
877     Encoding *encodingPtr;
878     int result, srcRead, dstWrote, dstChars;
879     Tcl_EncodingState state;
880    
881     if (encoding == NULL) {
882     encoding = systemEncoding;
883     }
884     encodingPtr = (Encoding *) encoding;
885    
886     if (src == NULL) {
887     srcLen = 0;
888     } else if (srcLen < 0) {
889     srcLen = (*encodingPtr->lengthProc)(src);
890     }
891     if (statePtr == NULL) {
892     flags |= TCL_ENCODING_START | TCL_ENCODING_END;
893     statePtr = &state;
894     }
895     if (srcReadPtr == NULL) {
896     srcReadPtr = &srcRead;
897     }
898     if (dstWrotePtr == NULL) {
899     dstWrotePtr = &dstWrote;
900     }
901     if (dstCharsPtr == NULL) {
902     dstCharsPtr = &dstChars;
903     }
904    
905     /*
906     * If there are any null characters in the middle of the buffer, they will
907     * converted to the UTF-8 null character (\xC080). To get the actual
908     * \0 at the end of the destination buffer, we need to append it manually.
909     */
910    
911     dstLen--;
912     result = (*encodingPtr->toUtfProc)(encodingPtr->clientData, src, srcLen,
913     flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr,
914     dstCharsPtr);
915     dst[*dstWrotePtr] = '\0';
916     return result;
917     }
918    
919     /*
920     *-------------------------------------------------------------------------
921     *
922     * Tcl_UtfToExternalDString --
923     *
924     * Convert a source buffer from UTF-8 into the specified encoding.
925     * If any of the bytes in the source buffer are invalid or cannot
926     * be represented in the target encoding, a default fallback
927     * character will be substituted.
928     *
929     * Results:
930     * The converted bytes are stored in the DString, which is then
931     * NULL terminated in an encoding-specific manner. The return value
932     * is a pointer to the value stored in the DString.
933     *
934     * Side effects:
935     * None.
936     *
937     *-------------------------------------------------------------------------
938     */
939    
940     char *
941     Tcl_UtfToExternalDString(encoding, src, srcLen, dstPtr)
942     Tcl_Encoding encoding; /* The encoding for the converted string,
943     * or NULL for the default system encoding. */
944     CONST char *src; /* Source string in UTF-8. */
945     int srcLen; /* Source string length in bytes, or < 0 for
946     * strlen(). */
947     Tcl_DString *dstPtr; /* Uninitialized or free DString in which
948     * the converted string is stored. */
949     {
950     char *dst;
951     Tcl_EncodingState state;
952     Encoding *encodingPtr;
953     int flags, dstLen, result, soFar, srcRead, dstWrote, dstChars;
954    
955     Tcl_DStringInit(dstPtr);
956     dst = Tcl_DStringValue(dstPtr);
957     dstLen = dstPtr->spaceAvl - 1;
958    
959     if (encoding == NULL) {
960     encoding = systemEncoding;
961     }
962     encodingPtr = (Encoding *) encoding;
963    
964     if (src == NULL) {
965     srcLen = 0;
966     } else if (srcLen < 0) {
967     srcLen = strlen(src);
968     }
969     flags = TCL_ENCODING_START | TCL_ENCODING_END;
970     while (1) {
971     result = (*encodingPtr->fromUtfProc)(encodingPtr->clientData, src,
972     srcLen, flags, &state, dst, dstLen, &srcRead, &dstWrote,
973     &dstChars);
974     soFar = dst + dstWrote - Tcl_DStringValue(dstPtr);
975     if (result != TCL_CONVERT_NOSPACE) {
976     if (encodingPtr->nullSize == 2) {
977     Tcl_DStringSetLength(dstPtr, soFar + 1);
978     }
979     Tcl_DStringSetLength(dstPtr, soFar);
980     return Tcl_DStringValue(dstPtr);
981     }
982     flags &= ~TCL_ENCODING_START;
983     src += srcRead;
984     srcLen -= srcRead;
985     if (Tcl_DStringLength(dstPtr) == 0) {
986     Tcl_DStringSetLength(dstPtr, dstLen);
987     }
988     Tcl_DStringSetLength(dstPtr, 2 * Tcl_DStringLength(dstPtr) + 1);
989     dst = Tcl_DStringValue(dstPtr) + soFar;
990     dstLen = Tcl_DStringLength(dstPtr) - soFar - 1;
991     }
992     }
993    
994     /*
995     *-------------------------------------------------------------------------
996     *
997     * Tcl_UtfToExternal --
998     *
999     * Convert a buffer from UTF-8 into the specified encoding.
1000     *
1001     * Results:
1002     * The return value is one of TCL_OK, TCL_CONVERT_MULTIBYTE,
1003     * TCL_CONVERT_SYNTAX, TCL_CONVERT_UNKNOWN, or TCL_CONVERT_NOSPACE,
1004     * as documented in tcl.h.
1005     *
1006     * Side effects:
1007     * The converted bytes are stored in the output buffer.
1008     *
1009     *-------------------------------------------------------------------------
1010     */
1011    
1012     int
1013     Tcl_UtfToExternal(interp, encoding, src, srcLen, flags, statePtr, dst,
1014     dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr)
1015     Tcl_Interp *interp; /* Interp for error return, if not NULL. */
1016     Tcl_Encoding encoding; /* The encoding for the converted string,
1017     * or NULL for the default system encoding. */
1018     CONST char *src; /* Source string in UTF-8. */
1019     int srcLen; /* Source string length in bytes, or < 0 for
1020     * strlen(). */
1021     int flags; /* Conversion control flags. */
1022     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
1023     * state information used during a piecewise
1024     * conversion. Contents of statePtr are
1025     * initialized and/or reset by conversion
1026     * routine under control of flags argument. */
1027     char *dst; /* Output buffer in which converted string
1028     * is stored. */
1029     int dstLen; /* The maximum length of output buffer in
1030     * bytes. */
1031     int *srcReadPtr; /* Filled with the number of bytes from the
1032     * source string that were converted. This
1033     * may be less than the original source length
1034     * if there was a problem converting some
1035     * source characters. */
1036     int *dstWrotePtr; /* Filled with the number of bytes that were
1037     * stored in the output buffer as a result of
1038     * the conversion. */
1039     int *dstCharsPtr; /* Filled with the number of characters that
1040     * correspond to the bytes stored in the
1041     * output buffer. */
1042     {
1043     Encoding *encodingPtr;
1044     int result, srcRead, dstWrote, dstChars;
1045     Tcl_EncodingState state;
1046    
1047     if (encoding == NULL) {
1048     encoding = systemEncoding;
1049     }
1050     encodingPtr = (Encoding *) encoding;
1051    
1052     if (src == NULL) {
1053     srcLen = 0;
1054     } else if (srcLen < 0) {
1055     srcLen = strlen(src);
1056     }
1057     if (statePtr == NULL) {
1058     flags |= TCL_ENCODING_START | TCL_ENCODING_END;
1059     statePtr = &state;
1060     }
1061     if (srcReadPtr == NULL) {
1062     srcReadPtr = &srcRead;
1063     }
1064     if (dstWrotePtr == NULL) {
1065     dstWrotePtr = &dstWrote;
1066     }
1067     if (dstCharsPtr == NULL) {
1068     dstCharsPtr = &dstChars;
1069     }
1070    
1071     dstLen -= encodingPtr->nullSize;
1072     result = (*encodingPtr->fromUtfProc)(encodingPtr->clientData, src, srcLen,
1073     flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr,
1074     dstCharsPtr);
1075     if (encodingPtr->nullSize == 2) {
1076     dst[*dstWrotePtr + 1] = '\0';
1077     }
1078     dst[*dstWrotePtr] = '\0';
1079    
1080     return result;
1081     }
1082    
1083     /*
1084     *---------------------------------------------------------------------------
1085     *
1086     * Tcl_FindExecutable --
1087     *
1088     * This procedure computes the absolute path name of the current
1089     * application, given its argv[0] value.
1090     *
1091     * Results:
1092     * None.
1093     *
1094     * Side effects:
1095     * The variable tclExecutableName gets filled in with the file
1096     * name for the application, if we figured it out. If we couldn't
1097     * figure it out, tclExecutableName is set to NULL.
1098     *
1099     *---------------------------------------------------------------------------
1100     */
1101    
1102     void
1103     Tcl_FindExecutable(argv0)
1104     CONST char *argv0; /* The value of the application's argv[0]
1105     * (native). */
1106     {
1107     CONST char *name;
1108     Tcl_DString buffer, nameString;
1109    
1110     TclInitSubsystems(argv0);
1111    
1112     if (argv0 == NULL) {
1113     goto done;
1114     }
1115     if (tclExecutableName != NULL) {
1116     ckfree(tclExecutableName);
1117     tclExecutableName = NULL;
1118     }
1119     if ((name = TclpFindExecutable(argv0)) == NULL) {
1120     goto done;
1121     }
1122    
1123     /*
1124     * The value returned from TclpNameOfExecutable is a UTF string that
1125     * is possibly dirty depending on when it was initialized. To assure
1126     * that the UTF string is a properly encoded native string for this
1127     * system, convert the UTF string to the default native encoding
1128     * before the default encoding is initialized. Then, convert it back
1129     * to UTF after the system encoding is loaded.
1130     */
1131    
1132     Tcl_UtfToExternalDString(NULL, name, -1, &buffer);
1133     TclFindEncodings(argv0);
1134    
1135     /*
1136     * Now it is OK to convert the native string back to UTF and set
1137     * the value of the tclExecutableName.
1138     */
1139    
1140     Tcl_ExternalToUtfDString(NULL, Tcl_DStringValue(&buffer), -1, &nameString);
1141     tclExecutableName = (char *)
1142     ckalloc((unsigned) (Tcl_DStringLength(&nameString) + 1));
1143     strcpy(tclExecutableName, Tcl_DStringValue(&nameString));
1144    
1145     Tcl_DStringFree(&buffer);
1146     Tcl_DStringFree(&nameString);
1147     return;
1148    
1149     done:
1150     TclFindEncodings(argv0);
1151     }
1152    
1153     /*
1154     *---------------------------------------------------------------------------
1155     *
1156     * LoadEncodingFile --
1157     *
1158     * Read a file that describes an encoding and create a new Encoding
1159     * from the data.
1160     *
1161     * Results:
1162     * The return value is the newly loaded Encoding, or NULL if
1163     * the file didn't exist of was in the incorrect format. If NULL was
1164     * returned, an error message is left in interp's result object,
1165     * unless interp was NULL.
1166     *
1167     * Side effects:
1168     * File read from disk.
1169     *
1170     *---------------------------------------------------------------------------
1171     */
1172    
1173     static Tcl_Encoding
1174     LoadEncodingFile(interp, name)
1175     Tcl_Interp *interp; /* Interp for error reporting, if not NULL. */
1176     CONST char *name; /* The name of the encoding file on disk
1177     * and also the name for new encoding. */
1178     {
1179     int objc, i, ch;
1180     Tcl_Obj **objv;
1181     Tcl_Obj *pathPtr;
1182     Tcl_Channel chan;
1183     Tcl_Encoding encoding;
1184    
1185     pathPtr = TclGetLibraryPath();
1186     if (pathPtr == NULL) {
1187     goto unknown;
1188     }
1189     objc = 0;
1190     Tcl_ListObjGetElements(NULL, pathPtr, &objc, &objv);
1191    
1192     chan = NULL;
1193     for (i = 0; i < objc; i++) {
1194     chan = OpenEncodingFile(Tcl_GetString(objv[i]), name);
1195     if (chan != NULL) {
1196     break;
1197     }
1198     }
1199    
1200     if (chan == NULL) {
1201     goto unknown;
1202     }
1203    
1204     Tcl_SetChannelOption(NULL, chan, "-encoding", "utf-8");
1205    
1206     while (1) {
1207     Tcl_DString ds;
1208    
1209     Tcl_DStringInit(&ds);
1210     Tcl_Gets(chan, &ds);
1211     ch = Tcl_DStringValue(&ds)[0];
1212     Tcl_DStringFree(&ds);
1213     if (ch != '#') {
1214     break;
1215     }
1216     }
1217    
1218     encoding = NULL;
1219     switch (ch) {
1220     case 'S': {
1221     encoding = LoadTableEncoding(interp, name, ENCODING_SINGLEBYTE,
1222     chan);
1223     break;
1224     }
1225     case 'D': {
1226     encoding = LoadTableEncoding(interp, name, ENCODING_DOUBLEBYTE,
1227     chan);
1228     break;
1229     }
1230     case 'M': {
1231     encoding = LoadTableEncoding(interp, name, ENCODING_MULTIBYTE,
1232     chan);
1233     break;
1234     }
1235     case 'E': {
1236     encoding = LoadEscapeEncoding(name, chan);
1237     break;
1238     }
1239     }
1240     if ((encoding == NULL) && (interp != NULL)) {
1241     Tcl_AppendResult(interp, "invalid encoding file \"", name, "\"", NULL);
1242     }
1243     Tcl_Close(NULL, chan);
1244     return encoding;
1245    
1246     unknown:
1247     if (interp != NULL) {
1248     Tcl_AppendResult(interp, "unknown encoding \"", name, "\"", NULL);
1249     }
1250     return NULL;
1251     }
1252    
1253     /*
1254     *----------------------------------------------------------------------
1255     *
1256     * OpenEncodingFile --
1257     *
1258     * Look for the file encoding/<name>.enc in the specified
1259     * directory.
1260     *
1261     * Results:
1262     * Returns an open file channel if the file exists.
1263     *
1264     * Side effects:
1265     * None.
1266     *
1267     *----------------------------------------------------------------------
1268     */
1269    
1270     static Tcl_Channel
1271     OpenEncodingFile(dir, name)
1272     CONST char *dir;
1273     CONST char *name;
1274    
1275     {
1276     char *argv[3];
1277     Tcl_DString pathString;
1278     char *path;
1279     Tcl_Channel chan;
1280    
1281     argv[0] = (char *) dir;
1282     argv[1] = "encoding";
1283     argv[2] = (char *) name;
1284    
1285     Tcl_DStringInit(&pathString);
1286     Tcl_JoinPath(3, argv, &pathString);
1287     path = Tcl_DStringAppend(&pathString, ".enc", -1);
1288     chan = Tcl_OpenFileChannel(NULL, path, "r", 0);
1289     Tcl_DStringFree(&pathString);
1290    
1291     return chan;
1292     }
1293    
1294     /*
1295     *-------------------------------------------------------------------------
1296     *
1297     * LoadTableEncoding --
1298     *
1299     * Helper function for LoadEncodingTable(). Loads a table to that
1300     * converts between Unicode and some other encoding and creates an
1301     * encoding (using a TableEncoding structure) from that information.
1302     *
1303     * File contains binary data, but begins with a marker to indicate
1304     * byte-ordering, so that same binary file can be read on either
1305     * endian platforms.
1306     *
1307     * Results:
1308     * The return value is the new encoding, or NULL if the encoding
1309     * could not be created (because the file contained invalid data).
1310     *
1311     * Side effects:
1312     * None.
1313     *
1314     *-------------------------------------------------------------------------
1315     */
1316    
1317     static Tcl_Encoding
1318     LoadTableEncoding(interp, name, type, chan)
1319     Tcl_Interp *interp; /* Interp for temporary obj while reading. */
1320     CONST char *name; /* Name for new encoding. */
1321     int type; /* Type of encoding (ENCODING_?????). */
1322     Tcl_Channel chan; /* File containing new encoding. */
1323     {
1324     Tcl_DString lineString;
1325     Tcl_Obj *objPtr;
1326     char *line;
1327     int i, hi, lo, numPages, symbol, fallback;
1328     unsigned char used[256];
1329     unsigned int size;
1330     TableEncodingData *dataPtr;
1331     unsigned short *pageMemPtr;
1332     Tcl_EncodingType encType;
1333     char *hex;
1334     static char staticHex[] = {
1335     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0,
1336     10, 11, 12, 13, 14, 15
1337     };
1338    
1339     hex = staticHex - '0';
1340    
1341     Tcl_DStringInit(&lineString);
1342     Tcl_Gets(chan, &lineString);
1343     line = Tcl_DStringValue(&lineString);
1344    
1345     fallback = (int) strtol(line, &line, 16);
1346     symbol = (int) strtol(line, &line, 10);
1347     numPages = (int) strtol(line, &line, 10);
1348     Tcl_DStringFree(&lineString);
1349    
1350     if (numPages < 0) {
1351     numPages = 0;
1352     } else if (numPages > 256) {
1353     numPages = 256;
1354     }
1355    
1356     memset(used, 0, sizeof(used));
1357    
1358     #undef PAGESIZE
1359     #define PAGESIZE (256 * sizeof(unsigned short))
1360    
1361     dataPtr = (TableEncodingData *) ckalloc(sizeof(TableEncodingData));
1362     memset(dataPtr, 0, sizeof(TableEncodingData));
1363    
1364     dataPtr->fallback = fallback;
1365    
1366     /*
1367     * Read the table that maps characters to Unicode. Performs a single
1368     * malloc to get the memory for the array and all the pages needed by
1369     * the array.
1370     */
1371    
1372     size = 256 * sizeof(unsigned short *) + numPages * PAGESIZE;
1373     dataPtr->toUnicode = (unsigned short **) ckalloc(size);
1374     memset(dataPtr->toUnicode, 0, size);
1375     pageMemPtr = (unsigned short *) (dataPtr->toUnicode + 256);
1376    
1377     if (interp == NULL) {
1378     objPtr = Tcl_NewObj();
1379     } else {
1380     objPtr = Tcl_GetObjResult(interp);
1381     }
1382     for (i = 0; i < numPages; i++) {
1383     int ch;
1384     char *p;
1385    
1386     Tcl_ReadChars(chan, objPtr, 3 + 16 * (16 * 4 + 1), 0);
1387     p = Tcl_GetString(objPtr);
1388     hi = (hex[(int)p[0]] << 4) + hex[(int)p[1]];
1389     dataPtr->toUnicode[hi] = pageMemPtr;
1390     p += 2;
1391     for (lo = 0; lo < 256; lo++) {
1392     if ((lo & 0x0f) == 0) {
1393     p++;
1394     }
1395     ch = (hex[(int)p[0]] << 12) + (hex[(int)p[1]] << 8)
1396     + (hex[(int)p[2]] << 4) + hex[(int)p[3]];
1397     if (ch != 0) {
1398     used[ch >> 8] = 1;
1399     }
1400     *pageMemPtr = (unsigned short) ch;
1401     pageMemPtr++;
1402     p += 4;
1403     }
1404     }
1405     if (interp == NULL) {
1406     Tcl_DecrRefCount(objPtr);
1407     } else {
1408     Tcl_ResetResult(interp);
1409     }
1410    
1411     if (type == ENCODING_DOUBLEBYTE) {
1412     memset(dataPtr->prefixBytes, 1, sizeof(dataPtr->prefixBytes));
1413     } else {
1414     for (hi = 1; hi < 256; hi++) {
1415     if (dataPtr->toUnicode[hi] != NULL) {
1416     dataPtr->prefixBytes[hi] = 1;
1417     }
1418     }
1419     }
1420    
1421     /*
1422     * Invert toUnicode array to produce the fromUnicode array. Performs a
1423     * single malloc to get the memory for the array and all the pages
1424     * needed by the array. While reading in the toUnicode array, we
1425     * remembered what pages that would be needed for the fromUnicode array.
1426     */
1427    
1428     if (symbol) {
1429     used[0] = 1;
1430     }
1431     numPages = 0;
1432     for (hi = 0; hi < 256; hi++) {
1433     if (used[hi]) {
1434     numPages++;
1435     }
1436     }
1437     size = 256 * sizeof(unsigned short *) + numPages * PAGESIZE;
1438     dataPtr->fromUnicode = (unsigned short **) ckalloc(size);
1439     memset(dataPtr->fromUnicode, 0, size);
1440     pageMemPtr = (unsigned short *) (dataPtr->fromUnicode + 256);
1441    
1442     for (hi = 0; hi < 256; hi++) {
1443     if (dataPtr->toUnicode[hi] == NULL) {
1444     dataPtr->toUnicode[hi] = emptyPage;
1445     } else {
1446     for (lo = 0; lo < 256; lo++) {
1447     int ch;
1448    
1449     ch = dataPtr->toUnicode[hi][lo];
1450     if (ch != 0) {
1451     unsigned short *page;
1452    
1453     page = dataPtr->fromUnicode[ch >> 8];
1454     if (page == NULL) {
1455     page = pageMemPtr;
1456     pageMemPtr += 256;
1457     dataPtr->fromUnicode[ch >> 8] = page;
1458     }
1459     page[ch & 0xff] = (unsigned short) ((hi << 8) + lo);
1460     }
1461     }
1462     }
1463     }
1464     if (type == ENCODING_MULTIBYTE) {
1465     /*
1466     * If multibyte encodings don't have a backslash character, define
1467     * one. Otherwise, on Windows, native file names won't work because
1468     * the backslash in the file name will map to the unknown character
1469     * (question mark) when converting from UTF-8 to external encoding.
1470     */
1471    
1472     if (dataPtr->fromUnicode[0] != NULL) {
1473     if (dataPtr->fromUnicode[0]['\\'] == '\0') {
1474     dataPtr->fromUnicode[0]['\\'] = '\\';
1475     }
1476     }
1477     }
1478     if (symbol) {
1479     unsigned short *page;
1480    
1481     /*
1482     * Make a special symbol encoding that not only maps the symbol
1483     * characters from their Unicode code points down into page 0, but
1484     * also ensure that the characters on page 0 map to themselves.
1485     * This is so that a symbol font can be used to display a simple
1486     * string like "abcd" and have alpha, beta, chi, delta show up,
1487     * rather than have "unknown" chars show up because strictly
1488     * speaking the symbol font doesn't have glyphs for those low ascii
1489     * chars.
1490     */
1491    
1492     page = dataPtr->fromUnicode[0];
1493     if (page == NULL) {
1494     page = pageMemPtr;
1495     dataPtr->fromUnicode[0] = page;
1496     }
1497     for (lo = 0; lo < 256; lo++) {
1498     if (dataPtr->toUnicode[0][lo] != 0) {
1499     page[lo] = (unsigned short) lo;
1500     }
1501     }
1502     }
1503     for (hi = 0; hi < 256; hi++) {
1504     if (dataPtr->fromUnicode[hi] == NULL) {
1505     dataPtr->fromUnicode[hi] = emptyPage;
1506     }
1507     }
1508     encType.encodingName = name;
1509     encType.toUtfProc = TableToUtfProc;
1510     encType.fromUtfProc = TableFromUtfProc;
1511     encType.freeProc = TableFreeProc;
1512     encType.nullSize = (type == ENCODING_DOUBLEBYTE) ? 2 : 1;
1513     encType.clientData = (ClientData) dataPtr;
1514     return Tcl_CreateEncoding(&encType);
1515    
1516     }
1517    
1518     /*
1519     *-------------------------------------------------------------------------
1520     *
1521     * LoadEscapeEncoding --
1522     *
1523     * Helper function for LoadEncodingTable(). Loads a state machine
1524     * that converts between Unicode and some other encoding.
1525     *
1526     * File contains text data that describes the escape sequences that
1527     * are used to choose an encoding and the associated names for the
1528     * sub-encodings.
1529     *
1530     * Results:
1531     * The return value is the new encoding, or NULL if the encoding
1532     * could not be created (because the file contained invalid data).
1533     *
1534     * Side effects:
1535     * None.
1536     *
1537     *-------------------------------------------------------------------------
1538     */
1539    
1540     static Tcl_Encoding
1541     LoadEscapeEncoding(name, chan)
1542     CONST char *name; /* Name for new encoding. */
1543     Tcl_Channel chan; /* File containing new encoding. */
1544     {
1545     int i;
1546     unsigned int size;
1547     Tcl_DString escapeData;
1548     char init[16], final[16];
1549     EscapeEncodingData *dataPtr;
1550     Tcl_EncodingType type;
1551    
1552     init[0] = '\0';
1553     final[0] = '\0';
1554     Tcl_DStringInit(&escapeData);
1555    
1556     while (1) {
1557     int argc;
1558     char **argv;
1559     char *line;
1560     Tcl_DString lineString;
1561    
1562     Tcl_DStringInit(&lineString);
1563     if (Tcl_Gets(chan, &lineString) < 0) {
1564     break;
1565     }
1566     line = Tcl_DStringValue(&lineString);
1567     if (Tcl_SplitList(NULL, line, &argc, &argv) != TCL_OK) {
1568     continue;
1569     }
1570     if (argc >= 2) {
1571     if (strcmp(argv[0], "name") == 0) {
1572     ;
1573     } else if (strcmp(argv[0], "init") == 0) {
1574     strncpy(init, argv[1], sizeof(init));
1575     init[sizeof(init) - 1] = '\0';
1576     } else if (strcmp(argv[0], "final") == 0) {
1577     strncpy(final, argv[1], sizeof(final));
1578     final[sizeof(final) - 1] = '\0';
1579     } else {
1580     EscapeSubTable est;
1581    
1582     strncpy(est.sequence, argv[1], sizeof(est.sequence));
1583     est.sequence[sizeof(est.sequence) - 1] = '\0';
1584     est.sequenceLen = strlen(est.sequence);
1585    
1586     strncpy(est.name, argv[0], sizeof(est.name));
1587     est.name[sizeof(est.name) - 1] = '\0';
1588    
1589     est.encodingPtr = NULL;
1590     Tcl_DStringAppend(&escapeData, (char *) &est, sizeof(est));
1591     }
1592     }
1593     ckfree((char *) argv);
1594     Tcl_DStringFree(&lineString);
1595     }
1596    
1597     size = sizeof(EscapeEncodingData)
1598     - sizeof(EscapeSubTable) + Tcl_DStringLength(&escapeData);
1599     dataPtr = (EscapeEncodingData *) ckalloc(size);
1600     dataPtr->initLen = strlen(init);
1601     strcpy(dataPtr->init, init);
1602     dataPtr->finalLen = strlen(final);
1603     strcpy(dataPtr->final, final);
1604     dataPtr->numSubTables = Tcl_DStringLength(&escapeData) / sizeof(EscapeSubTable);
1605     memcpy((VOID *) dataPtr->subTables, (VOID *) Tcl_DStringValue(&escapeData),
1606     (size_t) Tcl_DStringLength(&escapeData));
1607     Tcl_DStringFree(&escapeData);
1608    
1609     memset(dataPtr->prefixBytes, 0, sizeof(dataPtr->prefixBytes));
1610     for (i = 0; i < dataPtr->numSubTables; i++) {
1611     dataPtr->prefixBytes[UCHAR(dataPtr->subTables[i].sequence[0])] = 1;
1612     }
1613     if (dataPtr->init[0] != '\0') {
1614     dataPtr->prefixBytes[UCHAR(dataPtr->init[0])] = 1;
1615     }
1616     if (dataPtr->final[0] != '\0') {
1617     dataPtr->prefixBytes[UCHAR(dataPtr->final[0])] = 1;
1618     }
1619    
1620     type.encodingName = name;
1621     type.toUtfProc = EscapeToUtfProc;
1622     type.fromUtfProc = EscapeFromUtfProc;
1623     type.freeProc = EscapeFreeProc;
1624     type.nullSize = 1;
1625     type.clientData = (ClientData) dataPtr;
1626    
1627     return Tcl_CreateEncoding(&type);
1628     }
1629    
1630     /*
1631     *-------------------------------------------------------------------------
1632     *
1633     * BinaryProc --
1634     *
1635     * The default conversion when no other conversion is specified.
1636     * No translation is done; source bytes are copied directly to
1637     * destination bytes.
1638     *
1639     * Results:
1640     * Returns TCL_OK if conversion was successful.
1641     *
1642     * Side effects:
1643     * None.
1644     *
1645     *-------------------------------------------------------------------------
1646     */
1647    
1648     static int
1649     BinaryProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
1650     srcReadPtr, dstWrotePtr, dstCharsPtr)
1651     ClientData clientData; /* Not used. */
1652     CONST char *src; /* Source string (unknown encoding). */
1653     int srcLen; /* Source string length in bytes. */
1654     int flags; /* Conversion control flags. */
1655     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
1656     * state information used during a piecewise
1657     * conversion. Contents of statePtr are
1658     * initialized and/or reset by conversion
1659     * routine under control of flags argument. */
1660     char *dst; /* Output buffer in which converted string
1661     * is stored. */
1662     int dstLen; /* The maximum length of output buffer in
1663     * bytes. */
1664     int *srcReadPtr; /* Filled with the number of bytes from the
1665     * source string that were converted. */
1666     int *dstWrotePtr; /* Filled with the number of bytes that were
1667     * stored in the output buffer as a result of
1668     * the conversion. */
1669     int *dstCharsPtr; /* Filled with the number of characters that
1670     * correspond to the bytes stored in the
1671     * output buffer. */
1672     {
1673     int result;
1674    
1675     result = TCL_OK;
1676     dstLen -= TCL_UTF_MAX - 1;
1677     if (dstLen < 0) {
1678     dstLen = 0;
1679     }
1680     if (srcLen > dstLen) {
1681     srcLen = dstLen;
1682     result = TCL_CONVERT_NOSPACE;
1683     }
1684    
1685     *srcReadPtr = srcLen;
1686     *dstWrotePtr = srcLen;
1687     *dstCharsPtr = srcLen;
1688     for ( ; --srcLen >= 0; ) {
1689     *dst++ = *src++;
1690     }
1691     return result;
1692     }
1693    
1694     /*
1695     *-------------------------------------------------------------------------
1696     *
1697     * UtfToUtfProc --
1698     *
1699     * Convert from UTF-8 to UTF-8. Note that the UTF-8 to UTF-8
1700     * translation is not a no-op, because it will turn a stream of
1701     * improperly formed UTF-8 into a properly formed stream.
1702     *
1703     * Results:
1704     * Returns TCL_OK if conversion was successful.
1705     *
1706     * Side effects:
1707     * None.
1708     *
1709     *-------------------------------------------------------------------------
1710     */
1711    
1712     static int
1713     UtfToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
1714     srcReadPtr, dstWrotePtr, dstCharsPtr)
1715     ClientData clientData; /* Not used. */
1716     CONST char *src; /* Source string in UTF-8. */
1717     int srcLen; /* Source string length in bytes. */
1718     int flags; /* Conversion control flags. */
1719     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
1720     * state information used during a piecewise
1721     * conversion. Contents of statePtr are
1722     * initialized and/or reset by conversion
1723     * routine under control of flags argument. */
1724     char *dst; /* Output buffer in which converted string
1725     * is stored. */
1726     int dstLen; /* The maximum length of output buffer in
1727     * bytes. */
1728     int *srcReadPtr; /* Filled with the number of bytes from the
1729     * source string that were converted. This
1730     * may be less than the original source length
1731     * if there was a problem converting some
1732     * source characters. */
1733     int *dstWrotePtr; /* Filled with the number of bytes that were
1734     * stored in the output buffer as a result of
1735     * the conversion. */
1736     int *dstCharsPtr; /* Filled with the number of characters that
1737     * correspond to the bytes stored in the
1738     * output buffer. */
1739     {
1740     CONST char *srcStart, *srcEnd, *srcClose;
1741     char *dstStart, *dstEnd;
1742     int result, numChars;
1743     Tcl_UniChar ch;
1744    
1745     result = TCL_OK;
1746    
1747     srcStart = src;
1748     srcEnd = src + srcLen;
1749     srcClose = srcEnd;
1750     if ((flags & TCL_ENCODING_END) == 0) {
1751     srcClose -= TCL_UTF_MAX;
1752     }
1753    
1754     dstStart = dst;
1755     dstEnd = dst + dstLen - TCL_UTF_MAX;
1756    
1757     for (numChars = 0; src < srcEnd; numChars++) {
1758     if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
1759     /*
1760     * If there is more string to follow, this will ensure that the
1761     * last UTF-8 character in the source buffer hasn't been cut off.
1762     */
1763    
1764     result = TCL_CONVERT_MULTIBYTE;
1765     break;
1766     }
1767     if (dst > dstEnd) {
1768     result = TCL_CONVERT_NOSPACE;
1769     break;
1770     }
1771     src += Tcl_UtfToUniChar(src, &ch);
1772     dst += Tcl_UniCharToUtf(ch, dst);
1773     }
1774    
1775     *srcReadPtr = src - srcStart;
1776     *dstWrotePtr = dst - dstStart;
1777     *dstCharsPtr = numChars;
1778     return result;
1779     }
1780    
1781     /*
1782     *-------------------------------------------------------------------------
1783     *
1784     * UnicodeToUtfProc --
1785     *
1786     * Convert from Unicode to UTF-8.
1787     *
1788     * Results:
1789     * Returns TCL_OK if conversion was successful.
1790     *
1791     * Side effects:
1792     * None.
1793     *
1794     *-------------------------------------------------------------------------
1795     */
1796    
1797     static int
1798     UnicodeToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
1799     srcReadPtr, dstWrotePtr, dstCharsPtr)
1800     ClientData clientData; /* Not used. */
1801     CONST char *src; /* Source string in Unicode. */
1802     int srcLen; /* Source string length in bytes. */
1803     int flags; /* Conversion control flags. */
1804     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
1805     * state information used during a piecewise
1806     * conversion. Contents of statePtr are
1807     * initialized and/or reset by conversion
1808     * routine under control of flags argument. */
1809     char *dst; /* Output buffer in which converted string
1810     * is stored. */
1811     int dstLen; /* The maximum length of output buffer in
1812     * bytes. */
1813     int *srcReadPtr; /* Filled with the number of bytes from the
1814     * source string that were converted. This
1815     * may be less than the original source length
1816     * if there was a problem converting some
1817     * source characters. */
1818     int *dstWrotePtr; /* Filled with the number of bytes that were
1819     * stored in the output buffer as a result of
1820     * the conversion. */
1821     int *dstCharsPtr; /* Filled with the number of characters that
1822     * correspond to the bytes stored in the
1823     * output buffer. */
1824     {
1825     CONST Tcl_UniChar *wSrc, *wSrcStart, *wSrcEnd;
1826     char *dstEnd, *dstStart;
1827     int result, numChars;
1828    
1829     result = TCL_OK;
1830     if ((srcLen % sizeof(Tcl_UniChar)) != 0) {
1831     result = TCL_CONVERT_MULTIBYTE;
1832     srcLen /= sizeof(Tcl_UniChar);
1833     srcLen *= sizeof(Tcl_UniChar);
1834     }
1835    
1836     wSrc = (Tcl_UniChar *) src;
1837    
1838     wSrcStart = (Tcl_UniChar *) src;
1839     wSrcEnd = (Tcl_UniChar *) (src + srcLen);
1840    
1841     dstStart = dst;
1842     dstEnd = dst + dstLen - TCL_UTF_MAX;
1843    
1844     for (numChars = 0; wSrc < wSrcEnd; numChars++) {
1845     if (dst > dstEnd) {
1846     result = TCL_CONVERT_NOSPACE;
1847     break;
1848     }
1849     dst += Tcl_UniCharToUtf(*wSrc, dst);
1850     wSrc++;
1851     }
1852    
1853     *srcReadPtr = (char *) wSrc - (char *) wSrcStart;
1854     *dstWrotePtr = dst - dstStart;
1855     *dstCharsPtr = numChars;
1856     return result;
1857     }
1858    
1859     /*
1860     *-------------------------------------------------------------------------
1861     *
1862     * UtfToUnicodeProc --
1863     *
1864     * Convert from UTF-8 to Unicode.
1865     *
1866     * Results:
1867     * Returns TCL_OK if conversion was successful.
1868     *
1869     * Side effects:
1870     * None.
1871     *
1872     *-------------------------------------------------------------------------
1873     */
1874    
1875     static int
1876     UtfToUnicodeProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
1877     srcReadPtr, dstWrotePtr, dstCharsPtr)
1878     ClientData clientData; /* TableEncodingData that specifies encoding. */
1879     CONST char *src; /* Source string in UTF-8. */
1880     int srcLen; /* Source string length in bytes. */
1881     int flags; /* Conversion control flags. */
1882     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
1883     * state information used during a piecewise
1884     * conversion. Contents of statePtr are
1885     * initialized and/or reset by conversion
1886     * routine under control of flags argument. */
1887     char *dst; /* Output buffer in which converted string
1888     * is stored. */
1889     int dstLen; /* The maximum length of output buffer in
1890     * bytes. */
1891     int *srcReadPtr; /* Filled with the number of bytes from the
1892     * source string that were converted. This
1893     * may be less than the original source length
1894     * if there was a problem converting some
1895     * source characters. */
1896     int *dstWrotePtr; /* Filled with the number of bytes that were
1897     * stored in the output buffer as a result of
1898     * the conversion. */
1899     int *dstCharsPtr; /* Filled with the number of characters that
1900     * correspond to the bytes stored in the
1901     * output buffer. */
1902     {
1903     CONST char *srcStart, *srcEnd, *srcClose;
1904     Tcl_UniChar *wDst, *wDstStart, *wDstEnd;
1905     int result, numChars;
1906    
1907     srcStart = src;
1908     srcEnd = src + srcLen;
1909     srcClose = srcEnd;
1910     if ((flags & TCL_ENCODING_END) == 0) {
1911     srcClose -= TCL_UTF_MAX;
1912     }
1913    
1914     wDst = (Tcl_UniChar *) dst;
1915     wDstStart = (Tcl_UniChar *) dst;
1916     wDstEnd = (Tcl_UniChar *) (dst + dstLen - sizeof(Tcl_UniChar));
1917    
1918     result = TCL_OK;
1919     for (numChars = 0; src < srcEnd; numChars++) {
1920     if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
1921     /*
1922     * If there is more string to follow, this will ensure that the
1923     * last UTF-8 character in the source buffer hasn't been cut off.
1924     */
1925    
1926     result = TCL_CONVERT_MULTIBYTE;
1927     break;
1928     }
1929     if (wDst > wDstEnd) {
1930     result = TCL_CONVERT_NOSPACE;
1931     break;
1932     }
1933     src += Tcl_UtfToUniChar(src, wDst);
1934     wDst++;
1935     }
1936     *srcReadPtr = src - srcStart;
1937     *dstWrotePtr = (char *) wDst - (char *) wDstStart;
1938     *dstCharsPtr = numChars;
1939     return result;
1940     }
1941    
1942     /*
1943     *-------------------------------------------------------------------------
1944     *
1945     * TableToUtfProc --
1946     *
1947     * Convert from the encoding specified by the TableEncodingData into
1948     * UTF-8.
1949     *
1950     * Results:
1951     * Returns TCL_OK if conversion was successful.
1952     *
1953     * Side effects:
1954     * None.
1955     *
1956     *-------------------------------------------------------------------------
1957     */
1958    
1959     static int
1960     TableToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
1961     srcReadPtr, dstWrotePtr, dstCharsPtr)
1962     ClientData clientData; /* TableEncodingData that specifies
1963     * encoding. */
1964     CONST char *src; /* Source string in specified encoding. */
1965     int srcLen; /* Source string length in bytes. */
1966     int flags; /* Conversion control flags. */
1967     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
1968     * state information used during a piecewise
1969     * conversion. Contents of statePtr are
1970     * initialized and/or reset by conversion
1971     * routine under control of flags argument. */
1972     char *dst; /* Output buffer in which converted string
1973     * is stored. */
1974     int dstLen; /* The maximum length of output buffer in
1975     * bytes. */
1976     int *srcReadPtr; /* Filled with the number of bytes from the
1977     * source string that were converted. This
1978     * may be less than the original source length
1979     * if there was a problem converting some
1980     * source characters. */
1981     int *dstWrotePtr; /* Filled with the number of bytes that were
1982     * stored in the output buffer as a result of
1983     * the conversion. */
1984     int *dstCharsPtr; /* Filled with the number of characters that
1985     * correspond to the bytes stored in the
1986     * output buffer. */
1987     {
1988     CONST char *srcStart, *srcEnd;
1989     char *dstEnd, *dstStart, *prefixBytes;
1990     int result, byte, numChars;
1991     Tcl_UniChar ch;
1992     unsigned short **toUnicode;
1993     unsigned short *pageZero;
1994     TableEncodingData *dataPtr;
1995    
1996     srcStart = src;
1997     srcEnd = src + srcLen;
1998    
1999     dstStart = dst;
2000     dstEnd = dst + dstLen - TCL_UTF_MAX;
2001    
2002     dataPtr = (TableEncodingData *) clientData;
2003     toUnicode = dataPtr->toUnicode;
2004     prefixBytes = dataPtr->prefixBytes;
2005     pageZero = toUnicode[0];
2006    
2007     result = TCL_OK;
2008     for (numChars = 0; src < srcEnd; numChars++) {
2009     if (dst > dstEnd) {
2010     result = TCL_CONVERT_NOSPACE;
2011     break;
2012     }
2013     byte = *((unsigned char *) src);
2014     if (prefixBytes[byte]) {
2015     src++;
2016     if (src >= srcEnd) {
2017     src--;
2018     result = TCL_CONVERT_MULTIBYTE;
2019     break;
2020     }
2021     ch = toUnicode[byte][*((unsigned char *) src)];
2022     } else {
2023     ch = pageZero[byte];
2024     }
2025     if ((ch == 0) && (byte != 0)) {
2026     if (flags & TCL_ENCODING_STOPONERROR) {
2027     result = TCL_CONVERT_SYNTAX;
2028     break;
2029     }
2030     if (prefixBytes[byte]) {
2031     src--;
2032     }
2033     ch = (Tcl_UniChar) byte;
2034     }
2035     dst += Tcl_UniCharToUtf(ch, dst);
2036     src++;
2037     }
2038     *srcReadPtr = src - srcStart;
2039     *dstWrotePtr = dst - dstStart;
2040     *dstCharsPtr = numChars;
2041     return result;
2042     }
2043    
2044     /*
2045     *-------------------------------------------------------------------------
2046     *
2047     * TableFromUtfProc --
2048     *
2049     * Convert from UTF-8 into the encoding specified by the
2050     * TableEncodingData.
2051     *
2052     * Results:
2053     * Returns TCL_OK if conversion was successful.
2054     *
2055     * Side effects:
2056     * None.
2057     *
2058     *-------------------------------------------------------------------------
2059     */
2060    
2061     static int
2062     TableFromUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
2063     srcReadPtr, dstWrotePtr, dstCharsPtr)
2064     ClientData clientData; /* TableEncodingData that specifies
2065     * encoding. */
2066     CONST char *src; /* Source string in UTF-8. */
2067     int srcLen; /* Source string length in bytes. */
2068     int flags; /* Conversion control flags. */
2069     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
2070     * state information used during a piecewise
2071     * conversion. Contents of statePtr are
2072     * initialized and/or reset by conversion
2073     * routine under control of flags argument. */
2074     char *dst; /* Output buffer in which converted string
2075     * is stored. */
2076     int dstLen; /* The maximum length of output buffer in
2077     * bytes. */
2078     int *srcReadPtr; /* Filled with the number of bytes from the
2079     * source string that were converted. This
2080     * may be less than the original source length
2081     * if there was a problem converting some
2082     * source characters. */
2083     int *dstWrotePtr; /* Filled with the number of bytes that were
2084     * stored in the output buffer as a result of
2085     * the conversion. */
2086     int *dstCharsPtr; /* Filled with the number of characters that
2087     * correspond to the bytes stored in the
2088     * output buffer. */
2089     {
2090     CONST char *srcStart, *srcEnd, *srcClose;
2091     char *dstStart, *dstEnd, *prefixBytes;
2092     Tcl_UniChar ch;
2093     int result, len, word, numChars;
2094     TableEncodingData *dataPtr;
2095     unsigned short **fromUnicode;
2096    
2097     result = TCL_OK;
2098    
2099     dataPtr = (TableEncodingData *) clientData;
2100     prefixBytes = dataPtr->prefixBytes;
2101     fromUnicode = dataPtr->fromUnicode;
2102    
2103     srcStart = src;
2104     srcEnd = src + srcLen;
2105     srcClose = srcEnd;
2106     if ((flags & TCL_ENCODING_END) == 0) {
2107     srcClose -= TCL_UTF_MAX;
2108     }
2109    
2110     dstStart = dst;
2111     dstEnd = dst + dstLen - 1;
2112    
2113     for (numChars = 0; src < srcEnd; numChars++) {
2114     if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
2115     /*
2116     * If there is more string to follow, this will ensure that the
2117     * last UTF-8 character in the source buffer hasn't been cut off.
2118     */
2119    
2120     result = TCL_CONVERT_MULTIBYTE;
2121     break;
2122     }
2123     len = Tcl_UtfToUniChar(src, &ch);
2124     word = fromUnicode[(ch >> 8)][ch & 0xff];
2125     if ((word == 0) && (ch != 0)) {
2126     if (flags & TCL_ENCODING_STOPONERROR) {
2127     result = TCL_CONVERT_UNKNOWN;
2128     break;
2129     }
2130     word = dataPtr->fallback;
2131     }
2132     if (prefixBytes[(word >> 8)] != 0) {
2133     if (dst + 1 > dstEnd) {
2134     result = TCL_CONVERT_NOSPACE;
2135     break;
2136     }
2137     dst[0] = (char) (word >> 8);
2138     dst[1] = (char) word;
2139     dst += 2;
2140     } else {
2141     if (dst > dstEnd) {
2142     result = TCL_CONVERT_NOSPACE;
2143     break;
2144     }
2145     dst[0] = (char) word;
2146     dst++;
2147     }
2148     src += len;
2149     }
2150     *srcReadPtr = src - srcStart;
2151     *dstWrotePtr = dst - dstStart;
2152     *dstCharsPtr = numChars;
2153     return result;
2154     }
2155    
2156     /*
2157     *---------------------------------------------------------------------------
2158     *
2159     * TableFreeProc --
2160     *
2161     * This procedure is invoked when an encoding is deleted. It deletes
2162     * the memory used by the TableEncodingData.
2163     *
2164     * Results:
2165     * None.
2166     *
2167     * Side effects:
2168     * Memory freed.
2169     *
2170     *---------------------------------------------------------------------------
2171     */
2172    
2173     static void
2174     TableFreeProc(clientData)
2175     ClientData clientData; /* TableEncodingData that specifies
2176     * encoding. */
2177     {
2178     TableEncodingData *dataPtr;
2179    
2180     dataPtr = (TableEncodingData *) clientData;
2181     ckfree((char *) dataPtr->toUnicode);
2182     ckfree((char *) dataPtr->fromUnicode);
2183     ckfree((char *) dataPtr);
2184     }
2185    
2186     /*
2187     *-------------------------------------------------------------------------
2188     *
2189     * EscapeToUtfProc --
2190     *
2191     * Convert from the encoding specified by the EscapeEncodingData into
2192     * UTF-8.
2193     *
2194     * Results:
2195     * Returns TCL_OK if conversion was successful.
2196     *
2197     * Side effects:
2198     * None.
2199     *
2200     *-------------------------------------------------------------------------
2201     */
2202    
2203     static int
2204     EscapeToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
2205     srcReadPtr, dstWrotePtr, dstCharsPtr)
2206     ClientData clientData; /* EscapeEncodingData that specifies
2207     * encoding. */
2208     CONST char *src; /* Source string in specified encoding. */
2209     int srcLen; /* Source string length in bytes. */
2210     int flags; /* Conversion control flags. */
2211     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
2212     * state information used during a piecewise
2213     * conversion. Contents of statePtr are
2214     * initialized and/or reset by conversion
2215     * routine under control of flags argument. */
2216     char *dst; /* Output buffer in which converted string
2217     * is stored. */
2218     int dstLen; /* The maximum length of output buffer in
2219     * bytes. */
2220     int *srcReadPtr; /* Filled with the number of bytes from the
2221     * source string that were converted. This
2222     * may be less than the original source length
2223     * if there was a problem converting some
2224     * source characters. */
2225     int *dstWrotePtr; /* Filled with the number of bytes that were
2226     * stored in the output buffer as a result of
2227     * the conversion. */
2228     int *dstCharsPtr; /* Filled with the number of characters that
2229     * correspond to the bytes stored in the
2230     * output buffer. */
2231     {
2232     EscapeEncodingData *dataPtr;
2233     char *prefixBytes, *tablePrefixBytes;
2234     unsigned short **tableToUnicode;
2235     Encoding *encodingPtr;
2236     int state, result, numChars;
2237     CONST char *srcStart, *srcEnd;
2238     char *dstStart, *dstEnd;
2239    
2240     result = TCL_OK;
2241    
2242     tablePrefixBytes = NULL; /* lint. */
2243     tableToUnicode = NULL; /* lint. */
2244    
2245     dataPtr = (EscapeEncodingData *) clientData;
2246     prefixBytes = dataPtr->prefixBytes;
2247     encodingPtr = NULL;
2248    
2249     srcStart = src;
2250     srcEnd = src + srcLen;
2251    
2252     dstStart = dst;
2253     dstEnd = dst + dstLen - TCL_UTF_MAX;
2254    
2255     state = (int) *statePtr;
2256     if (flags & TCL_ENCODING_START) {
2257     state = 0;
2258     }
2259    
2260     for (numChars = 0; src < srcEnd; ) {
2261     int byte, hi, lo, ch;
2262    
2263     if (dst > dstEnd) {
2264     result = TCL_CONVERT_NOSPACE;
2265     break;
2266     }
2267     byte = *((unsigned char *) src);
2268     if (prefixBytes[byte]) {
2269     unsigned int left, len, longest;
2270     int checked, i;
2271     EscapeSubTable *subTablePtr;
2272    
2273     /*
2274     * Saw the beginning of an escape sequence.
2275     */
2276    
2277     left = srcEnd - src;
2278     len = dataPtr->initLen;
2279     longest = len;
2280     checked = 0;
2281     if (len <= left) {
2282     checked++;
2283     if ((len > 0) &&
2284     (memcmp(src, dataPtr->init, len) == 0)) {
2285     /*
2286     * If we see initialization string, skip it, even if we're
2287     * not at the beginning of the buffer.
2288     */
2289    
2290     src += len;
2291     continue;
2292     }
2293     }
2294     len = dataPtr->finalLen;
2295     if (len > longest) {
2296     longest = len;
2297     }
2298     if (len <= left) {
2299     checked++;
2300     if ((len > 0) &&
2301     (memcmp(src, dataPtr->final, len) == 0)) {
2302     /*
2303     * If we see finalization string, skip it, even if we're
2304     * not at the end of the buffer.
2305     */
2306    
2307     src += len;
2308     continue;
2309     }
2310     }
2311     subTablePtr = dataPtr->subTables;
2312     for (i = 0; i < dataPtr->numSubTables; i++) {
2313     len = subTablePtr->sequenceLen;
2314     if (len > longest) {
2315     longest = len;
2316     }
2317     if (len <= left) {
2318     checked++;
2319     if ((len > 0) &&
2320     (memcmp(src, subTablePtr->sequence, len) == 0)) {
2321     state = i;
2322     encodingPtr = NULL;
2323     subTablePtr = NULL;
2324     src += len;
2325     break;
2326     }
2327     }
2328     subTablePtr++;
2329     }
2330     if (subTablePtr == NULL) {
2331     /*
2332     * A match was found, the escape sequence was consumed, and
2333     * the state was updated.
2334     */
2335    
2336     continue;
2337     }
2338    
2339     /*
2340     * We have a split-up or unrecognized escape sequence. If we
2341     * checked all the sequences, then it's a syntax error,
2342     * otherwise we need more bytes to determine a match.
2343     */
2344    
2345     if ((checked == dataPtr->numSubTables + 2)
2346     || (flags & TCL_ENCODING_END)) {
2347     if ((flags & TCL_ENCODING_STOPONERROR) == 0) {
2348     /*
2349     * Skip the unknown escape sequence.
2350     */
2351    
2352     src += longest;
2353     continue;
2354     }
2355     result = TCL_CONVERT_SYNTAX;
2356     } else {
2357     result = TCL_CONVERT_MULTIBYTE;
2358     }
2359     break;
2360     }
2361    
2362     if (encodingPtr == NULL) {
2363     TableEncodingData *tableDataPtr;
2364    
2365     encodingPtr = GetTableEncoding(dataPtr, state);
2366     tableDataPtr = (TableEncodingData *) encodingPtr->clientData;
2367     tablePrefixBytes = tableDataPtr->prefixBytes;
2368     tableToUnicode = tableDataPtr->toUnicode;
2369     }
2370     if (tablePrefixBytes[byte]) {
2371     src++;
2372     if (src >= srcEnd) {
2373     src--;
2374     result = TCL_CONVERT_MULTIBYTE;
2375     break;
2376     }
2377     hi = byte;
2378     lo = *((unsigned char *) src);
2379     } else {
2380     hi = 0;
2381     lo = byte;
2382     }
2383     ch = tableToUnicode[hi][lo];
2384     dst += Tcl_UniCharToUtf(ch, dst);
2385     src++;
2386     numChars++;
2387     }
2388    
2389     *statePtr = (Tcl_EncodingState) state;
2390     *srcReadPtr = src - srcStart;
2391     *dstWrotePtr = dst - dstStart;
2392     *dstCharsPtr = numChars;
2393     return result;
2394     }
2395    
2396     /*
2397     *-------------------------------------------------------------------------
2398     *
2399     * EscapeFromUtfProc --
2400     *
2401     * Convert from UTF-8 into the encoding specified by the
2402     * EscapeEncodingData.
2403     *
2404     * Results:
2405     * Returns TCL_OK if conversion was successful.
2406     *
2407     * Side effects:
2408     * None.
2409     *
2410     *-------------------------------------------------------------------------
2411     */
2412    
2413     static int
2414     EscapeFromUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
2415     srcReadPtr, dstWrotePtr, dstCharsPtr)
2416     ClientData clientData; /* EscapeEncodingData that specifies
2417     * encoding. */
2418     CONST char *src; /* Source string in UTF-8. */
2419     int srcLen; /* Source string length in bytes. */
2420     int flags; /* Conversion control flags. */
2421     Tcl_EncodingState *statePtr;/* Place for conversion routine to store
2422     * state information used during a piecewise
2423     * conversion. Contents of statePtr are
2424     * initialized and/or reset by conversion
2425     * routine under control of flags argument. */
2426     char *dst; /* Output buffer in which converted string
2427     * is stored. */
2428     int dstLen; /* The maximum length of output buffer in
2429     * bytes. */
2430     int *srcReadPtr; /* Filled with the number of bytes from the
2431     * source string that were converted. This
2432     * may be less than the original source length
2433     * if there was a problem converting some
2434     * source characters. */
2435     int *dstWrotePtr; /* Filled with the number of bytes that were
2436     * stored in the output buffer as a result of
2437     * the conversion. */
2438     int *dstCharsPtr; /* Filled with the number of characters that
2439     * correspond to the bytes stored in the
2440     * output buffer. */
2441     {
2442     EscapeEncodingData *dataPtr;
2443     Encoding *encodingPtr;
2444     CONST char *srcStart, *srcEnd, *srcClose;
2445     char *dstStart, *dstEnd;
2446     int state, result, numChars;
2447     TableEncodingData *tableDataPtr;
2448     char *tablePrefixBytes;
2449     unsigned short **tableFromUnicode;
2450    
2451     result = TCL_OK;
2452    
2453     dataPtr = (EscapeEncodingData *) clientData;
2454    
2455     srcStart = src;
2456     srcEnd = src + srcLen;
2457     srcClose = srcEnd;
2458     if ((flags & TCL_ENCODING_END) == 0) {
2459     srcClose -= TCL_UTF_MAX;
2460     }
2461    
2462     dstStart = dst;
2463     dstEnd = dst + dstLen - 1;
2464    
2465     if (flags & TCL_ENCODING_START) {
2466     unsigned int len;
2467    
2468     state = 0;
2469     len = dataPtr->subTables[0].sequenceLen;
2470     if (dst + dataPtr->initLen + len > dstEnd) {
2471     *srcReadPtr = 0;
2472     *dstWrotePtr = 0;
2473     return TCL_CONVERT_NOSPACE;
2474     }
2475     memcpy((VOID *) dst, (VOID *) dataPtr->init,
2476     (size_t) dataPtr->initLen);
2477     dst += dataPtr->initLen;
2478     memcpy((VOID *) dst, (VOID *) dataPtr->subTables[0].sequence,
2479     (size_t) len);
2480     dst += len;
2481     } else {
2482     state = (int) *statePtr;
2483     }
2484    
2485     encodingPtr = GetTableEncoding(dataPtr, state);
2486     tableDataPtr = (TableEncodingData *) encodingPtr->clientData;
2487     tablePrefixBytes = tableDataPtr->prefixBytes;
2488     tableFromUnicode = tableDataPtr->fromUnicode;
2489    
2490     for (numChars = 0; src < srcEnd; numChars++) {
2491     unsigned int len;
2492     int word;
2493     Tcl_UniChar ch;
2494    
2495     if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
2496     /*
2497     * If there is more string to follow, this will ensure that the
2498     * last UTF-8 character in the source buffer hasn't been cut off.
2499     */
2500    
2501     result = TCL_CONVERT_MULTIBYTE;
2502     break;
2503     }
2504     len = Tcl_UtfToUniChar(src, &ch);
2505     word = tableFromUnicode[(ch >> 8)][ch & 0xff];
2506    
2507     if ((word == 0) && (ch != 0)) {
2508     int oldState;
2509     EscapeSubTable *subTablePtr;
2510    
2511     oldState = state;
2512     for (state = 0; state < dataPtr->numSubTables; state++) {
2513     encodingPtr = GetTableEncoding(dataPtr, state);
2514     tableDataPtr = (TableEncodingData *) encodingPtr->clientData;
2515     word = tableDataPtr->fromUnicode[(ch >> 8)][ch & 0xff];
2516     if (word != 0) {
2517     break;
2518     }
2519     }
2520    
2521     if (word == 0) {
2522     state = oldState;
2523     if (flags & TCL_ENCODING_STOPONERROR) {
2524     result = TCL_CONVERT_UNKNOWN;
2525     break;
2526     }
2527     encodingPtr = GetTableEncoding(dataPtr, state);
2528     tableDataPtr = (TableEncodingData *) encodingPtr->clientData;
2529     word = tableDataPtr->fallback;
2530     }
2531    
2532     tablePrefixBytes = tableDataPtr->prefixBytes;
2533     tableFromUnicode = tableDataPtr->fromUnicode;
2534    
2535     subTablePtr = &dataPtr->subTables[state];
2536     if (dst + subTablePtr->sequenceLen > dstEnd) {
2537     result = TCL_CONVERT_NOSPACE;
2538     break;
2539     }
2540     memcpy((VOID *) dst, (VOID *) subTablePtr->sequence,
2541     (size_t) subTablePtr->sequenceLen);
2542     dst += subTablePtr->sequenceLen;
2543     }
2544    
2545     if (tablePrefixBytes[(word >> 8)] != 0) {
2546     if (dst + 1 > dstEnd) {
2547     result = TCL_CONVERT_NOSPACE;
2548     break;
2549     }
2550     dst[0] = (char) (word >> 8);
2551     dst[1] = (char) word;
2552     dst += 2;
2553     } else {
2554     if (dst > dstEnd) {
2555     result = TCL_CONVERT_NOSPACE;
2556     break;
2557     }
2558     dst[0] = (char) word;
2559     dst++;
2560     }
2561     src += len;
2562     }
2563    
2564     if ((result == TCL_OK) && (flags & TCL_ENCODING_END)) {
2565     if (dst + dataPtr->finalLen > dstEnd) {
2566     result = TCL_CONVERT_NOSPACE;
2567     } else {
2568     memcpy((VOID *) dst, (VOID *) dataPtr->final,
2569     (size_t) dataPtr->finalLen);
2570     dst += dataPtr->finalLen;
2571     }
2572     }
2573    
2574     *statePtr = (Tcl_EncodingState) state;
2575     *srcReadPtr = src - srcStart;
2576     *dstWrotePtr = dst - dstStart;
2577     *dstCharsPtr = numChars;
2578     return result;
2579     }
2580    
2581     /*
2582     *---------------------------------------------------------------------------
2583     *
2584     * EscapeFreeProc --
2585     *
2586     * This procedure is invoked when an EscapeEncodingData encoding is
2587     * deleted. It deletes the memory used by the encoding.
2588     *
2589     * Results:
2590     * None.
2591     *
2592     * Side effects:
2593     * Memory freed.
2594     *
2595     *---------------------------------------------------------------------------
2596     */
2597    
2598     static void
2599     EscapeFreeProc(clientData)
2600     ClientData clientData; /* EscapeEncodingData that specifies encoding. */
2601     {
2602     EscapeEncodingData *dataPtr;
2603     EscapeSubTable *subTablePtr;
2604     int i;
2605    
2606     dataPtr = (EscapeEncodingData *) clientData;
2607     if (dataPtr == NULL) {
2608     return;
2609     }
2610     subTablePtr = dataPtr->subTables;
2611     for (i = 0; i < dataPtr->numSubTables; i++) {
2612     FreeEncoding((Tcl_Encoding) subTablePtr->encodingPtr);
2613     subTablePtr++;
2614     }
2615     ckfree((char *) dataPtr);
2616     }
2617    
2618     /*
2619     *---------------------------------------------------------------------------
2620     *
2621     * GetTableEncoding --
2622     *
2623     * Helper function for the EscapeEncodingData conversions. Gets the
2624     * encoding (of type TextEncodingData) that represents the specified
2625     * state.
2626     *
2627     * Results:
2628     * The return value is the encoding.
2629     *
2630     * Side effects:
2631     * If the encoding that represents the specified state has not
2632     * already been used by this EscapeEncoding, it will be loaded
2633     * and cached in the dataPtr.
2634     *
2635     *---------------------------------------------------------------------------
2636     */
2637    
2638     static Encoding *
2639     GetTableEncoding(dataPtr, state)
2640     EscapeEncodingData *dataPtr;/* Contains names of encodings. */
2641     int state; /* Index in dataPtr of desired Encoding. */
2642     {
2643     EscapeSubTable *subTablePtr;
2644     Encoding *encodingPtr;
2645    
2646     subTablePtr = &dataPtr->subTables[state];
2647     encodingPtr = subTablePtr->encodingPtr;
2648     if (encodingPtr == NULL) {
2649     encodingPtr = (Encoding *) Tcl_GetEncoding(NULL, subTablePtr->name);
2650     if ((encodingPtr == NULL)
2651     || (encodingPtr->toUtfProc != TableToUtfProc)) {
2652     panic("EscapeToUtfProc: invalid sub table");
2653     }
2654     subTablePtr->encodingPtr = encodingPtr;
2655     }
2656     return encodingPtr;
2657     }
2658    
2659     /*
2660     *---------------------------------------------------------------------------
2661     *
2662     * unilen --
2663     *
2664     * A helper function for the Tcl_ExternalToUtf functions. This
2665     * function is similar to strlen for double-byte characters: it
2666     * returns the number of bytes in a 0x0000 terminated string.
2667     *
2668     * Results:
2669     * As above.
2670     *
2671     * Side effects:
2672     * None.
2673     *
2674     *---------------------------------------------------------------------------
2675     */
2676    
2677     static size_t
2678     unilen(src)
2679     CONST char *src;
2680     {
2681     unsigned short *p;
2682    
2683     p = (unsigned short *) src;
2684     while (*p != 0x0000) {
2685     p++;
2686     }
2687     return (char *) p - src;
2688     }
2689    
2690    
2691     /*
2692     *-------------------------------------------------------------------------
2693     *
2694     * TclFindEncodings --
2695     *
2696     * Find and load the encoding file for this operating system.
2697     * Before this is called, Tcl makes assumptions about the
2698     * native string representation, but the true encoding is not
2699     * assured.
2700     *
2701     * Results:
2702     * None.
2703     *
2704     * Side effects:
2705     * Varied, see the respective initialization routines.
2706     *
2707     *-------------------------------------------------------------------------
2708     */
2709    
2710     void
2711     TclFindEncodings(argv0)
2712     CONST char *argv0; /* Name of executable from argv[0] to main()
2713     * in native multi-byte encoding. */
2714     {
2715     char *native;
2716     Tcl_Obj *pathPtr;
2717     Tcl_DString libPath, buffer;
2718    
2719     if (encodingsInitialized == 0) {
2720     /*
2721     * Double check inside the mutex. There may be calls
2722     * back into this routine from some of the procedures below.
2723     */
2724    
2725     TclpInitLock();
2726     if (encodingsInitialized == 0) {
2727     /*
2728     * Have to set this bit here to avoid deadlock with the
2729     * routines below us that call into TclInitSubsystems.
2730     */
2731    
2732     encodingsInitialized = 1;
2733    
2734     native = TclpFindExecutable(argv0);
2735     TclpInitLibraryPath(native);
2736    
2737     /*
2738     * The library path was set in the TclpInitLibraryPath routine.
2739     * The string set is a dirty UTF string. To preserve the value
2740     * convert the UTF string back to native before setting the new
2741     * default encoding.
2742     */
2743    
2744     pathPtr = TclGetLibraryPath();
2745     if (pathPtr != NULL) {
2746     Tcl_UtfToExternalDString(NULL, Tcl_GetString(pathPtr), -1,
2747     &libPath);
2748     }
2749    
2750     TclpSetInitialEncodings();
2751    
2752     /*
2753     * Now convert the native string back to UTF.
2754     */
2755    
2756     if (pathPtr != NULL) {
2757     Tcl_ExternalToUtfDString(NULL, Tcl_DStringValue(&libPath), -1,
2758     &buffer);
2759     pathPtr = Tcl_NewStringObj(Tcl_DStringValue(&buffer), -1);
2760     TclSetLibraryPath(pathPtr);
2761    
2762     Tcl_DStringFree(&libPath);
2763     Tcl_DStringFree(&buffer);
2764     }
2765     }
2766     TclpInitUnlock();
2767     }
2768     }
2769    
2770    
2771     /* $History: tclencoding.c $
2772     *
2773     * ***************** Version 1 *****************
2774     * User: Dtashley Date: 1/02/01 Time: 1:26a
2775     * Created in $/IjuScripter, IjuConsole/Source/Tcl Base
2776     * Initial check-in.
2777     */
2778    
2779     /* End of TCLENCODING.C */

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25