2002-04-05 Daniel Steffen <das@users.sourceforge.net>

* mac/tclMacPkgConfig.c: Added Mac implementation of pkgconfig. * tests/config.test: fixed failing tests.
Changed paths from prefix_exec_prefix to the individual
2002-04-05 13:49:45 +00:00 · 2002-02-19 22:01:17 +00:00 · 2002-02-06 12:21:43 +00:00 · 2002-02-06 12:20:26 +00:00 · 2002-02-05 23:58:02 +00:00 · 2002-02-05 23:05:17 +00:00
1704 changed files with 168807 additions and 485407 deletions
@@ -1,3 +0,0 @@
-*.bmp
-*.gif
-*.png
@@ -1,24 +0,0 @@
-*.a
-*.dll
-*.dylib
-*.exe
-*.exp
-*.lib
-*.o
-*.obj
-*.res
-*.sl
-*.so
-*/Makefile
-*/config.cache
-*/config.log
-*/config.status
-*/tclConfig.sh
-*/tclsh*
-*/tcltest*
-*/versions.vc
-unix/dltest.marker
-unix/tcl.pc
-unix/pkgs/*
-win/pkgs/*
-win/tcl.hpj
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>tcl8.5</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-	</buildSpec>
-	<natures>
-	</natures>
-</projectDescription>
@@ -1,2 +0,0 @@
-eclipse.preferences.version=1
-encoding/<project>=UTF-8
@@ -1,2 +0,0 @@
-eclipse.preferences.version=1
-line.separator=\n
@@ -1,7 +1,11 @@
 README:  Tcl
-    This is the Tcl 8.5.15 source distribution.
-	http://sourceforge.net/projects/tcl/files/Tcl/
-    You can get any source release of Tcl from the URL above.
+    This is the Tcl 8.4a4 source distribution.
+    Tcl/Tk is also available through NetCVS:
+	http://tcl.sourceforge.net/
+    You can get any source release of Tcl from the file distributions
+    link at the above URL.
+
+RCS: @(#) $Id: README,v 1.39 2001/08/08 22:28:23 dgp Exp $

 Contents
 --------
@@ -10,10 +14,10 @@ Contents
    3. Compiling and installing Tcl
    4. Development tools
    5. Tcl newsgroup
-    6. The Tcler's Wiki
-    7. Mailing lists
-    8. Support and Training
-    9. Tracking Development
+    6. Tcl contributed archive
+    7. Tcl Resource Center
+    8. Mailing lists
+    9. Support and Training
    10. Thank You

 1. Introduction
@@ -21,23 +25,18 @@ Contents
 Tcl provides a powerful platform for creating integration applications that
 tie together diverse applications, protocols, devices, and frameworks.
 When paired with the Tk toolkit, Tcl provides the fastest and most powerful
-way to create GUI applications that run on PCs, Unix, and Mac OS X.
+way to create GUI applications that run on PCs, Unix, and the Macintosh.
 Tcl can also be used for a variety of web-related tasks and for creating
 powerful command languages for applications.

 Tcl is maintained, enhanced, and distributed freely by the Tcl community.
-Source code development and tracking of bug reports and feature requests
-takes place at:
+The home for Tcl/Tk sources and bug/patch database is on SourceForge:

-	http://core.tcl.tk/
-
-Tcl/Tk release and mailing list services are hosted by SourceForge:
-
-	http://sourceforge.net/projects/tcl/
+	http://tcl.sourceforge.net/

 with the Tcl Developer Xchange hosted at:

-	http://www.tcl.tk/
+	http://www.purl.org/tcl/home/

 Tcl is a freely available open source package.  You can do virtually
 anything you like with it, such as modifying it, redistributing it,
@@ -49,21 +48,17 @@ and selling it either in whole or in part.  See the file

 Extensive documentation is available at our website.
 The home page for this release, including new features, is
-	http://www.tcl.tk/software/tcltk/8.5.html
+	http://www.purl.org/tcl/home/software/tcltk/8.4.html

 Detailed release notes can be found at the file distributions page
 by clicking on the relevant version.
-	http://sourceforge.net/projects/tcl/files/Tcl/
+	http://sourceforge.net/project/showfiles.php?group_id=10894

 Information about Tcl itself can be found at
-	http://www.tcl.tk/about/
+	http://www.purl.org/tcl/home/scripting/

-There have been many Tcl books on the market.  Many are mentioned in the Wiki:
-	http://wiki.tcl.tk/_/ref?N=25206
-
-To view the complete set of reference manual entries for Tcl 8.5 online,
-visit the URL:
-	http://www.tcl.tk/man/tcl8.5/
+There are many Tcl books on the market.  Most are listed at
+	http://www.purl.org/tcl/home/resource/doc/books/

 2a. Unix Documentation
 ----------------------
@@ -97,45 +92,53 @@ Windows help Tcl documentation will appear in the "Start" menu:
 3. Compiling and installing Tcl
 -------------------------------

-There are brief notes in the unix/README, win/README, and macosx/README about
+There are brief notes in the unix/README, win/README, and mac/README about
 compiling on these different platforms.  There is additional information
 about building Tcl from sources at

-	http://www.tcl.tk/doc/howto/compile.html
+	http://www.purl.org/tcl/home/doc/howto/compile.html

-4. Development tools
+4. TclPro Development tools
 ---------------------------

-ActiveState produces a high quality set of commercial quality development
-tools that is available to accelerate your Tcl application development.
-Tcl Dev Kit builds on the earlier TclPro toolset and provides a debugger,
-static code checker, single-file wrapping utility, bytecode compiler and
-more.  More information can be found at
+A high quality set of commercial quality development tools is available to
+accelerate your Tcl application development.  The TclPro product provides a
+debugger, static code checker, packaging utility, and bytecode compiler.
+TclPro was open-sourced when Scriptics/Ajuba was acquired by Interwoven.
+Visit its home at SourceForge for more information and source/binaries:

-	http://www.ActiveState.com/Tcl
+	http://tclpro.sourceforge.net/

 5. Tcl newsgroup
 ----------------

-There is a USENET news group, "comp.lang.tcl", intended for the exchange of
+There is a network news group "comp.lang.tcl" intended for the exchange of
 information about Tcl, Tk, and related applications.  The newsgroup is a
 great place to ask general information questions.  For bug reports, please
 see the "Support and bug fixes" section below.

-6. Tcl'ers Wiki
---------------
+6. Tcl contributed archive
+--------------------------

-A Wiki-based open community site covering all aspects of Tcl/Tk is at:
+Many people have created exciting packages and applications based on Tcl
+and/or Tk and made them freely available to the Tcl community.  An archive
+of these contributions is kept on the machine ftp.neosoft.com.  You
+can access the archive using anonymous FTP; the Tcl contributed archive is
+in the directory "/pub/tcl".  The archive also contains several FAQ
+("frequently asked questions") documents that provide solutions to problems
+that are commonly encountered by TCL newcomers.

-	http://wiki.tcl.tk/
+7. Tcl Resource Center
+----------------------

-It is dedicated to the Tcl programming language and its extensions.  A
-wealth of useful information can be found there.  It contains code
-snippets, references to papers, books, and FAQs, as well as pointers to
-development tools, extensions, and applications.  You can also recommend
-additional URLs by editing the wiki yourself.
+Visit http://www.purl.org/tcl/home/resource/ to see an annotated index of
+many Tcl resources available on the World Wide Web.  This includes
+papers, books, and FAQs, as well as development tools, extensions,
+applications, binary releases, and patches.  You can also recommend
+additional URLs for the resource center using the forms labeled "Add a
+Resource".

-7. Mailing lists
+8. Mailing lists
 ----------------

 Several mailing lists are hosted at SourceForge to discuss development or
@@ -146,36 +149,34 @@ to subscribe, visit:

 and go to the Mailing Lists page.

-8. Support and Training
+9. Support and Training
 ------------------------

 We are very interested in receiving bug reports, patches, and suggestions
-for improvements.  We prefer that you send this information to us as
-tickets entered into our tracker at:
+for improvements.  We prefer that you send this information to us via the
+bug form at SourceForge, rather than emailing us directly.  The bug
+database is at:

-	http://core.tcl.tk/tcl/reportlist
+	http://tcl.sourceforge.net/
+
+The bug form was designed to give uniform structure to bug reports as
+well as to solicit enough information to minimize followup questions.

 We will log and follow-up on each bug, although we cannot promise a
 specific turn-around time.  Enhancements may take longer and may not happen
-at all unless there is widespread support for them (we're trying to
-slow the rate at which Tcl/Tk turns into a kitchen sink).  It's very
-difficult to make incompatible changes to Tcl/Tk at this point, due to
-the size of the installed base.
+at all unless there is widespread support for them (we're trying to slow
+the rate at which Tcl/Tk turns into a kitchen sink).  It's very difficult
+to make incompatible changes to Tcl/Tk at this point, due to the size of
+the installed base.

 The Tcl community is too large for us to provide much individual support
 for users.  If you need help we suggest that you post questions to
 comp.lang.tcl.  We read the newsgroup and will attempt to answer esoteric
-questions for which no one else is likely to know the answer.  In addition,
+questions for which no-one else is likely to know the answer.  In addition,
 see the following Web site for links to other organizations that offer
 Tcl/Tk training:

-	http://wiki.tcl.tk/training
-
-9. Tracking Development
-----------------------
-
-Tcl is developed in public.  To keep an eye on how Tcl is changing, see
-	http://core.tcl.tk/
+	http://www.purl.org/tcl/home/resource/community/commercial/training

 10. Thank You
 -------------
@@ -4,3 +4,5 @@ systems.  Typically, files from this directory are used to compile
 Tcl when a system doesn't contain the corresponding files or when
 they are known to be incorrect.  When the whole world becomes POSIX-
 compliant this directory should be unnecessary.
+
+RCS: @(#) $Id: README,v 1.2 1998/09/14 18:39:44 stanton Exp $
@@ -9,6 +9,8 @@
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: dirent.h,v 1.2 1998/09/14 18:39:44 stanton Exp $
 */

 #ifndef _DIRENT
@@ -9,11 +9,17 @@
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: dirent2.h,v 1.2 1998/09/14 18:39:44 stanton Exp $
 */

 #ifndef _DIRENT
 #define _DIRENT

+#ifndef _TCL
+#include <tcl.h>
+#endif
+
 /*
 * Dirent structure, which holds information about a single
 * directory entry.
@@ -46,8 +52,8 @@ typedef struct _dirdesc {
 * Procedures defined for reading directories:
 */

-extern void		closedir (DIR *dirp);
-extern DIR *		opendir (char *name);
-extern struct dirent *	readdir (DIR *dirp);
+extern void		closedir _ANSI_ARGS_((DIR *dirp));
+extern DIR *		opendir _ANSI_ARGS_((char *name));
+extern struct dirent *	readdir _ANSI_ARGS_((DIR *dirp));

 #endif /* _DIRENT */
@@ -1,4 +1,4 @@
-/*
+/* 
 * dlfcn.h --
 *
 *	This file provides a replacement for the header file "dlfcn.h"
@@ -16,9 +16,12 @@
 *	this software, provided that the author is not construed to be liable
 *	for any results of using the software, alterations are clearly marked
 *	as such, and this notice is not modified.
+ *
+ * RCS: @(#) $Id: dlfcn.h,v 1.2 1998/09/14 18:39:44 stanton Exp $
 */

 /*
+ * @(#)dlfcn.h	1.4 revision of 95/04/25  09:36:52
 * This is an unpublished work copyright (c) 1992 HELIOS Software GmbH
 * 30159 Hannover, Germany
 */
@@ -26,6 +29,10 @@
 #ifndef __dlfcn_h__
 #define __dlfcn_h__

+#ifndef _TCL
+#include <tcl.h>
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -42,14 +49,14 @@ extern "C" {
 * that contains functions to be called to initialize and terminate.
 */
 struct dl_info {
-	void (*init) (void);
-	void (*fini) (void);
+	void (*init) _ANSI_ARGS_((void));
+	void (*fini) _ANSI_ARGS_((void));
 };

-void *dlopen (const char *path, int mode);
-void *dlsym (void *handle, const char *symbol);
-char *dlerror (void);
-int dlclose (void *handle);
+VOID *dlopen _ANSI_ARGS_((const char *path, int mode));
+VOID *dlsym _ANSI_ARGS_((void *handle, const char *symbol));
+char *dlerror _ANSI_ARGS_((void));
+int dlclose _ANSI_ARGS_((void *handle));

 #ifdef __cplusplus
 }
@@ -9,6 +9,8 @@
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: fixstrtod.c,v 1.2 1998/09/14 18:39:44 stanton Exp $
 */

 #include <stdio.h>
@@ -20,12 +22,12 @@
 * somes systems (e.g. SunOS 4.1.4) stdlib.h doesn't declare strtod.
 */

-extern double strtod(char *, char **);
+extern double strtod();

 double
-fixstrtod(
-    char *string,
-    char **endPtr)
+fixstrtod(string, endPtr)
+    char *string;
+    char **endPtr;
 {
    double d;
    d = strtod(string, endPtr);
@@ -11,4 +11,6 @@
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: float.h,v 1.2 1998/09/14 18:39:44 stanton Exp $
 */
@@ -8,20 +8,22 @@
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: gettod.c,v 1.2 1998/09/14 18:39:44 stanton Exp $
 */

+#include "tcl.h"
 #include "tclPort.h"
 #include <sys/timeb.h>

 #undef timezone

 int
-gettimeofday(
-    struct timeval *tp,
-    struct timezone *tz)
+gettimeofday(tp, tz)
+struct timeval *tp;
+struct timezone *tz;
 {
    struct timeb t;
-
    ftime(&t);
    tp->tv_sec = t.time;
    tp->tv_usec = t. millitm * 1000;
@@ -12,6 +12,8 @@
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: limits.h,v 1.2 1998/09/14 18:39:44 stanton Exp $
 */

 #define LONG_MIN		0x80000000
@@ -1,21 +1,26 @@
-/*
+/* 
 * memcmp.c --
 *
 *	Source code for the "memcmp" library routine.
 *
 * Copyright (c) 1998 Sun Microsystems, Inc.
 *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * SCCS: @(#) memcmp.c 1.2 98/01/19 10:48:58
 */

+#include "tcl.h"
 #include "tclPort.h"

 /*
- * Here is the prototype just in case it is not included in tclPort.h.
+ * Here is the prototype just in case it is not included
+ * in tclPort.h.
 */

-int		memcmp(CONST VOID *s1, CONST VOID *s2, size_t n);
+int		memcmp _ANSI_ARGS_((CONST VOID *s1,
+			    CONST VOID *s2, size_t n));

 /*
 *----------------------------------------------------------------------
@@ -25,10 +30,11 @@ int		memcmp(CONST VOID *s1, CONST VOID *s2, size_t n);
 *	Compares two bytes sequences.
 *
 * Results:
- *	Compares its arguments, looking at the first n bytes (each interpreted
- *	as an unsigned char), and returns an integer less than, equal to, or
- *	greater than 0, according as s1 is less than, equal to, or greater
- *	than s2 when taken to be unsigned 8 bit numbers.
+ *     compares  its  arguments, looking at the first n
+ *     bytes (each interpreted as an unsigned char), and  returns
+ *     an integer less than, equal to, or greater than 0, accord-
+ *     ing as s1 is less  than,  equal  to,  or
+ *     greater than s2 when taken to be unsigned 8 bit numbers.
 *
 * Side effects:
 *	None.
@@ -37,28 +43,19 @@ int		memcmp(CONST VOID *s1, CONST VOID *s2, size_t n);
 */

 int
-memcmp(
-    CONST VOID *s1,		/* First string. */
-    CONST VOID *s2,		/* Second string. */
-    size_t n)			/* Length to compare. */
+memcmp(s1, s2, n)
+    CONST VOID *s1;			/* First string. */
+    CONST VOID *s2;			/* Second string. */
+    size_t      n;                      /* Length to compare. */
 {
-    CONST unsigned char *ptr1 = (CONST unsigned char *) s1;
-    CONST unsigned char *ptr2 = (CONST unsigned char *) s2;
+    unsigned char u1, u2;

-    for ( ; n-- ; ptr1++, ptr2++) {
-	unsigned char u1 = *ptr1, u2 = *ptr2;
-
-	if (u1 != u2) {
+    for ( ; n-- ; s1++, s2++) {
+	u1 = * (unsigned char *) s1;
+	u2 = * (unsigned char *) s2;
+	if ( u1 != u2) {
 	    return (u1-u2);
 	}
    }
    return 0;
 }
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 4
- * fill-column: 78
- * End:
- */
@@ -1,12 +1,17 @@
 /* 
 * opendir.c --
 *
- *	This file provides dirent-style directory-reading procedures for V7
- *	Unix systems that don't have such procedures. The origin of this code
- *	is unclear, but it seems to have come originally from Larry Wall.
+ *	This file provides dirent-style directory-reading procedures
+ *	for V7 Unix systems that don't have such procedures.  The
+ *	origin of this code is unclear, but it seems to have come
+ *	originally from Larry Wall.
+ *
+ *
+ * RCS: @(#) $Id: opendir.c,v 1.2 1998/09/14 18:39:44 stanton Exp $
 */

 #include "tclInt.h"
+#include "tclPort.h"

 #undef DIRSIZ
 #define DIRSIZ(dp) \
@@ -15,28 +20,24 @@
 /*
 * open a directory.
 */
-
 DIR *
-opendir(
-    char *name)
+opendir(name)
+char *name;
 {
-    register DIR *dirp;
-    register int fd;
-    char *myname;
+	register DIR *dirp;
+	register int fd;
+	char *myname;

-    myname = ((*name == '\0') ? "." : name);
-    if ((fd = open(myname, 0, 0)) == -1) {
-	return NULL;
-    }
-    dirp = (DIR *) ckalloc(sizeof(DIR));
-    if (dirp == NULL) {
-	/* unreachable? */
-	close(fd);
-	return NULL;
-    }
-    dirp->dd_fd = fd;
-    dirp->dd_loc = 0;
-    return dirp;
+	myname = ((*name == '\0') ? "." : name);
+	if ((fd = open(myname, 0, 0)) == -1)
+		return NULL;
+	if ((dirp = (DIR *)ckalloc(sizeof(DIR))) == NULL) {
+		close (fd);
+		return NULL;
+	}
+	dirp->dd_fd = fd;
+	dirp->dd_loc = 0;
+	return dirp;
 }

 /*
@@ -46,65 +47,62 @@ opendir(
 #define	ODIRSIZ	14

 struct	olddirect {
-    ino_t od_ino;
-    char od_name[ODIRSIZ];
+	ino_t	od_ino;
+	char	od_name[ODIRSIZ];
 };
 #else	/* a Pyramid in the ATT universe */
 #define	ODIRSIZ	248

 struct	olddirect {
-    long od_ino;
-    short od_fill1, od_fill2;
-    char od_name[ODIRSIZ];
+	long	od_ino;
+	short	od_fill1, od_fill2;
+	char	od_name[ODIRSIZ];
 };
 #endif

 /*
 * get next entry in a directory.
 */
-
 struct dirent *
-readdir(
-    register DIR *dirp)
+readdir(dirp)
+register DIR *dirp;
 {
-    register struct olddirect *dp;
-    static struct dirent dir;
+	register struct olddirect *dp;
+	static struct dirent dir;

-    for (;;) {
-	if (dirp->dd_loc == 0) {
-	    dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ);
-	    if (dirp->dd_size <= 0) {
-		return NULL;
-	    }
+	for (;;) {
+		if (dirp->dd_loc == 0) {
+			dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf,
+			    DIRBLKSIZ);
+			if (dirp->dd_size <= 0)
+				return NULL;
+		}
+		if (dirp->dd_loc >= dirp->dd_size) {
+			dirp->dd_loc = 0;
+			continue;
+		}
+		dp = (struct olddirect *)(dirp->dd_buf + dirp->dd_loc);
+		dirp->dd_loc += sizeof(struct olddirect);
+		if (dp->od_ino == 0)
+			continue;
+		dir.d_ino = dp->od_ino;
+		strncpy(dir.d_name, dp->od_name, ODIRSIZ);
+		dir.d_name[ODIRSIZ] = '\0'; /* insure null termination */
+		dir.d_namlen = strlen(dir.d_name);
+		dir.d_reclen = DIRSIZ(&dir);
+		return (&dir);
 	}
-	if (dirp->dd_loc >= dirp->dd_size) {
-	    dirp->dd_loc = 0;
-	    continue;
-	}
-	dp = (struct olddirect *)(dirp->dd_buf + dirp->dd_loc);
-	dirp->dd_loc += sizeof(struct olddirect);
-	if (dp->od_ino == 0) {
-	    continue;
-	}
-	dir.d_ino = dp->od_ino;
-	strncpy(dir.d_name, dp->od_name, ODIRSIZ);
-	dir.d_name[ODIRSIZ] = '\0'; /* insure null termination */
-	dir.d_namlen = strlen(dir.d_name);
-	dir.d_reclen = DIRSIZ(&dir);
-	return &dir;
-    }
 }

 /*
 * close a directory.
 */
-
 void
-closedir(
-    register DIR *dirp)
+closedir(dirp)
+register DIR *dirp;
 {
-    close(dirp->dd_fd);
-    dirp->dd_fd = -1;
-    dirp->dd_loc = 0;
-    ckfree((char *) dirp);
+	close(dirp->dd_fd);
+	dirp->dd_fd = -1;
+	dirp->dd_loc = 0;
+	ckfree((char *) dirp);
 }
@@ -1,36 +1,45 @@
 /*
 * stdlib.h --
 *
- *	Declares facilities exported by the "stdlib" portion of the C library.
- *	This file isn't complete in the ANSI-C sense; it only declares things
- *	that are needed by Tcl. This file is needed even on many systems with
- *	their own stdlib.h (e.g. SunOS) because not all stdlib.h files declare
- *	all the procedures needed here (such as strtod).
+ *	Declares facilities exported by the "stdlib" portion of
+ *	the C library.  This file isn't complete in the ANSI-C
+ *	sense;  it only declares things that are needed by Tcl.
+ *	This file is needed even on many systems with their own
+ *	stdlib.h (e.g. SunOS) because not all stdlib.h files
+ *	declare all the procedures needed here (such as strtod).
 *
 * Copyright (c) 1991 The Regents of the University of California.
 * Copyright (c) 1994-1998 Sun Microsystems, Inc.
 *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: stdlib.h,v 1.3 1999/04/16 00:46:30 stanton Exp $
 */

 #ifndef _STDLIB
 #define _STDLIB

-extern void		abort(void);
-extern double		atof(const char *string);
-extern int		atoi(const char *string);
-extern long		atol(const char *string);
-extern char *		calloc(unsigned int numElements, unsigned int size);
-extern void		exit(int status);
-extern int		free(char *blockPtr);
-extern char *		getenv(const char *name);
-extern char *		malloc(unsigned int numBytes);
-extern void		qsort(void *base, int n, int size, int (*compar)(
-			    const void *element1, const void *element2));
-extern char *		realloc(char *ptr, unsigned int numBytes);
-extern double		strtod(const char *string, char **endPtr);
-extern long		strtol(const char *string, char **endPtr, int base);
-extern unsigned long	strtoul(const char *string, char **endPtr, int base);
+#include <tcl.h>
+
+extern void		abort _ANSI_ARGS_((void));
+extern double		atof _ANSI_ARGS_((CONST char *string));
+extern int		atoi _ANSI_ARGS_((CONST char *string));
+extern long		atol _ANSI_ARGS_((CONST char *string));
+extern char *		calloc _ANSI_ARGS_((unsigned int numElements,
+			    unsigned int size));
+extern void		exit _ANSI_ARGS_((int status));
+extern int		free _ANSI_ARGS_((char *blockPtr));
+extern char *		getenv _ANSI_ARGS_((CONST char *name));
+extern char *		malloc _ANSI_ARGS_((unsigned int numBytes));
+extern void		qsort _ANSI_ARGS_((VOID *base, int n, int size,
+			    int (*compar)(CONST VOID *element1, CONST VOID
+			    *element2)));
+extern char *		realloc _ANSI_ARGS_((char *ptr, unsigned int numBytes));
+extern double		strtod _ANSI_ARGS_((CONST char *string, char **endPtr));
+extern long		strtol _ANSI_ARGS_((CONST char *string, char **endPtr,
+			    int base));
+extern unsigned long	strtoul _ANSI_ARGS_((CONST char *string,
+			    char **endPtr, int base));

 #endif /* _STDLIB */
@@ -0,0 +1,393 @@
+/* 
+ * strftime.c --
+ *
+ *	This file contains a modified version of the BSD 4.4 strftime
+ *	function.
+ *
+ * This file is a modified version of the strftime.c file from the BSD 4.4
+ * source.  See the copyright notice below for details on redistribution
+ * restrictions.  The "license.terms" file does not apply to this file.
+ *
+ * RCS: @(#) $Id: strftime.c,v 1.8 2001/11/23 01:26:30 das Exp $
+ */
+
+/*
+ * Copyright (c) 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS)
+static char *rcsid = "$Id: strftime.c,v 1.8 2001/11/23 01:26:30 das Exp $";
+#endif /* LIBC_SCCS */
+
+#include <time.h>
+#include <string.h>
+#include <locale.h>
+#include "tclInt.h"
+#include "tclPort.h"
+
+#define TM_YEAR_BASE   1900
+#define IsLeapYear(x)   ((x % 4 == 0) && (x % 100 != 0 || x % 400 == 0))
+
+typedef struct {
+    const char *abday[7];
+    const char *day[7];
+    const char *abmon[12];
+    const char *mon[12];
+    const char *am_pm[2];
+    const char *d_t_fmt;
+    const char *d_fmt;
+    const char *t_fmt;
+    const char *t_fmt_ampm;
+} _TimeLocale;
+ 
+static const _TimeLocale _DefaultTimeLocale = 
+{
+    {
+	"Sun","Mon","Tue","Wed","Thu","Fri","Sat",
+    },
+    {
+	"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
+	"Friday", "Saturday"
+    },
+    {
+	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+    },
+    {
+	"January", "February", "March", "April", "May", "June", "July",
+	"August", "September", "October", "November", "December"
+    },
+    {
+	"AM", "PM"
+    },
+    "%a %b %d %H:%M:%S %Y",
+    "%m/%d/%y",
+    "%H:%M:%S",
+    "%I:%M:%S %p"
+};
+
+static const _TimeLocale *_CurrentTimeLocale = &_DefaultTimeLocale;
+
+static size_t gsize;
+static char *pt;
+static int		 _add _ANSI_ARGS_((const char* str));
+static int		_conv _ANSI_ARGS_((int n, int digits, int pad));
+static int		_secs _ANSI_ARGS_((const struct tm *t));
+static size_t		_fmt _ANSI_ARGS_((const char *format,
+			    const struct tm *t));
+
+size_t
+TclpStrftime(s, maxsize, format, t)
+    char *s;
+    size_t maxsize;
+    const char *format;
+    const struct tm *t;
+{
+    if (format[0] == '%' && format[1] == 'Q') {
+	/* Format as a stardate */
+	sprintf(s, "Stardate %2d%03d.%01d",
+		(((t->tm_year + TM_YEAR_BASE) + 377) - 2323),
+		(((t->tm_yday + 1) * 1000) /
+			(365 + IsLeapYear((t->tm_year + TM_YEAR_BASE)))),
+		(((t->tm_hour * 60) + t->tm_min)/144));
+	return(strlen(s));
+    }
+
+    tzset();
+
+    pt = s;
+    if ((gsize = maxsize) < 1)
+	return(0);
+    if (_fmt(format, t)) {
+	*pt = '\0';
+	return(maxsize - gsize);
+    }
+    return(0);
+}
+
+#define SUN_WEEK(t)	(((t)->tm_yday + 7 - \
+				((t)->tm_wday)) / 7)
+#define MON_WEEK(t)	(((t)->tm_yday + 7 - \
+				((t)->tm_wday ? (t)->tm_wday - 1 : 6)) / 7)
+
+static size_t
+_fmt(format, t)
+    const char *format;
+    const struct tm *t;
+{
+    for (; *format; ++format) {
+	if (*format == '%') {
+	    ++format;
+	    if (*format == 'E') {
+				/* Alternate Era */
+		++format;
+	    } else if (*format == 'O') {
+				/* Alternate numeric symbols */
+		++format;
+	    }
+	    switch(*format) {
+		case '\0':
+		    --format;
+		    break;
+		case 'A':
+		    if (t->tm_wday < 0 || t->tm_wday > 6)
+			return(0);
+		    if (!_add(_CurrentTimeLocale->day[t->tm_wday]))
+			return(0);
+		    continue;
+		case 'a':
+		    if (t->tm_wday < 0 || t->tm_wday > 6)
+			return(0);
+		    if (!_add(_CurrentTimeLocale->abday[t->tm_wday]))
+			return(0);
+		    continue;
+		case 'B':
+		    if (t->tm_mon < 0 || t->tm_mon > 11)
+			return(0);
+		    if (!_add(_CurrentTimeLocale->mon[t->tm_mon]))
+			return(0);
+		    continue;
+		case 'b':
+		case 'h':
+		    if (t->tm_mon < 0 || t->tm_mon > 11)
+			return(0);
+		    if (!_add(_CurrentTimeLocale->abmon[t->tm_mon]))
+			return(0);
+		    continue;
+		case 'C':
+		    if (!_conv((t->tm_year + TM_YEAR_BASE) / 100,
+			    2, '0'))
+			return(0);
+		    continue;
+		case 'c':
+		    if (!_fmt(_CurrentTimeLocale->d_t_fmt, t))
+			return(0);
+		    continue;
+		case 'D':
+		    if (!_fmt("%m/%d/%y", t))
+			return(0);
+		    continue;
+		case 'd':
+		    if (!_conv(t->tm_mday, 2, '0'))
+			return(0);
+		    continue;
+		case 'e':
+		    if (!_conv(t->tm_mday, 2, ' '))
+			return(0);
+		    continue;
+		case 'H':
+		    if (!_conv(t->tm_hour, 2, '0'))
+			return(0);
+		    continue;
+		case 'I':
+		    if (!_conv(t->tm_hour % 12 ?
+			    t->tm_hour % 12 : 12, 2, '0'))
+			return(0);
+		    continue;
+		case 'j':
+		    if (!_conv(t->tm_yday + 1, 3, '0'))
+			return(0);
+		    continue;
+		case 'k':
+		    if (!_conv(t->tm_hour, 2, ' '))
+			return(0);
+		    continue;
+		case 'l':
+		    if (!_conv(t->tm_hour % 12 ?
+			    t->tm_hour % 12: 12, 2, ' '))
+			return(0);
+		    continue;
+		case 'M':
+		    if (!_conv(t->tm_min, 2, '0'))
+			return(0);
+		    continue;
+		case 'm':
+		    if (!_conv(t->tm_mon + 1, 2, '0'))
+			return(0);
+		    continue;
+		case 'n':
+		    if (!_add("\n"))
+			return(0);
+		    continue;
+		case 'p':
+		    if (!_add(_CurrentTimeLocale->am_pm[t->tm_hour >= 12]))
+			return(0);
+		    continue;
+		case 'R':
+		    if (!_fmt("%H:%M", t))
+			return(0);
+		    continue;
+		case 'r':
+		    if (!_fmt(_CurrentTimeLocale->t_fmt_ampm, t))
+			return(0);
+		    continue;
+		case 'S':
+		    if (!_conv(t->tm_sec, 2, '0'))
+			return(0);
+		    continue;
+		case 's':
+		    if (!_secs(t))
+			return(0);
+		    continue;
+		case 'T':
+		    if (!_fmt("%H:%M:%S", t))
+			return(0);
+		    continue;
+		case 't':
+		    if (!_add("\t"))
+			return(0);
+		    continue;
+		case 'U':
+		    if (!_conv(SUN_WEEK(t), 2, '0'))
+			return(0);
+		    continue;
+		case 'u':
+		    if (!_conv(t->tm_wday ? t->tm_wday : 7, 1, '0'))
+			return(0);
+		    continue;
+		case 'V':
+		{
+				/* ISO 8601 Week Of Year:
+				   If the week (Monday - Sunday) containing
+				   January 1 has four or more days in the new 
+				   year, then it is week 1; otherwise it is 
+				   week 53 of the previous year and the next
+				   week is week one. */
+				 
+		    int week = MON_WEEK(t);
+
+		    int days = (((t)->tm_yday + 7 - \
+			    ((t)->tm_wday ? (t)->tm_wday - 1 : 6)) % 7);
+
+
+		    if (days >= 4) {
+			week++;
+		    } else if (week == 0) {
+			week = 53;
+		    }
+
+		    if (!_conv(week, 2, '0'))
+			return(0);
+		    continue;
+		}
+		case 'W':
+		    if (!_conv(MON_WEEK(t), 2, '0'))
+			return(0);
+		    continue;
+		case 'w':
+		    if (!_conv(t->tm_wday, 1, '0'))
+			return(0);
+		    continue;
+		case 'x':
+		    if (!_fmt(_CurrentTimeLocale->d_fmt, t))
+			return(0);
+		    continue;
+		case 'X':
+		    if (!_fmt(_CurrentTimeLocale->t_fmt, t))
+			return(0);
+		    continue;
+		case 'y':
+		    if (!_conv((t->tm_year + TM_YEAR_BASE) % 100,
+			    2, '0'))
+			return(0);
+		    continue;
+		case 'Y':
+		    if (!_conv((t->tm_year + TM_YEAR_BASE), 4, '0'))
+			return(0);
+		    continue;
+		case 'Z': {
+		    char *name = TclpGetTZName(t->tm_isdst);
+		    if (name && !_add(name)) {
+			return 0;
+		    }
+		    continue;
+		}
+		case '%':
+		    /*
+		     * X311J/88-090 (4.12.3.5): if conversion char is
+		     * undefined, behavior is undefined.  Print out the
+		     * character itself as printf(3) does.
+		     */
+		default:
+		    break;
+	    }
+	}
+	if (!gsize--)
+	    return(0);
+	*pt++ = *format;
+    }
+    return(gsize);
+}
+
+static int
+_secs(t)
+    const struct tm *t;
+{
+    static char buf[15];
+    register time_t s;
+    register char *p;
+    struct tm tmp;
+
+    /* Make a copy, mktime(3) modifies the tm struct. */
+    tmp = *t;
+    s = mktime(&tmp);
+    for (p = buf + sizeof(buf) - 2; s > 0 && p > buf; s /= 10)
+	*p-- = (char)(s % 10 + '0');
+    return(_add(++p));
+}
+
+static int
+_conv(n, digits, pad)
+    int n, digits;
+    int pad;
+{
+    static char buf[10];
+    register char *p;
+
+    for (p = buf + sizeof(buf) - 2; n > 0 && p > buf; n /= 10, --digits)
+	*p-- = (char)(n % 10 + '0');
+    while (p > buf && digits-- > 0)
+	*p-- = (char) pad;
+    return(_add(++p));
+}
+
+static int
+_add(str)
+    const char *str;
+{
+    for (;; ++pt, --gsize) {
+	if (!gsize)
+	    return(0);
+	if (!(*pt = *str++))
+	    return(1);
+    }
+}
@@ -6,52 +6,66 @@
 * Copyright (c) 1991-1993 The Regents of the University of California.
 * Copyright (c) 1994-1996 Sun Microsystems, Inc.
 *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: string.h,v 1.4 2000/07/18 18:16:17 ericm Exp $
 */

 #ifndef _STRING
 #define _STRING

+#include <tcl.h>
+
 /*
- * The following #include is needed to define size_t. (This used to include
- * sys/stdtypes.h but that doesn't exist on older versions of SunOS, e.g.
- * 4.0.2, so I'm trying sys/types.h now.... hopefully it exists everywhere)
+ * The following #include is needed to define size_t. (This used to
+ * include sys/stdtypes.h but that doesn't exist on older versions
+ * of SunOS, e.g. 4.0.2, so I'm trying sys/types.h now.... hopefully
+ * it exists everywhere)
 */

+#ifndef MAC_TCL
 #include <sys/types.h>
-
-#ifdef __APPLE__
-extern void *		memchr(const void *s, int c, size_t n);
-#else
-extern char *		memchr(const void *s, int c, size_t n);
 #endif
-extern int		memcmp(const void *s1, const void *s2, size_t n);
-extern char *		memcpy(void *t, const void *f, size_t n);
+
+extern char *		memchr _ANSI_ARGS_((CONST VOID *s, int c, size_t n));
+extern int		memcmp _ANSI_ARGS_((CONST VOID *s1, CONST VOID *s2,
+			    size_t n));
+extern char *		memcpy _ANSI_ARGS_((VOID *t, CONST VOID *f, size_t n));
 #ifdef NO_MEMMOVE
-#define memmove(d,s,n)	(bcopy((s), (d), (n)))
+#define memmove(d, s, n) bcopy ((s), (d), (n))
 #else
-extern char *		memmove(void *t, const void *f, size_t n);
+extern char *		memmove _ANSI_ARGS_((VOID *t, CONST VOID *f,
+			    size_t n));
 #endif
-extern char *		memset(void *s, int c, size_t n);
+extern char *		memset _ANSI_ARGS_((VOID *s, int c, size_t n));

-extern int		strcasecmp(const char *s1, const char *s2);
-extern char *		strcat(char *dst, const char *src);
-extern char *		strchr(const char *string, int c);
-extern int		strcmp(const char *s1, const char *s2);
-extern char *		strcpy(char *dst, const char *src);
-extern size_t		strcspn(const char *string, const char *chars);
-extern char *		strdup(const char *string);
-extern char *		strerror(int error);
-extern size_t		strlen(const char *string);
-extern int		strncasecmp(const char *s1, const char *s2, size_t n);
-extern char *		strncat(char *dst, const char *src, size_t numChars);
-extern int		strncmp(const char *s1, const char *s2, size_t nChars);
-extern char *		strncpy(char *dst, const char *src, size_t numChars);
-extern char *		strpbrk(const char *string, const char *chars);
-extern char *		strrchr(const char *string, int c);
-extern size_t		strspn(const char *string, const char *chars);
-extern char *		strstr(const char *string, const char *substring);
-extern char *		strtok(char *s, const char *delim);
+extern int		strcasecmp _ANSI_ARGS_((CONST char *s1,
+			    CONST char *s2));
+extern char *		strcat _ANSI_ARGS_((char *dst, CONST char *src));
+extern char *		strchr _ANSI_ARGS_((CONST char *string, int c));
+extern int		strcmp _ANSI_ARGS_((CONST char *s1, CONST char *s2));
+extern char *		strcpy _ANSI_ARGS_((char *dst, CONST char *src));
+extern size_t		strcspn _ANSI_ARGS_((CONST char *string,
+			    CONST char *chars));
+extern char *		strdup _ANSI_ARGS_((CONST char *string));
+extern char *		strerror _ANSI_ARGS_((int error));
+extern size_t		strlen _ANSI_ARGS_((CONST char *string));
+extern int		strncasecmp _ANSI_ARGS_((CONST char *s1,
+			    CONST char *s2, size_t n));
+extern char *		strncat _ANSI_ARGS_((char *dst, CONST char *src,
+			    size_t numChars));
+extern int		strncmp _ANSI_ARGS_((CONST char *s1, CONST char *s2,
+			    size_t nChars));
+extern char *		strncpy _ANSI_ARGS_((char *dst, CONST char *src,
+			    size_t numChars));
+extern char *		strpbrk _ANSI_ARGS_((CONST char *string,
+			    CONST char *chars));
+extern char *		strrchr _ANSI_ARGS_((CONST char *string, int c));
+extern size_t		strspn _ANSI_ARGS_((CONST char *string,
+			    CONST char *chars));
+extern char *		strstr _ANSI_ARGS_((CONST char *string,
+			    CONST char *substring));
+extern char *		strtok _ANSI_ARGS_((char *s, CONST char *delim));

 #endif /* _STRING */
@@ -6,16 +6,18 @@
 * Copyright (c) 1988-1993 The Regents of the University of California.
 * Copyright (c) 1995-1996 Sun Microsystems, Inc.
 *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: strncasecmp.c,v 1.2 1998/09/14 18:39:45 stanton Exp $
 */

 #include "tclPort.h"

 /*
- * This array is designed for mapping upper and lower case letter together for
- * a case independent comparison. The mappings are based upon ASCII character
- * sequences.
+ * This array is designed for mapping upper and lower case letter
+ * together for a case independent comparison.  The mappings are
+ * based upon ASCII character sequences.
 */

 static unsigned char charmap[] = {
@@ -54,11 +56,14 @@ static unsigned char charmap[] = {
 };

 /*
- * Here are the prototypes just in case they are not included in tclPort.h.
+ * Here are the prototypes just in case they are not included
+ * in tclPort.h.
 */
+int		strncasecmp _ANSI_ARGS_((CONST char *s1,
+			    CONST char *s2, size_t n));

-int		strncasecmp(CONST char *s1, CONST char *s2, size_t n);
-int		strcasecmp(CONST char *s1, CONST char *s2);
+int		strcasecmp _ANSI_ARGS_((CONST char *s1,
+			    CONST char *s2));

 /*
 *----------------------------------------------------------------------
@@ -68,8 +73,9 @@ int		strcasecmp(CONST char *s1, CONST char *s2);
 *	Compares two strings, ignoring case differences.
 *
 * Results:
- *	Compares two null-terminated strings s1 and s2, returning -1, 0, or 1
- *	if s1 is lexicographically less than, equal to, or greater than s2.
+ *	Compares two null-terminated strings s1 and s2, returning -1, 0,
+ *	or 1 if s1 is lexicographically less than, equal to, or greater
+ *	than s2.
 *
 * Side effects:
 *	None.
@@ -78,9 +84,9 @@ int		strcasecmp(CONST char *s1, CONST char *s2);
 */

 int
-strcasecmp(
-    CONST char *s1,		/* First string. */
-    CONST char *s2)		/* Second string. */
+strcasecmp(s1, s2)
+    CONST char *s1;			/* First string. */
+    CONST char *s2;			/* Second string. */
 {
    unsigned char u1, u2;

@@ -102,9 +108,9 @@ strcasecmp(
 *	Compares two strings, ignoring case differences.
 *
 * Results:
- *	Compares up to length chars of s1 and s2, returning -1, 0, or 1 if s1
- *	is lexicographically less than, equal to, or greater than s2 over
- *	those characters.
+ *	Compares up to length chars of s1 and s2, returning -1, 0, or 1
+ *	if s1 is lexicographically less than, equal to, or greater
+ *	than s2 over those characters.
 *
 * Side effects:
 *	None.
@@ -113,10 +119,10 @@ strcasecmp(
 */

 int
-strncasecmp(
-    CONST char *s1,		/* First string. */
-    CONST char *s2,		/* Second string. */
-    size_t length)		/* Maximum number of characters to compare
+strncasecmp(s1, s2, length)
+    CONST char *s1;		/* First string. */
+    CONST char *s2;		/* Second string. */
+    size_t length;		/* Maximum number of characters to compare
 				 * (stop earlier if the end of either string
 				 * is reached). */
 {
@@ -6,15 +6,12 @@
 * Copyright (c) 1988-1993 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
 *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: strstr.c,v 1.2 1998/09/14 18:39:45 stanton Exp $
 */

-#include "tcl.h"
-#ifndef NULL
-#define NULL 0
-#endif
-
 /*
 *----------------------------------------------------------------------
 *
@@ -23,10 +20,12 @@
 *	Locate the first instance of a substring in a string.
 *
 * Results:
- *	If string contains substring, the return value is the location of the
- *	first matching instance of substring in string. If string doesn't
- *	contain substring, the return value is 0. Matching is done on an exact
- *	character-for-character basis with no wildcards or special characters.
+ *	If string contains substring, the return value is the
+ *	location of the first matching instance of substring
+ *	in string.  If string doesn't contain substring, the
+ *	return value is 0.  Matching is done on an exact
+ *	character-for-character basis with no wildcards or special
+ *	characters.
 *
 * Side effects:
 *	None.
@@ -35,16 +34,15 @@
 */

 char *
-strstr(
-    register char *string,	/* String to search. */
-    char *substring)		/* Substring to try to find in string. */
+strstr(string, substring)
+    register char *string;	/* String to search. */
+    char *substring;		/* Substring to try to find in string. */
 {
    register char *a, *b;

-    /*
-     * First scan quickly through the two strings looking for a
-     * single-character match. When it's found, then compare the rest of the
-     * substring.
+    /* First scan quickly through the two strings looking for a
+     * single-character match.  When it's found, then compare the
+     * rest of the substring.
     */

    b = substring;
@@ -66,5 +64,5 @@ strstr(
 	}
 	b = substring;
    }
-    return NULL;
+    return (char *) 0;
 }
@@ -8,10 +8,19 @@
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: strtod.c,v 1.4 2001/11/23 01:26:34 das Exp $
 */

-#include "tclInt.h"
+#include "tcl.h"
+#include "tclPort.h"
+#ifdef NO_STDLIB_H
+#   include "../compat/stdlib.h"
+#else
+#   include <stdlib.h>
+#endif
 #include <ctype.h>
+#include "tclPort.h"

 #ifndef TRUE
 #define TRUE 1
@@ -60,19 +69,20 @@ static double powersOf10[] = {	/* Table giving binary powers of 10.  Entry */
 */

 double
-strtod(
-    CONST char *string,		/* A decimal ASCII floating-point number,
-				 * optionally preceded by white space. Must
-				 * have form "-I.FE-X", where I is the integer
-				 * part of the mantissa, F is the fractional
-				 * part of the mantissa, and X is the
-				 * exponent. Either of the signs may be "+",
-				 * "-", or omitted. Either I or F may be
-				 * omitted, or both. The decimal point isn't
-				 * necessary unless F is present. The "E" may
-				 * actually be an "e". E and X may both be
-				 * omitted (but not just one). */
-    char **endPtr)		/* If non-NULL, store terminating character's
+strtod(string, endPtr)
+    CONST char *string;		/* A decimal ASCII floating-point number,
+				 * optionally preceded by white space.
+				 * Must have form "-I.FE-X", where I is the
+				 * integer part of the mantissa, F is the
+				 * fractional part of the mantissa, and X
+				 * is the exponent.  Either of the signs
+				 * may be "+", "-", or omitted.  Either I
+				 * or F may be omitted, or both.  The decimal
+				 * point isn't necessary unless F is present.
+				 * The "E" may actually be an "e".  E and X
+				 * may both be omitted (but not just one).
+				 */
+    char **endPtr;		/* If non-NULL, store terminating character's
 				 * address here. */
 {
    int sign, expSign = FALSE;
@@ -81,26 +91,26 @@ strtod(
    register int c;
    int exp = 0;		/* Exponent read from "EX" field. */
    int fracExp = 0;		/* Exponent that derives from the fractional
-				 * part. Under normal circumstatnces, it is
+				 * part.  Under normal circumstatnces, it is
 				 * the negative of the number of digits in F.
 				 * However, if I is very long, the last digits
 				 * of I get dropped (otherwise a long I with a
 				 * large negative exponent could cause an
-				 * unnecessary overflow on I alone). In this
+				 * unnecessary overflow on I alone).  In this
 				 * case, fracExp is incremented one for each
 				 * dropped digit. */
    int mantSize;		/* Number of digits in mantissa. */
    int decPt;			/* Number of mantissa digits BEFORE decimal
 				 * point. */
-    CONST char *pExp;		/* Temporarily holds location of exponent in
-				 * string. */
+    CONST char *pExp;		/* Temporarily holds location of exponent
+				 * in string. */

    /*
     * Strip off leading blanks and check for a sign.
     */

    p = string;
-    while (isspace(UCHAR(*p))) {
+    while (isspace(*p)) {
 	p += 1;
    }
    if (*p == '-') {
@@ -132,10 +142,10 @@ strtod(
    }

    /*
-     * Now suck up the digits in the mantissa. Use two integers to collect 9
-     * digits each (this is faster than using floating-point). If the mantissa
-     * has more than 18 digits, ignore the extras, since they can't affect the
-     * value anyway.
+     * Now suck up the digits in the mantissa.  Use two integers to
+     * collect 9 digits each (this is faster than using floating-point).
+     * If the mantissa has more than 18 digits, ignore the extras, since
+     * they can't affect the value anyway.
     */
    
    pExp  = p;
@@ -143,7 +153,7 @@ strtod(
    if (decPt < 0) {
 	decPt = mantSize;
    } else {
-	mantSize -= 1;		/* One of the digits was the point. */
+	mantSize -= 1;			/* One of the digits was the point. */
    }
    if (mantSize > 18) {
 	fracExp = decPt - 18;
@@ -157,9 +167,9 @@ strtod(
 	goto done;
    } else {
 	int frac1, frac2;
-
 	frac1 = 0;
-	for ( ; mantSize > 9; mantSize -= 1) {
+	for ( ; mantSize > 9; mantSize -= 1)
+	{
 	    c = *p;
 	    p += 1;
 	    if (c == '.') {
@@ -169,7 +179,8 @@ strtod(
 	    frac1 = 10*frac1 + (c - '0');
 	}
 	frac2 = 0;
-	for (; mantSize > 0; mantSize -= 1) {
+	for (; mantSize > 0; mantSize -= 1)
+	{
 	    c = *p;
 	    p += 1;
 	    if (c == '.') {
@@ -197,11 +208,11 @@ strtod(
 	    }
 	    expSign = FALSE;
 	}
-	if (!isdigit(UCHAR(*p))) {
+	if (!isdigit(*p)) {
 	    p = pExp;
 	    goto done;
 	}
-	while (isdigit(UCHAR(*p))) {
+	while (isdigit(*p)) {
 	    exp = exp * 10 + (*p - '0');
 	    p += 1;
 	}
@@ -213,9 +224,10 @@ strtod(
    }

    /*
-     * Generate a floating-point number that represents the exponent. Do this
-     * by processing the exponent one bit at a time to combine many powers of
-     * 2 of 10. Then combine the exponent with the fraction.
+     * Generate a floating-point number that represents the exponent.
+     * Do this by processing the exponent one bit at a time to combine
+     * many powers of 2 of 10. Then combine the exponent with the
+     * fraction.
     */
    
    if (exp < 0) {
@@ -240,7 +252,7 @@ strtod(
 	fraction *= dblExp;
    }

-  done:
+done:
    if (endPtr != NULL) {
 	*endPtr = (char *) p;
    }
@@ -6,12 +6,14 @@
 * Copyright (c) 1988 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
 *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: strtol.c,v 1.2 1998/09/14 18:39:45 stanton Exp $
 */

 #include <ctype.h>
-#include "tclInt.h"
+

 /*
 *----------------------------------------------------------------------
@@ -21,10 +23,11 @@
 *	Convert an ASCII string into an integer.
 *
 * Results:
- *	The return value is the integer equivalent of string. If endPtr is
- *	non-NULL, then *endPtr is filled in with the character after the last
- *	one that was part of the integer. If string doesn't contain a valid
- *	integer value, then zero is returned and *endPtr is set to string.
+ *	The return value is the integer equivalent of string.  If endPtr
+ *	is non-NULL, then *endPtr is filled in with the character
+ *	after the last one that was part of the integer.  If string
+ *	doesn't contain a valid integer value, then zero is returned
+ *	and *endPtr is set to string.
 *
 * Side effects:
 *	None.
@@ -33,28 +36,30 @@
 */

 long int
-strtol(
-    CONST char *string,		/* String of ASCII digits, possibly preceded
-				 * by white space. For bases greater than 10,
-				 * either lower- or upper-case digits may be
-				 * used. */
-    char **endPtr,		/* Where to store address of terminating
+strtol(string, endPtr, base)
+    char *string;		/* String of ASCII digits, possibly
+				 * preceded by white space.  For bases
+				 * greater than 10, either lower- or
+				 * upper-case digits may be used.
+				 */
+    char **endPtr;		/* Where to store address of terminating
 				 * character, or NULL. */
-    int base)			/* Base for conversion. Must be less than 37.
-				 * If 0, then the base is chosen from the
-				 * leading characters of string: "0x" means
-				 * hex, "0" means octal, anything else means
-				 * decimal. */
+    int base;			/* Base for conversion.  Must be less
+				 * than 37.  If 0, then the base is chosen
+				 * from the leading characters of string:
+				 * "0x" means hex, "0" means octal, anything
+				 * else means decimal.
+				 */
 {
-    register CONST char *p;
-    long result;
+    register char *p;
+    int result;

    /*
     * Skip any leading blanks.
     */

    p = string;
-    while (isspace(UCHAR(*p))) {
+    while (isspace(*p)) {
 	p += 1;
    }

@@ -72,7 +77,7 @@ strtol(
 	result = strtoul(p, endPtr, base);
    }
    if ((result == 0) && (endPtr != 0) && (*endPtr == p)) {
-	*endPtr = (char *) string;
+	*endPtr = string;
    }
    return result;
 }
@@ -6,16 +6,18 @@
 * Copyright (c) 1988 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
 *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: strtoul.c,v 1.2 1998/09/14 18:39:45 stanton Exp $
 */

-#include "tclInt.h"
+#include <ctype.h>

 /*
- * The table below is used to convert from ASCII digits to a numerical
- * equivalent. It maps from '0' through 'z' to integers (100 for non-digit
- * characters).
+ * The table below is used to convert from ASCII digits to a
+ * numerical equivalent.  It maps from '0' through 'z' to integers
+ * (100 for non-digit characters).
 */

 static char cvtIn[] = {
@@ -37,10 +39,11 @@ static char cvtIn[] = {
 *	Convert an ASCII string into an integer.
 *
 * Results:
- *	The return value is the integer equivalent of string. If endPtr is
- *	non-NULL, then *endPtr is filled in with the character after the last
- *	one that was part of the integer. If string doesn't contain a valid
- *	integer value, then zero is returned and *endPtr is set to string.
+ *	The return value is the integer equivalent of string.  If endPtr
+ *	is non-NULL, then *endPtr is filled in with the character
+ *	after the last one that was part of the integer.  If string
+ *	doesn't contain a valid integer value, then zero is returned
+ *	and *endPtr is set to string.
 *
 * Side effects:
 *	None.
@@ -49,112 +52,94 @@ static char cvtIn[] = {
 */

 unsigned long int
-strtoul(
-    CONST char *string,		/* String of ASCII digits, possibly preceded
-				 * by white space. For bases greater than 10,
-				 * either lower- or upper-case digits may be
-				 * used. */
-    char **endPtr,		/* Where to store address of terminating
+strtoul(string, endPtr, base)
+    char *string;		/* String of ASCII digits, possibly
+				 * preceded by white space.  For bases
+				 * greater than 10, either lower- or
+				 * upper-case digits may be used.
+				 */
+    char **endPtr;		/* Where to store address of terminating
 				 * character, or NULL. */
-    int base)			/* Base for conversion.  Must be less than 37.
-				 * If 0, then the base is chosen from the
-				 * leading characters of string: "0x" means
-				 * hex, "0" means octal, anything else means
-				 * decimal. */
+    int base;			/* Base for conversion.  Must be less
+				 * than 37.  If 0, then the base is chosen
+				 * from the leading characters of string:
+				 * "0x" means hex, "0" means octal, anything
+				 * else means decimal.
+				 */
 {
-    register CONST char *p;
+    register char *p;
    register unsigned long int result = 0;
    register unsigned digit;
    int anyDigits = 0;
-    int negative=0;
-    int overflow=0;

    /*
     * Skip any leading blanks.
     */

    p = string;
-    while (isspace(UCHAR(*p))) {
+    while (isspace(*p)) {
 	p += 1;
    }
-    if (*p == '-') {
-        negative = 1;
-        p += 1;
-    } else {
-        if (*p == '+') {
-            p += 1;
-        }
-    }

    /*
-     * If no base was provided, pick one from the leading characters of the
-     * string.
+     * If no base was provided, pick one from the leading characters
+     * of the string.
     */
    
-    if (base == 0) {
+    if (base == 0)
+    {
 	if (*p == '0') {
 	    p += 1;
-	    if ((*p == 'x') || (*p == 'X')) {
+	    if (*p == 'x') {
 		p += 1;
 		base = 16;
 	    } else {
+
 		/*
-		 * Must set anyDigits here, otherwise "0" produces a "no
-		 * digits" error.
+		 * Must set anyDigits here, otherwise "0" produces a
+		 * "no digits" error.
 		 */

 		anyDigits = 1;
 		base = 8;
 	    }
-	} else {
-	    base = 10;
 	}
+	else base = 10;
    } else if (base == 16) {
+
 	/*
 	 * Skip a leading "0x" from hex numbers.
 	 */

-	if ((p[0] == '0') && ((p[1] == 'x') || (p[1] == 'X'))) {
+	if ((p[0] == '0') && (p[1] == 'x')) {
 	    p += 2;
 	}
    }

    /*
-     * Sorry this code is so messy, but speed seems important. Do different
-     * things for base 8, 10, 16, and other.
+     * Sorry this code is so messy, but speed seems important.  Do
+     * different things for base 8, 10, 16, and other.
     */

    if (base == 8) {
-	unsigned long maxres = ULONG_MAX >> 3;
-
 	for ( ; ; p += 1) {
 	    digit = *p - '0';
 	    if (digit > 7) {
 		break;
 	    }
-	    if (result > maxres) { overflow = 1; }
-	    result = (result << 3);
-	    if (digit > (ULONG_MAX - result)) { overflow = 1; }
-	    result += digit;
+	    result = (result << 3) + digit;
 	    anyDigits = 1;
 	}
    } else if (base == 10) {
-	unsigned long maxres = ULONG_MAX / 10;
-
 	for ( ; ; p += 1) {
 	    digit = *p - '0';
 	    if (digit > 9) {
 		break;
 	    }
-	    if (result > maxres) { overflow = 1; }
-	    result *= 10;
-	    if (digit > (ULONG_MAX - result)) { overflow = 1; }
-	    result += digit;
+	    result = (10*result) + digit;
 	    anyDigits = 1;
 	}
    } else if (base == 16) {
-	unsigned long maxres = ULONG_MAX >> 4;
-
 	for ( ; ; p += 1) {
 	    digit = *p - '0';
 	    if (digit > ('z' - '0')) {
@@ -164,28 +149,20 @@ strtoul(
 	    if (digit > 15) {
 		break;
 	    }
-	    if (result > maxres) { overflow = 1; }
-	    result = (result << 4);
-	    if (digit > (ULONG_MAX - result)) { overflow = 1; }
-	    result += digit;
+	    result = (result << 4) + digit;
 	    anyDigits = 1;
 	}
-    } else if (base >= 2 && base <= 36) {
-	unsigned long maxres = ULONG_MAX / base;
-
+    } else {
 	for ( ; ; p += 1) {
 	    digit = *p - '0';
 	    if (digit > ('z' - '0')) {
 		break;
 	    }
 	    digit = cvtIn[digit];
-	    if (digit >= ( (unsigned) base )) {
+	    if (digit >= base) {
 		break;
 	    }
-	    if (result > maxres) { overflow = 1; }
-	    result *= base;
-	    if (digit > (ULONG_MAX - result)) { overflow = 1; }
-	    result += digit;
+	    result = result*base + digit;
 	    anyDigits = 1;
 	}
    }
@@ -199,16 +176,8 @@ strtoul(
    }

    if (endPtr != 0) {
-	/* unsafe, but required by the strtoul prototype */
-	*endPtr = (char *) p;
+	*endPtr = p;
    }

-    if (overflow) {
-	errno = ERANGE;
-	return ULONG_MAX;
-    } 
-    if (negative) {
-	return -result;
-    }
    return result;
 }
@@ -0,0 +1,100 @@
+/*
+ * tclErrno.h --
+ *
+ *	This header file contains the various POSIX errno definitions that
+ *	are used by Tcl.  This file is derived from the spec POSIX 2.4 and
+ *	previous implementations for Berkeley UNIX.
+ *
+ * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
+ * Copyright (c) 1996 Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: tclErrno.h,v 1.2 1998/09/14 18:39:45 stanton Exp $
+ */
+
+extern int errno;			/* global error number */
+
+#define	EPERM		1		/* Operation not permitted */
+#define	ENOENT		2		/* No such file or directory */
+#define	ESRCH		3		/* No such process */
+#define	EINTR		4		/* Interrupted system call */
+#define	EIO		5		/* Input/output error */
+#define	ENXIO		6		/* Device not configured */
+#define	E2BIG		7		/* Argument list too long */
+#define	ENOEXEC		8		/* Exec format error */
+#define	EBADF		9		/* Bad file descriptor */
+#define	ECHILD		10		/* No child processes */
+#define	EDEADLK		11		/* Resource deadlock avoided */
+					/* 11 was EAGAIN */
+#define	ENOMEM		12		/* Cannot allocate memory */
+#define	EACCES		13		/* Permission denied */
+#define	EFAULT		14		/* Bad address */
+#define	ENOTBLK		15		/* Block device required */
+#define	EBUSY		16		/* Device busy */
+#define	EEXIST		17		/* File exists */
+#define	EXDEV		18		/* Cross-device link */
+#define	ENODEV		19		/* Operation not supported by device */
+#define	ENOTDIR		20		/* Not a directory */
+#define	EISDIR		21		/* Is a directory */
+#define	EINVAL		22		/* Invalid argument */
+#define	ENFILE		23		/* Too many open files in system */
+#define	EMFILE		24		/* Too many open files */
+#define	ENOTTY		25		/* Inappropriate ioctl for device */
+#define	ETXTBSY		26		/* Text file busy */
+#define	EFBIG		27		/* File too large */
+#define	ENOSPC		28		/* No space left on device */
+#define	ESPIPE		29		/* Illegal seek */
+#define	EROFS		30		/* Read-only file system */
+#define	EMLINK		31		/* Too many links */
+#define	EPIPE		32		/* Broken pipe */
+#define	EDOM		33		/* Numerical argument out of domain */
+#define	ERANGE		34		/* Result too large */
+#define	EAGAIN		35		/* Resource temporarily unavailable */
+#define	EWOULDBLOCK	EAGAIN		/* Operation would block */
+#define	EINPROGRESS	36		/* Operation now in progress */
+#define	EALREADY	37		/* Operation already in progress */
+#define	ENOTSOCK	38		/* Socket operation on non-socket */
+#define	EDESTADDRREQ	39		/* Destination address required */
+#define	EMSGSIZE	40		/* Message too long */
+#define	EPROTOTYPE	41		/* Protocol wrong type for socket */
+#define	ENOPROTOOPT	42		/* Protocol not available */
+#define	EPROTONOSUPPORT	43		/* Protocol not supported */
+#define	ESOCKTNOSUPPORT	44		/* Socket type not supported */
+#define	EOPNOTSUPP	45		/* Operation not supported on socket */
+#define	EPFNOSUPPORT	46		/* Protocol family not supported */
+#define	EAFNOSUPPORT	47		/* Address family not supported by protocol family */
+#define	EADDRINUSE	48		/* Address already in use */
+#define	EADDRNOTAVAIL	49		/* Can't assign requested address */
+#define	ENETDOWN	50		/* Network is down */
+#define	ENETUNREACH	51		/* Network is unreachable */
+#define	ENETRESET	52		/* Network dropped connection on reset */
+#define	ECONNABORTED	53		/* Software caused connection abort */
+#define	ECONNRESET	54		/* Connection reset by peer */
+#define	ENOBUFS		55		/* No buffer space available */
+#define	EISCONN		56		/* Socket is already connected */
+#define	ENOTCONN	57		/* Socket is not connected */
+#define	ESHUTDOWN	58		/* Can't send after socket shutdown */
+#define	ETOOMANYREFS	59		/* Too many references: can't splice */
+#define	ETIMEDOUT	60		/* Connection timed out */
+#define	ECONNREFUSED	61		/* Connection refused */
+#define	ELOOP		62		/* Too many levels of symbolic links */
+#define	ENAMETOOLONG	63		/* File name too long */
+#define	EHOSTDOWN	64		/* Host is down */
+#define	EHOSTUNREACH	65		/* No route to host */
+#define	ENOTEMPTY	66		/* Directory not empty */
+#define	EPROCLIM	67		/* Too many processes */
+#define	EUSERS		68		/* Too many users */
+#define	EDQUOT		69		/* Disc quota exceeded */
+#define	ESTALE		70		/* Stale NFS file handle */
+#define	EREMOTE		71		/* Too many levels of remote in path */
+#define	EBADRPC		72		/* RPC struct is bad */
+#define	ERPCMISMATCH	73		/* RPC version wrong */
+#define	EPROGUNAVAIL	74		/* RPC prog. not avail */
+#define	EPROGMISMATCH	75		/* Program version wrong */
+#define	EPROCUNAVAIL	76		/* Bad procedure for program */
+#define	ENOLCK		77		/* No locks available */
+#define	ENOSYS		78		/* Function not implemented */
+#define	EFTYPE		79		/* Inappropriate file type or format */
+
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 1988 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that this notice is preserved and that due credit is given
+ * to the University of California at Berkeley. The name of the University
+ * may not be used to endorse or promote products derived from this
+ * software without specific written prior permission. This software
+ * is provided ``as is'' without express or implied warranty.
+ *
+ * RCS: @(#) $Id: tmpnam.c,v 1.2 1998/09/14 18:39:45 stanton Exp $
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+#include <stdio.h>
+
+/*
+ * Use /tmp instead of /usr/tmp, because L_tmpname is only 14 chars
+ * on some machines (like NeXT machines) and /usr/tmp will cause
+ * buffer overflows.
+ */
+
+#ifdef P_tmpdir
+#   undef P_tmpdir
+#endif
+#define	P_tmpdir	"/tmp"
+
+char *
+tmpnam(s)
+	char *s;
+{
+	static char name[50];
+	char *mktemp();
+
+	if (!s)
+		s = name;
+	(void)sprintf(s, "%s/XXXXXX", P_tmpdir);
+	return(mktemp(s));
+}
@@ -1,76 +1,84 @@
 /*
 * unistd.h --
 *
- *      Macros, constants and prototypes for Posix conformance.
+ *      Macros, CONSTants and prototypes for Posix conformance.
 *
- * Copyright 1989 Regents of the University of California Permission to use,
- * copy, modify, and distribute this software and its documentation for any
- * purpose and without fee is hereby granted, provided that the above
- * copyright notice appear in all copies. The University of California makes
- * no representations about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
+ * Copyright 1989 Regents of the University of California
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies.  The University of California
+ * makes no representations about the suitability of this
+ * software for any purpose.  It is provided "as is" without
+ * express or implied warranty.
+ *
+ * RCS: @(#) $Id: unistd.h,v 1.2 1998/09/14 18:39:45 stanton Exp $
 */

 #ifndef _UNISTD
 #define _UNISTD

 #include <sys/types.h>
+#ifndef _TCL
+#   include "tcl.h"
+#endif

 #ifndef NULL
 #define NULL    0
 #endif

 /* 
- * Strict POSIX stuff goes here. Extensions go down below, in the ifndef
- * _POSIX_SOURCE section.
+ * Strict POSIX stuff goes here.  Extensions go down below, in the 
+ * ifndef _POSIX_SOURCE section.
 */

-extern void		_exit(int status);
-extern int		access(const char *path, int mode);
-extern int		chdir(const char *path);
-extern int		chown(const char *path, uid_t owner, gid_t group);
-extern int		close(int fd);
-extern int		dup(int oldfd);
-extern int		dup2(int oldfd, int newfd);
-extern int		execl(const char *path, ...);
-extern int		execle(const char *path, ...);
-extern int		execlp(const char *file, ...);
-extern int		execv(const char *path, char **argv);
-extern int		execve(const char *path, char **argv, char **envp);
-extern int		execvpw(const char *file, char **argv);
-extern pid_t		fork(void);
-extern char *		getcwd(char *buf, size_t size);
-extern gid_t		getegid(void);
-extern uid_t		geteuid(void);
-extern gid_t		getgid(void);
-extern int		getgroups(int bufSize, int *buffer);
-extern pid_t		getpid(void);
-extern uid_t		getuid(void);
-extern int		isatty(int fd);
-extern long		lseek(int fd, long offset, int whence);
-extern int		pipe(int *fildes);
-extern int		read(int fd, char *buf, size_t size);
-extern int		setgid(gid_t group);
-extern int		setuid(uid_t user);
-extern unsigned		sleep(unsigned seconds);
-extern char *		ttyname(int fd);
-extern int		unlink(const char *path);
-extern int		write(int fd, const char *buf, size_t size);
+extern void _exit _ANSI_ARGS_((int status));
+extern int access _ANSI_ARGS_((CONST char *path, int mode));
+extern int chdir _ANSI_ARGS_((CONST char *path));
+extern int chown _ANSI_ARGS_((CONST char *path, uid_t owner, gid_t group));
+extern int close _ANSI_ARGS_((int fd));
+extern int dup _ANSI_ARGS_((int oldfd));
+extern int dup2 _ANSI_ARGS_((int oldfd, int newfd));
+extern int execl _ANSI_ARGS_((CONST char *path, ...));
+extern int execle _ANSI_ARGS_((CONST char *path, ...));
+extern int execlp _ANSI_ARGS_((CONST char *file, ...));
+extern int execv _ANSI_ARGS_((CONST char *path, char **argv));
+extern int execve _ANSI_ARGS_((CONST char *path, char **argv, char **envp));
+extern int execvp _ANSI_ARGS_((CONST char *file, char **argv));
+extern pid_t fork _ANSI_ARGS_((void));
+extern char *getcwd _ANSI_ARGS_((char *buf, size_t size));
+extern gid_t getegid _ANSI_ARGS_((void));
+extern uid_t geteuid _ANSI_ARGS_((void));
+extern gid_t getgid _ANSI_ARGS_((void));
+extern int getgroups _ANSI_ARGS_((int bufSize, int *buffer));
+extern pid_t getpid _ANSI_ARGS_((void));
+extern uid_t getuid _ANSI_ARGS_((void));
+extern int isatty _ANSI_ARGS_((int fd));
+extern long lseek _ANSI_ARGS_((int fd, long offset, int whence));
+extern int pipe _ANSI_ARGS_((int *fildes));
+extern int read _ANSI_ARGS_((int fd, char *buf, size_t size));
+extern int setgid _ANSI_ARGS_((gid_t group));
+extern int setuid _ANSI_ARGS_((uid_t user));
+extern unsigned sleep _ANSI_ARGS_ ((unsigned seconds));
+extern char *ttyname _ANSI_ARGS_((int fd));
+extern int unlink _ANSI_ARGS_((CONST char *path));
+extern int write _ANSI_ARGS_((int fd, CONST char *buf, size_t size));

 #ifndef	_POSIX_SOURCE
-extern char *		crypt(const char *, const char *);
-extern int		fchown(int fd, uid_t owner, gid_t group);
-extern int		flock(int fd, int operation);
-extern int		ftruncate(int fd, unsigned long length);
-extern int		ioctl(int fd, int request, ...);
-extern int		readlink(const char *path, char *buf, int bufsize);
-extern int		setegid(gid_t group);
-extern int		seteuidw(uid_t user);
-extern int		setreuid(int ruid, int euid);
-extern int		symlink(const char *, const char *);
-extern int		ttyslot(void);
-extern int		truncate(const char *path, unsigned long length);
-extern int		vfork(void);
+extern char *crypt _ANSI_ARGS_((CONST char *, CONST char *));
+extern int fchown _ANSI_ARGS_((int fd, uid_t owner, gid_t group));
+extern int flock _ANSI_ARGS_((int fd, int operation));
+extern int ftruncate _ANSI_ARGS_((int fd, unsigned long length));
+extern int ioctl _ANSI_ARGS_((int fd, int request, ...));
+extern int readlink _ANSI_ARGS_((CONST char *path, char *buf, int bufsize));
+extern int setegid _ANSI_ARGS_((gid_t group));
+extern int seteuid _ANSI_ARGS_((uid_t user));
+extern int setreuid _ANSI_ARGS_((int ruid, int euid));
+extern int symlink _ANSI_ARGS_((CONST char *, CONST char *));
+extern int ttyslot _ANSI_ARGS_((void));
+extern int truncate _ANSI_ARGS_((CONST char *path, unsigned long length));
+extern int vfork _ANSI_ARGS_((void));
 #endif /* _POSIX_SOURCE */

 #endif /* _UNISTD */
+
@@ -1,17 +1,21 @@
 /* 
 * waitpid.c --
 *
- *	This procedure emulates the POSIX waitpid kernel call on BSD systems
- *	that don't have waitpid but do have wait3. This code is based on a
- *	prototype version written by Mark Diekhans and Karl Lehenbauer.
+ *	This procedure emulates the POSIX waitpid kernel call on
+ *	BSD systems that don't have waitpid but do have wait3.
+ *	This code is based on a prototype version written by
+ *	Mark Diekhans and Karl Lehenbauer.
 *
 * Copyright (c) 1993 The Regents of the University of California.
 * Copyright (c) 1994 Sun Microsystems, Inc.
 *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: waitpid.c,v 1.3 2000/01/11 22:08:50 hobbs Exp $
 */

+#include "tclInt.h"
 #include "tclPort.h"

 #ifndef pid_t
@@ -19,37 +23,40 @@
 #endif

 /*
- * A linked list of the following structures is used to keep track of
- * processes for which we received notification from the kernel, but the
- * application hasn't waited for them yet (this can happen because wait may
- * not return the process we really want). We save the information here until
- * the application finally does wait for the process.
+ * A linked list of the following structures is used to keep track
+ * of processes for which we received notification from the kernel,
+ * but the application hasn't waited for them yet (this can happen
+ * because wait may not return the process we really want).  We
+ * save the information here until the application finally does
+ * wait for the process.
 */

 typedef struct WaitInfo {
-    pid_t pid;			/* Pid of process that exited. */
-    WAIT_STATUS_TYPE status;	/* Status returned when child exited or
-				 * suspended. */
-    struct WaitInfo *nextPtr;	/* Next in list of exited processes. */
+    pid_t pid;				/* Pid of process that exited. */
+    WAIT_STATUS_TYPE status;		/* Status returned when child exited
+					 * or suspended. */
+    struct WaitInfo *nextPtr;		/* Next in list of exited processes. */
 } WaitInfo;

-static WaitInfo *deadList = NULL;
-				/* First in list of all dead processes. */
+static WaitInfo *deadList = NULL;	/* First in list of all dead
+					 * processes. */

 /*
 *----------------------------------------------------------------------
 *
 * waitpid --
 *
- *	This procedure emulates the functionality of the POSIX waitpid kernel
- *	call, using the BSD wait3 kernel call. Note: it doesn't emulate
- *	absolutely all of the waitpid functionality, in that it doesn't
- *	support pid's of 0 or < -1.
+ *	This procedure emulates the functionality of the POSIX
+ *	waitpid kernel call, using the BSD wait3 kernel call.
+ *	Note:  it doesn't emulate absolutely all of the waitpid
+ *	functionality, in that it doesn't support pid's of 0
+ *	or < -1.
 *
 * Results:
- *	-1 is returned if there is an error in the wait kernel call. Otherwise
- *	the pid of an exited or suspended process is returned and *statusPtr
- *	is set to the status value of the process.
+ *	-1 is returned if there is an error in the wait kernel call.
+ *	Otherwise the pid of an exited or suspended process is
+ *	returned and *statusPtr is set to the status value of the
+ *	process.
 *
 * Side effects:
 *	None.
@@ -62,12 +69,12 @@ static WaitInfo *deadList = NULL;
 #endif

 pid_t
-waitpid(
-    pid_t pid,			/* The pid to wait on. Must be -1 or greater
-				 * than zero. */
-    int *statusPtr,		/* Where to store wait status for the
+waitpid(pid, statusPtr, options)
+    pid_t pid;			/* The pid to wait on.  Must be -1 or
+				 * greater than zero. */
+    int *statusPtr;		/* Where to store wait status for the
 				 * process. */
-    int options)		/* OR'ed combination of WNOHANG and
+    int options;		/* OR'ed combination of WNOHANG and
 				 * WUNTRACED. */
 {
    register WaitInfo *waitPtr, *prevPtr;
@@ -80,9 +87,9 @@ waitpid(
    }

    /*
-     * See if there's a suitable process that has already stopped or exited.
-     * If so, remove it from the list of exited processes and return its
-     * information.
+     * See if there's a suitable process that has already stopped or
+     * exited. If so, remove it from the list of exited processes and
+     * return its information.
     */

    for (waitPtr = deadList, prevPtr = NULL; waitPtr != NULL;
@@ -105,12 +112,12 @@ waitpid(
    }

    /*
-     * Wait for any process to stop or exit. If it's an acceptable one then
-     * return it to the caller; otherwise store information about it in the
-     * list of exited processes and try again. On systems that have only wait
-     * but not wait3, there are several situations we can't handle, but we do
-     * the best we can (e.g. can still handle some combinations of options by
-     * invoking wait instead of wait3).
+     * Wait for any process to stop or exit.  If it's an acceptable one
+     * then return it to the caller;  otherwise store information about it
+     * in the list of exited processes and try again.  On systems that
+     * have only wait but not wait3, there are several situations we can't
+     * handle, but we do the best we can (e.g. can still handle some
+     * combinations of options by invoking wait instead of wait3).
     */

    while (1) {
@@ -143,13 +150,13 @@ waitpid(
 	return result;

 	/*
-	 * Can't return this info to caller. Save it in the list of stopped or
-	 * exited processes. Tricky point: first check for an existing entry
-	 * for the process and overwrite it if it exists (e.g. a previously
-	 * stopped process might now be dead).
+	 * Can't return this info to caller.  Save it in the list of
+	 * stopped or exited processes.  Tricky point: first check for
+	 * an existing entry for the process and overwrite it if it
+	 * exists (e.g. a previously stopped process might now be dead).
 	 */

-    saveInfo:
+	saveInfo:
 	for (waitPtr = deadList; waitPtr != NULL; waitPtr = waitPtr->nextPtr) {
 	    if (waitPtr->pid == result) {
 		waitPtr->status = status;
@@ -162,7 +169,6 @@ waitpid(
 	waitPtr->nextPtr = deadList;
 	deadList = waitPtr;

-    waitAgain:
-	continue;
+	waitAgain: continue;
    }
 }
@@ -1,9 +1,11 @@
 '\"
-'\" Copyright (c) 1998-1999 Scriptics Corporation
+'\" Copyright (c) 1998-1999 Scriptics Corportation
 '\"
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Access.3,v 1.5 2001/12/10 15:50:46 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_Access 3 8.1 Tcl "Tcl Library Procedures"
 .BS
@@ -19,7 +21,7 @@ int
 int
 \fBTcl_Stat\fR(\fIpath\fR, \fIstatPtr\fR)
 .SH ARGUMENTS
-.AS "struct stat" *statPtr out
+.AS stat *statPtr in
 .AP char *path in
 Native name of the file to check the attributes of.
 .AP int mode in
@@ -27,7 +29,7 @@ Mask consisting of one or more of R_OK, W_OK, X_OK and F_OK.  R_OK,
 W_OK and X_OK request checking whether the file exists and  has  read,
 write and  execute  permissions, respectively.  F_OK just requests
 checking for the existence of the file.
-.AP "struct stat" *statPtr out
+.AP stat *statPtr out
 The structure that contains the result.
 .BE

@@ -42,7 +44,7 @@ rather than calling system level functions \fBaccess\fR and \fBstat\fR
 directly.  First, the Windows implementation of both functions fixes
 some bugs in the system level calls.  Second, both \fBTcl_Access\fR
 and \fBTcl_Stat\fR (as well as \fBTcl_OpenFileChannelProc\fR) hook
-into a linked list of functions.  This allows the possibility to reroute
+into a linked list of functions.  This allows the possibity to reroute
 file access to alternative media or access methods.
 .PP
 \fBTcl_Access\fR checks whether the process would be allowed to read,
@@ -60,7 +62,7 @@ about the specified file.  You do not need any access rights to the
 file to get this information but you need search rights to all
 directories named in the path leading to the file.  The stat structure
 includes info regarding device, inode (always 0 on Windows),
-privilege mode, nlink (always 1 on Windows), user id (always 0 on
+priviledge mode, nlink (always 1 on Windows), user id (always 0 on
 Windows), group id (always 0 on Windows), rdev (same as device on
 Windows), size, last access time, last modification time, and creation
 time.
@@ -71,4 +73,3 @@ given.

 .SH KEYWORDS
 stat, access
-
@@ -5,235 +5,130 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: AddErrInfo.3,v 1.6 2002/01/15 21:19:06 dgp Exp $
+'\" 
 .so man.macros
-.TH Tcl_AddErrorInfo 3 8.5 Tcl "Tcl Library Procedures"
+.TH Tcl_AddErrorInfo 3 8.0 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_GetReturnOptions, Tcl_SetReturnOptions, Tcl_AddErrorInfo, Tcl_AppendObjToErrorInfo, Tcl_AddObjErrorInfo, Tcl_SetObjErrorCode, Tcl_SetErrorCode, Tcl_SetErrorCodeVA, Tcl_PosixError, Tcl_LogCommandInfo \- retrieve or record information about errors and other return options
+Tcl_AddObjErrorInfo, Tcl_AddErrorInfo, Tcl_SetObjErrorCode, Tcl_SetErrorCode, Tcl_SetErrorCodeVA, Tcl_PosixError, Tcl_LogCommandInfo \- record information about errors
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
-.VS 8.5
-.sp
-Tcl_Obj *
-\fBTcl_GetReturnOptions\fR(\fIinterp, code\fR)
-.sp
-int 
-\fBTcl_SetReturnOptions\fR(\fIinterp, options\fR)
-.VE 8.5
-.sp
-\fBTcl_AddErrorInfo\fR(\fIinterp, message\fR)
-.VS 8.5
-.sp
-\fBTcl_AppendObjToErrorInfo\fR(\fIinterp, objPtr\fR)
-.VE 8.5
 .sp
 \fBTcl_AddObjErrorInfo\fR(\fIinterp, message, length\fR)
 .sp
+\fBTcl_AddErrorInfo\fR(\fIinterp, message\fR)
+.sp
 \fBTcl_SetObjErrorCode\fR(\fIinterp, errorObjPtr\fR)
 .sp
 \fBTcl_SetErrorCode\fR(\fIinterp, element, element, ... \fB(char *) NULL\fR)
 .sp
 \fBTcl_SetErrorCodeVA\fR(\fIinterp, argList\fR)
 .sp
-const char *
+CONST char *
 \fBTcl_PosixError\fR(\fIinterp\fR)
 .sp
 void
 \fBTcl_LogCommandInfo\fR(\fIinterp, script, command, commandLength\fR)
 .SH ARGUMENTS
-.AS Tcl_Interp commandLength
+.AS Tcl_Interp *message
 .AP Tcl_Interp *interp in
 Interpreter in which to record information.
-.AP int code 
-The code returned from script evaluation.
-.AP Tcl_Obj *options
-A dictionary of return options.
 .AP char *message in
-For \fBTcl_AddErrorInfo\fR,
-this is a conventional C string to append to the \fB\-errorinfo\fR return option.
 For \fBTcl_AddObjErrorInfo\fR,
-this points to the first byte of an array of \fIlength\fR bytes
-containing a string to append to the \fB\-errorinfo\fR return option.
+this points to the first byte of an array of bytes
+containing a string to record in the \fBerrorInfo\fR variable.
 This byte array may contain embedded null bytes
 unless \fIlength\fR is negative.
-.VS 8.5
-.AP Tcl_Obj *objPtr in
-A message to be appended to the \fB\-errorinfo\fR return option
-in the form of a Tcl_Obj value.
-.VE 8.5
+For \fBTcl_AddErrorInfo\fR,
+this is a conventional C string to record in the \fBerrorInfo\fR variable.
 .AP int length in
 The number of bytes to copy from \fImessage\fR when
-appending to the \fB\-errorinfo\fR return option.
+setting the \fBerrorInfo\fR variable.
 If negative, all bytes up to the first null byte are used.
 .AP Tcl_Obj *errorObjPtr in
-The \fB\-errorcode\fR return option will be set to this value.
+This variable \fBerrorCode\fR will be set to this value.
 .AP char *element in
-String to record as one element of the \fB\-errorcode\fR return option.
+String to record as one element of \fBerrorCode\fR variable.
 Last \fIelement\fR argument must be NULL.
 .AP va_list argList in
-An argument list which must have been initialized using
-\fBva_start\fR, and cleared using \fBva_end\fR.
-.AP "const char" *script in
+An argument list which must have been initialised using
+\fBTCL_VARARGS_START\fR, and cleared using \fBva_end\fR.
+.AP char *script in
 Pointer to first character in script containing command (must be <= command)
-.AP "const char" *command in
+.AP char *command in
 Pointer to first character in command that generated the error
 .AP int commandLength in
-Number of bytes in command; -1 means use all bytes up to first null byte
+Number of bytes in command; -1 means use all bytes up to first NULL byte
 .BE

 .SH DESCRIPTION
 .PP
-.VS 8.5
-The \fBTcl_SetReturnOptions\fR and \fBTcl_GetReturnOptions\fR
-routines expose the same capabilities as the \fBreturn\fR and
-\fBcatch\fR commands, respectively, in the form of a C interface.
-.PP
-\fBTcl_GetReturnOptions\fR retrieves the dictionary of return options
-from an interpreter following a script evaluation.
-Routines such as \fBTcl_Eval\fR are called to evaluate a
-script in an interpreter.  These routines return an integer
-completion code.  These routines also leave in the interpreter
-both a result and a dictionary of return options generated
-by script evaluation.  Just as \fBTcl_GetObjResult\fR retrieves
-the result, \fBTcl_GetReturnOptions\fR retrieves the dictionary
-of return options.  The integer completion code should be
-passed as the \fIcode\fR argument to \fBTcl_GetReturnOptions\fR
-so that all required options will be present in the dictionary.
-Specifically, a \fIcode\fR value of \fBTCL_ERROR\fR will
-ensure that entries for the keys \fB\-errorinfo\fR,
-\fB\-errorcode\fR, and \fB\-errorline\fR will appear in the
-dictionary.  Also, the entries for the keys \fB\-code\fR
-and \fB\-level\fR will be adjusted if necessary to agree
-with the value of \fIcode\fR.  The \fB(Tcl_Obj *)\fR returned
-by \fBTcl_GetReturnOptions\fR points to an unshared
-\fBTcl_Obj\fR with reference count of zero.  The dictionary
-may be written to, either adding, removing, or overwriting
-any entries in it, without the need to check for a shared object.
-.PP
-A typical usage for \fBTcl_GetReturnOptions\fR is to
-retrieve the stack trace when script evaluation returns
-\fBTCL_ERROR\fR, like so:
-.CS
-int code = Tcl_Eval(interp, script);
-if (code == TCL_ERROR) {
-    Tcl_Obj *options = Tcl_GetReturnOptions(interp, code);  
-    Tcl_Obj *key = Tcl_NewStringObj("-errorinfo", -1);
-    Tcl_Obj *stackTrace;
-    Tcl_IncrRefCount(key);
-    Tcl_DictObjGet(NULL, options, key, &stackTrace);
-    Tcl_DecrRefCount(key);
-    /* Do something with stackTrace */
-}
-.CE
-.PP
-\fBTcl_SetReturnOptions\fR sets the return options
-of \fIinterp\fR to be \fIoptions\fR.  If \fIoptions\fR
-contains any invalid value for any key, TCL_ERROR will
-be returned, and the interp result will be set to an
-appropriate error message.  Otherwise, a completion code
-in agreement with the \fB\-code\fR and \fB\-level\fR
-keys in \fIoptions\fR will be returned.
-.PP
-As an example, Tcl's \fBreturn\fR command itself could
-be implemented in terms of \fBTcl_SetReturnOptions\fR
-like so:
-.CS
-if ((objc % 2) == 0) { /* explicit result argument */
-    objc--;
-    Tcl_SetObjResult(interp, objv[objc]);
-}
-return Tcl_SetReturnOptions(interp, Tcl_NewListObj(objc-1, objv+1));
-.CE
-(It is not really implemented that way.  Internal access
-privileges allow for a more efficient alternative that meshes
-better with the bytecode compiler.)
-.PP
-Note that a newly created \fBTcl_Obj\fR may be passed
-in as the \fIoptions\fR argument without the need to tend
-to any reference counting.  This is analogous to
-\fBTcl_SetObjResult\fR.
-.PP
-While \fBTcl_SetReturnOptions\fR provides a general interface
-to set any collection of return options, there are a handful
-of return options that are very frequently used.  Most 
-notably the \fB\-errorinfo\fR and \fB\-errorcode\fR return
-options should be set properly when the command procedure
-of a command returns \fBTCL_ERROR\fR.  Tcl provides several
-simpler interfaces to more directly set these return options.
-.VE 8.5
-.PP
-The \fB\-errorinfo\fR option holds a stack trace of the
+These procedures are used to manipulate two Tcl global variables
+that hold information about errors.
+The variable \fBerrorInfo\fR holds a stack trace of the
 operations that were in progress when an error occurred,
 and is intended to be human-readable.
-The \fB\-errorcode\fR option holds a list of items that
+The variable \fBerrorCode\fR holds a list of items that
 are intended to be machine-readable.
-The first item in the \fB\-errorcode\fR value identifies the class of
+The first item in \fBerrorCode\fR identifies the class of
 error that occurred
 (e.g. POSIX means an error occurred in a POSIX system call)
-and additional elements hold additional pieces
+and additional elements in \fBerrorCode\fR hold additional pieces
 of information that depend on the class.
-See the tclvars manual entry for details on the various
-formats for the \fB\-errorcode\fR option used by
-Tcl's built-in commands.
+See the Tcl overview manual entry for details on the various
+formats for \fBerrorCode\fR.
 .PP
-The \fB\-errorinfo\fR option value is gradually built up as an
+The \fBerrorInfo\fR variable is gradually built up as an
 error unwinds through the nested operations.
-Each time an error code is returned to \fBTcl_Eval\fR, or
-any of the routines that performs script evaluation,
-the procedure \fBTcl_AddErrorInfo\fR is called to add
-additional text to the \fB\-errorinfo\fR value describing the
+Each time an error code is returned to \fBTcl_EvalObjEx\fR
+(or \fBTcl_Eval\fR, which calls \fBTcl_EvalObjEx\fR)
+it calls the procedure \fBTcl_AddObjErrorInfo\fR to add
+additional text to \fBerrorInfo\fR describing the
 command that was being executed when the error occurred.
 By the time the error has been passed all the way back
 to the application, it will contain a complete trace
 of the activity in progress when the error occurred.
 .PP
 It is sometimes useful to add additional information to
-the \fB\-errorinfo\fR value beyond what can be supplied automatically
-by the script evaluation routines.
-\fBTcl_AddErrorInfo\fR may be used for this purpose:
-its \fImessage\fR argument is an additional
-string to be appended to the \fB\-errorinfo\fR option.
-For example, when an error arises during the \fBsource\fR command,
-the procedure \fBTcl_AddErrorInfo\fR is called to
-record the name of the file being processed and the
-line number on which the error occurred.
-Likewise, when an error arises during evaluation of a
-Tcl procedures, the procedure name and line number
+\fBerrorInfo\fR beyond what can be supplied automatically
+by \fBTcl_EvalObjEx\fR.
+\fBTcl_AddObjErrorInfo\fR may be used for this purpose:
+its \fImessage\fR and \fIlength\fR arguments describe an additional
+string to be appended to \fBerrorInfo\fR.
+For example, the \fBsource\fR command calls \fBTcl_AddObjErrorInfo\fR
+to record the name of the file being processed and the
+line number on which the error occurred;
+for Tcl procedures, the procedure name and line number
 within the procedure are recorded, and so on.
-The best time to call \fBTcl_AddErrorInfo\fR is just after
-a script evaluation routine has returned \fBTCL_ERROR\fR.
-The value of the \fB\-errorline\fR return option (retrieved
-via a call to \fBTcl_GetReturnOptions\fR) often makes up
-a useful part of the \fImessage\fR passed to \fBTcl_AddErrorInfo\fR.
+The best time to call \fBTcl_AddObjErrorInfo\fR is just after
+\fBTcl_EvalObjEx\fR has returned \fBTCL_ERROR\fR.
+In calling \fBTcl_AddObjErrorInfo\fR, you may find it useful to
+use the \fBerrorLine\fR field of the interpreter (see the
+\fBTcl_Interp\fR manual entry for details).
 .PP
-.VS 8.5
-\fBTcl_AppendObjToErrorInfo\fR is an alternative interface to the
-same functionality as \fBTcl_AddErrorInfo\fR.  \fBTcl_AppendObjToErrorInfo\fR
-is called when the string value to be appended to the \fB\-errorinfo\fR option
-is available as a \fBTcl_Obj\fR instead of as a \fBchar\fR array.
-.VE 8.5
-.PP
-\fBTcl_AddObjErrorInfo\fR is nearly identical
-to \fBTcl_AddErrorInfo\fR, except that it has an additional \fIlength\fR
-argument.  This allows the \fImessage\fR string to contain 
-embedded null bytes.  This is essentially never a good idea.
-If the \fImessage\fR needs to contain the null character \fBU+0000\fR,
-Tcl's usual internal encoding rules should be used to avoid
-the need for a null byte.  If the \fBTcl_AddObjErrorInfo\fR
-interface is used at all, it should be with a negative \fIlength\fR value.
+\fBTcl_AddErrorInfo\fR resembles \fBTcl_AddObjErrorInfo\fR
+but differs in initializing \fBerrorInfo\fR from the string
+value of the interpreter's result
+if the error is just starting to be logged.
+It does not use the result as a Tcl object
+so any embedded null characters in the result
+will cause information to be lost.
+It also takes a conventional C string in \fImessage\fR
+instead of \fBTcl_AddObjErrorInfo\fR's counted string.
 .PP
 The procedure \fBTcl_SetObjErrorCode\fR is used to set the
-\fB\-errorcode\fR return option to the list object \fIerrorObjPtr\fR 
-built up by the caller. 
-\fBTcl_SetObjErrorCode\fR is typically invoked just 
-before returning an error. If an error is
+\fBerrorCode\fR variable. \fIerrorObjPtr\fR contains a list object
+built up by the caller. \fBerrorCode\fR is set to this
+value. \fBTcl_SetObjErrorCode\fR is typically invoked just 
+before returning an error in an object command. If an error is
 returned without calling \fBTcl_SetObjErrorCode\fR or
 \fBTcl_SetErrorCode\fR the Tcl interpreter automatically sets
-the \fB\-errorcode\fR return option to \fBNONE\fR.
+\fBerrorCode\fR to \fBNONE\fR.
 .PP
 The procedure \fBTcl_SetErrorCode\fR is also used to set the
-\fB\-errorcode\fR return option. However, it takes one or more strings to
+\fBerrorCode\fR variable. However, it takes one or more strings to
 record instead of an object. Otherwise, it is similar to
 \fBTcl_SetObjErrorCode\fR in behavior.
 .PP
@@ -241,10 +136,9 @@ record instead of an object. Otherwise, it is similar to
 instead of taking a variable number of arguments it takes an argument list.
 .PP
 \fBTcl_PosixError\fR
-sets the \fB\-errorcode\fR variable after an error in a POSIX kernel call.
+sets the \fBerrorCode\fR variable after an error in a POSIX kernel call.
 It reads the value of the \fBerrno\fR C variable and calls
-\fBTcl_SetErrorCode\fR to set the \fB\-errorcode\fR return
-option in the \fBPOSIX\fR format.
+\fBTcl_SetErrorCode\fR to set \fBerrorCode\fR in the \fBPOSIX\fR format.
 The caller must previously have called \fBTcl_SetErrno\fR to set
 \fBerrno\fR; this is necessary on some platforms (e.g. Windows) where Tcl
 is linked into an application as a shared library, or when the error
@@ -254,44 +148,41 @@ occurs in a dynamically loaded extension. See the manual entry for
 \fBTcl_PosixError\fR returns a human-readable diagnostic message
 for the error
 (this is the same value that will appear as the third element
-in the \fB\-errorcode\fR value).
+in \fBerrorCode\fR).
 It may be convenient to include this string as part of the
 error message returned to the application in
 the interpreter's result.
 .PP
 \fBTcl_LogCommandInfo\fR is invoked after an error occurs in an
 interpreter.  It adds information about the command that was being
-executed when the error occurred to the \fB\-errorinfo\fR value, and
-the line number stored internally in the interpreter is set.  
+executed when the error occured to the \fBerrorInfo\fR variable, and
+the line number stored internally in the interpreter is set.  On the
+first call to \fBTcl_LogCommandInfo\fR or \fBTcl_AddObjErrorInfo\fR
+since an error occurred, the old information in \fBerrorInfo\fR is
+deleted.
 .PP
-In older releases of Tcl, there was no \fBTcl_GetReturnOptions\fR
-routine.  In its place, the global Tcl variables \fBerrorInfo\fR
-and \fBerrorCode\fR were the only place to retrieve the error
-information.  Much existing code written for older Tcl releases
-still access this information via those global variables.
-.PP
-It is important to realize that while reading from those
-global variables remains a supported way to access these
-return option values, it is important not to assume that
-writing to those global variables will properly set the
-corresponding return options.  It has long been emphasized
-in this manual page that it is important to 
-call the procedures described here rather than
+It is important to call the procedures described here rather than
 setting \fBerrorInfo\fR or \fBerrorCode\fR directly with
 \fBTcl_ObjSetVar2\fR.
+The reason for this is that the Tcl interpreter keeps information
+about whether these procedures have been called.
+For example, the first time \fBTcl_AddObjErrorInfo\fR is called
+for an error, it clears the existing value of \fBerrorInfo\fR
+and adds the error message in the interpreter's result to the variable
+before appending \fImessage\fR;
+in subsequent calls, it just appends the new \fImessage\fR.
+When \fBTcl_SetErrorCode\fR is called, it sets a flag indicating
+that \fBerrorCode\fR has been set;
+this allows the Tcl interpreter to set \fBerrorCode\fR to \fBNONE\fR
+if it receives an error return
+when \fBTcl_SetErrorCode\fR hasn't been called.
 .PP
 If the procedure \fBTcl_ResetResult\fR is called,
-it clears all of the state of the interpreter associated with
-script evaluation, including the entire return options dictionary.
-In particular, the \fB\-errorinfo\fR and \fB\-errorcode\fR options
-are reset.  
-If an error had occurred, the \fBTcl_ResetResult\fR call will
-clear the error state to make it appear as if no error had
-occurred after all.
-The global variables \fBerrorInfo\fR and
-\fBerrorCode\fR are not modified by \fBTcl_ResetResult\fR
-so they continue to hold a record of information about the
-most recent error seen in an interpreter.
+it clears all of the state associated with
+\fBerrorInfo\fR and \fBerrorCode\fR
+(but it doesn't actually modify the variables).
+If an error had occurred, this will clear the error state to
+make it appear as if no error had occurred after all.

 .SH "SEE ALSO"
 Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_Interp, Tcl_ResetResult, Tcl_SetErrno
@@ -4,11 +4,13 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Alloc.3,v 1.5 2001/04/06 23:14:08 andreas_kupries Exp $
+'\" 
 .so man.macros
 .TH Tcl_Alloc 3 7.5 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_Alloc, Tcl_Free, Tcl_Realloc, Tcl_AttemptAlloc, Tcl_AttemptRealloc, ckalloc, ckfree, ckrealloc, attemptckalloc, attemptckrealloc \- allocate or free heap memory
+Tcl_Alloc, Tcl_Free, Tcl_Realloc, Tcl_AttemptAlloc, Tcl_AttemptRealloc \- allocate or free heap memory
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -16,7 +18,6 @@ Tcl_Alloc, Tcl_Free, Tcl_Realloc, Tcl_AttemptAlloc, Tcl_AttemptRealloc, ckalloc,
 char *
 \fBTcl_Alloc\fR(\fIsize\fR)
 .sp
-void
 \fBTcl_Free\fR(\fIptr\fR)
 .sp
 char *
@@ -27,24 +28,9 @@ char *
 .sp
 char *
 \fBTcl_AttemptRealloc\fR(\fIptr, size\fR)
-.sp
-char *
-\fBckalloc\fR(\fIsize\fR)
-.sp
-void
-\fBckfree\fR(\fIptr\fR)
-.sp
-char *
-\fBckrealloc\fR(\fIptr, size\fR)
-.sp
-char *
-\fBattemptckalloc\fR(\fIsize\fR)
-.sp
-char *
-\fBattemptckrealloc\fR(\fIptr, size\fR)
 .SH ARGUMENTS
 .AS char *size
-.AP "unsigned int" size in
+.AP int size in
 Size in bytes of the memory block to allocate.
 .AP char *ptr in
 Pointer to memory block to free or realloc.
@@ -67,26 +53,12 @@ further allocation.
 \fBTcl_Realloc\fR changes the size of the block pointed to by
 \fIptr\fR to \fIsize\fR bytes and returns a pointer to the new block.
 The contents will be unchanged up to the lesser of the new and old
-sizes.  The returned location may be different from \fIptr\fR.  If
-\fIptr\fR is NULL, this is equivalent to calling \fBTcl_Alloc\fR with
-just the \fIsize\fR argument.
+sizes.  The returned location may be different from \fIptr\fR.
 .PP
 \fBTcl_AttemptAlloc\fR and \fBTcl_AttemptRealloc\fR are identical in
 function to \fBTcl_Alloc\fR and \fBTcl_Realloc\fR, except that
 \fBTcl_AttemptAlloc\fR and \fBTcl_AttemptRealloc\fR will not cause the Tcl
 interpreter to \fBpanic\fR if the memory allocation fails.  If the
-allocation fails, these functions will return NULL.  Note that on some
-platforms, but not all, attempting to allocate a zero-sized block of
-memory will also cause these functions to return NULL.
-.PP
-The procedures \fBckalloc\fR, \fBckfree\fR, \fBckrealloc\fR,
-\fBattemptckalloc\fR, and \fBattemptckrealloc\fR are implemented
-as macros.  Normally, they are synonyms for the corresponding
-procedures documented on this page.  When Tcl and all modules
-calling Tcl are compiled with \fBTCL_MEM_DEBUG\fR defined, however,
-these macros are redefined to be special debugging versions
-of these procedures.  To support Tcl's memory debugging within a
-module, use the macros rather than direct calls to \fBTcl_Alloc\fR, etc.
-
+allocation fails, these functions will return NULL.
 .SH KEYWORDS
-alloc, allocation, free, malloc, memory, realloc, TCL_MEM_DEBUG
+alloc, allocation, free, malloc, memory, realloc
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: AllowExc.3,v 1.2 1998/09/14 18:39:45 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_AllowExceptions 3 7.4 Tcl "Tcl Library Procedures"
 .BS
@@ -16,7 +18,7 @@ Tcl_AllowExceptions \- allow all exceptions in next script evaluation
 .sp
 \fBTcl_AllowExceptions\fR(\fIinterp\fR)
 .SH ARGUMENTS
-.AS Tcl_Interp *interp
+.AS Tcl_Interp *doublePtr
 .AP Tcl_Interp *interp in
 Interpreter in which script will be evaluated.
 .BE
@@ -25,20 +27,16 @@ Interpreter in which script will be evaluated.
 .PP
 If a script is evaluated at top-level (i.e. no other scripts are
 pending evaluation when the script is invoked), and if the script
-terminates with a completion code other than \fBTCL_OK\fR, \fBTCL_ERROR\fR
-or \fBTCL_RETURN\fR, then Tcl normally converts this into a \fBTCL_ERROR\fR
-return with an appropriate message.  The particular script
-evaluation procedures of Tcl that act in the manner are
-\fBTcl_EvalObjEx\fR, \fBTcl_EvalObjv\fR, \fBTcl_Eval\fR, \fBTcl_EvalEx\fR,
-\fBTcl_GlobalEval\fR, \fBTcl_GlobalEvalObj\fR, \fBTcl_VarEval\fR and
-\fBTcl_VarEvalVA\fR. 
+terminates with a completion code other than TCL_OK, TCL_CONTINUE
+or TCL_RETURN, then Tcl normally converts this into a TCL_ERROR
+return with an appropriate message.
 .PP
 However, if \fBTcl_AllowExceptions\fR is invoked immediately before
-calling one of those a procedures, then arbitrary completion
+calling a procedure such as \fBTcl_Eval\fR, then arbitrary completion
 codes are permitted from the script, and they are returned without
 modification.
 This is useful in cases where the caller can deal with exceptions
-such as \fBTCL_BREAK\fR or \fBTCL_CONTINUE\fR in a meaningful way.
+such as TCL_BREAK or TCL_CONTINUE in a meaningful way.

 .SH KEYWORDS
 continue, break, exception, interpreter
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: AppInit.3,v 1.3 2000/04/14 23:01:48 hobbs Exp $
+'\" 
 .so man.macros
 .TH Tcl_AppInit 3 7.0 Tcl "Tcl Library Procedures"
 .BS
@@ -24,9 +26,7 @@ Interpreter for the application.

 .SH DESCRIPTION
 .PP
-\fBTcl_AppInit\fR is a
-.QW hook
-procedure that is invoked by
+\fBTcl_AppInit\fR is a ``hook'' procedure that is invoked by
 the main programs for Tcl applications such as \fBtclsh\fR and \fBwish\fR.
 Its purpose is to allow new Tcl applications to be created without
 modifying the main programs provided as part of Tcl and Tk.
@@ -34,7 +34,7 @@ To create a new application you write a new version of
 \fBTcl_AppInit\fR to replace the default version provided by Tcl,
 then link your new \fBTcl_AppInit\fR with the Tcl library.
 .PP
-\fBTcl_AppInit\fR is invoked by \fBTcl_Main\fR and \fBTk_Main\fR
+\fBTcl_AppInit\fR is invoked after by \fBTcl_Main\fR and \fBTk_Main\fR
 after their own initialization and before entering the main loop
 to process commands.
 Here are some examples of things that \fBTcl_AppInit\fR might do:
@@ -49,8 +49,8 @@ Tcl variables \fBargv\fR and \fBargv0\fR in \fIinterp\fR.
 .IP [3]
 Invoke a startup script to initialize the application.
 .LP
-\fBTcl_AppInit\fR returns \fBTCL_OK\fR or \fBTCL_ERROR\fR.
-If it returns \fBTCL_ERROR\fR then it must leave an error message in
+\fBTcl_AppInit\fR returns TCL_OK or TCL_ERROR.
+If it returns TCL_ERROR then it must leave an error message in
 for the interpreter's result;  otherwise the result is ignored.
 .PP
 In addition to \fBTcl_AppInit\fR, your application should also contain
@@ -60,7 +60,7 @@ Tcl_Main(argc, argv, Tcl_AppInit);
 .CE
 The third argument to \fBTcl_Main\fR gives the address of the
 application-specific initialization procedure to invoke.
-This means that you do not have to use the name \fBTcl_AppInit\fR
+This means that you don't have to use the name \fBTcl_AppInit\fR
 for the procedure, but in practice the name is nearly always
 \fBTcl_AppInit\fR (in versions before Tcl 7.4 the name \fBTcl_AppInit\fR
 was implicit;  there was no way to specify the procedure explicitly).
@@ -4,11 +4,15 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" 
+'\" RCS: @(#) $Id: AssocData.3,v 1.4 2001/04/24 20:59:17 kennykb Exp $
 .so man.macros
 .TH Tcl_SetAssocData 3 7.5 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_GetAssocData, Tcl_SetAssocData, Tcl_DeleteAssocData \- manage associations of string keys and user specified data with Tcl interpreters
+Tcl_GetAssocData, Tcl_SetAssocData, Tcl_DeleteAssocData \- manage
+associations of string keys and user specified data with Tcl
+interpreters.
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -20,10 +24,12 @@ ClientData
 .sp
 \fBTcl_DeleteAssocData\fR(\fIinterp, key\fR)
 .SH ARGUMENTS
-.AS Tcl_InterpDeleteProc **delProcPtr
+.AS Tcl_InterpDeleteProc *delProcPtr
 .AP Tcl_Interp *interp in
 Interpreter in which to execute the specified command.
-.AP "const char" *key in
+.VS 8.4
+.AP "CONST char" *key in
+.VE
 Key for association with which to store data or from which to delete or
 retrieve data.  Typically the module prefix for a package.
 .AP Tcl_InterpDeleteProc *delProc in
@@ -63,8 +69,8 @@ is deleted.  \fIDeleteProc\fR should have arguments and result that match
 the type \fBTcl_InterpDeleteProc\fR:
 .CS
 typedef void Tcl_InterpDeleteProc(
-        ClientData \fIclientData\fR,
-        Tcl_Interp *\fIinterp\fR);
+	ClientData \fIclientData\fR,
+	Tcl_Interp *\fIinterp\fR);
 .CE
 When \fIdeleteProc\fR is invoked the \fIclientData\fR and \fIinterp\fR
 arguments will be the same as the corresponding arguments passed to
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Async.3,v 1.5 2000/07/26 01:29:00 davidg Exp $
+'\" 
 .so man.macros
 .TH Tcl_AsyncCreate 3 7.0 Tcl "Tcl Library Procedures"
 .BS
@@ -48,9 +50,9 @@ or 0 if \fIinterp\fR is NULL.
 These procedures provide a safe mechanism for dealing with
 asynchronous events such as signals.
 If an event such as a signal occurs while a Tcl script is being
-evaluated then it is not safe to take any substantive action to
+evaluated then it isn't safe to take any substantive action to
 process the event.
-For example, it is not safe to evaluate a Tcl script since the
+For example, it isn't safe to evaluate a Tcl script since the
 interpreter may already be in the middle of evaluating a script;
 it may not even be safe to allocate memory, since a memory
 allocation could have been in progress when the event occurred.
@@ -60,11 +62,11 @@ to a clean state, such as after the current Tcl command completes.
 .PP
 \fBTcl_AsyncCreate\fR, \fBTcl_AsyncDelete\fR, and \fBTcl_AsyncReady\fR
 are thread sensitive.  They access and/or set a thread-specific data
-structure in the event of a core built with \fI\-\-enable\-threads\fR.  The token
-created by \fBTcl_AsyncCreate\fR contains the needed thread information it
-was called from so that calling \fBTcl_AsyncMark\fR(\fItoken\fR) will only yield
-the origin thread into the asynchronous handler.
-.PP
+structure in the event of an --enable-thread built core.  The token
+created by Tcl_AsyncCreate contains the needed thread information it
+was called from so that calling Tcl_AsyncMark(token) will only yield
+the origin thread into the AsyncProc.
+.PP 
 \fBTcl_AsyncCreate\fR creates an asynchronous handler and returns
 a token for it.
 The asynchronous handler must be created before
@@ -83,9 +85,9 @@ the actions associated with the asynchronous event.
 type \fBTcl_AsyncProc\fR:
 .CS
 typedef int Tcl_AsyncProc(
-        ClientData \fIclientData\fR,
-        Tcl_Interp *\fIinterp\fR,
-        int \fIcode\fR);
+	ClientData \fIclientData\fR,
+	Tcl_Interp *\fIinterp\fR,
+	int \fIcode\fR);
 .CE
 The \fIclientData\fR will be the same as the \fIclientData\fR
 argument passed to \fBTcl_AsyncCreate\fR when the handler was
@@ -140,6 +142,7 @@ If new handlers become ready while handlers are executing,
 \fBTcl_AsyncInvoke\fR will invoke them all;  at each point it
 invokes the highest-priority (oldest) ready handler, repeating
 this over and over until there are no longer any ready handlers.
+
 .SH WARNING
 .PP
 It is almost always a bad idea for an asynchronous event
@@ -149,11 +152,12 @@ This sort of behavior can disrupt the execution of scripts in
 subtle ways and result in bugs that are extremely difficult
 to track down.
 If an asynchronous event handler needs to evaluate Tcl scripts
-then it should first save the interpreter's state by calling
-\fBTcl_SaveInterpState\fR, passing in the \fIcode\fR argument.
+then it should first save the interpreter's result plus the values
+of the variables \fBerrorInfo\fR and \fBerrorCode\fR (this can
+be done, for example, by storing them in dynamic strings).
 When the asynchronous handler is finished it should restore
-the interpreter's state by calling \fBTcl_RestoreInterpState\fR,
-and then returning the \fIcode\fR argument.
+the interpreter's result, \fBerrorInfo\fR, and \fBerrorCode\fR,
+and return the \fIcode\fR argument.

 .SH KEYWORDS
-asynchronous event, handler, signal, Tcl_SaveInterpState, thread
+asynchronous event, handler, signal
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: BackgdErr.3,v 1.3 2000/04/14 23:01:48 hobbs Exp $
+'\" 
 .so man.macros
 .TH Tcl_BackgroundError 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -24,8 +26,7 @@ Interpreter in which the error occurred.
 .SH DESCRIPTION
 .PP
 This procedure is typically invoked when a Tcl error occurs during
-.QW "background processing"
-such as executing an event handler.
+``background processing'' such as executing an event handler.
 When such an error occurs, the error condition is reported to Tcl
 or to a widget or some other C code, and there is not usually any
 obvious way for that code to report the error to the user.
@@ -33,29 +34,25 @@ In these cases the code calls \fBTcl_BackgroundError\fR with an
 \fIinterp\fR argument identifying the interpreter in which the
 error occurred.  At the time \fBTcl_BackgroundError\fR is invoked,
 the interpreter's result is expected to contain an error message.
-\fBTcl_BackgroundError\fR will invoke the command registered
-in that interpreter to handle background errors by the
-\fBinterp bgerror\fR command.
-The registered handler command is meant to report the error
-in an application-specific fashion.  The handler command
-receives two arguments, the result of the interp, and the
-return options of the interp at the time the error occurred.
-If the application registers no handler command, the default
-handler command will attempt to call \fBbgerror\fR to report
-the error.  If an error condition arises while invoking the
-handler command, then \fBTcl_BackgroundError\fR reports the
-error itself by printing a message on the standard error file.
+\fBTcl_BackgroundError\fR will invoke the \fBbgerror\fR
+Tcl command to report the error in an application-specific fashion.
+If no \fBbgerror\fR command exists, or if it returns with an error condition,
+then \fBTcl_BackgroundError\fR reports the error itself by printing
+a message on the standard error file.
 .PP
-\fBTcl_BackgroundError\fR does not invoke the handler command immediately
+\fBTcl_BackgroundError\fR does not invoke \fBbgerror\fR immediately
 because this could potentially interfere with scripts that are in process
 at the time the error occurred.
-Instead, it invokes the handler command later as an idle callback.
+Instead, it invokes \fBbgerror\fR later as an idle callback.
+\fBTcl_BackgroundError\fR saves the values of the \fBerrorInfo\fR and
+\fBerrorCode\fR variables and restores these values just before
+invoking \fBbgerror\fR.
 .PP
 It is possible for many background errors to accumulate before
-the handler command is invoked.  When this happens, each of the errors
-is processed in order.  However, if the handle command returns a
+\fBbgerror\fR is invoked.  When this happens, each of the errors
+is processed in order.  However, if \fBbgerror\fR returns a
 break exception, then all remaining error reports for the
 interpreter are skipped.

 .SH KEYWORDS
-background, bgerror, error, interp
+background, bgerror, error
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Backslash.3,v 1.3 1999/04/16 00:46:30 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_Backslash 3 "8.1" Tcl "Tcl Library Procedures"
 .BS
@@ -17,31 +19,35 @@ Tcl_Backslash \- parse a backslash sequence
 char
 \fBTcl_Backslash\fR(\fIsrc, countPtr\fR)
 .SH ARGUMENTS
-.AS char *countPtr out
+.AS char *countPtr
 .AP char *src in
 Pointer to a string starting with a backslash.
 .AP int *countPtr out
-If \fIcountPtr\fR is not NULL, \fI*countPtr\fR gets filled
+If \fIcountPtr\fR isn't NULL, \fI*countPtr\fR gets filled
 in with number of characters in the backslash sequence, including
 the backslash character.
 .BE

 .SH DESCRIPTION
 .PP
+.VS 8.1
 The use of \fBTcl_Backslash\fR is deprecated in favor of
 \fBTcl_UtfBackslash\fR.
 .PP
-This is a utility procedure provided for backwards compatibility with
+This is a utility procedure provided for backwards compatibilty with
 non-internationalized Tcl extensions.  It parses a backslash sequence and
 returns the low byte of the Unicode character corresponding to the sequence. 
+.VE
 \fBTcl_Backslash\fR modifies \fI*countPtr\fR to contain the number of
 characters in the backslash sequence.
 .PP
 See the Tcl manual entry for information on the valid backslash sequences.
 All of the sequences described in the Tcl manual entry are supported by
 \fBTcl_Backslash\fR.
+.VS 8.1 br
 .SH "SEE ALSO"
 Tcl(n), Tcl_UtfBackslash(3)
+.VE

 .SH KEYWORDS
 backslash, parse
@@ -1,15 +1,16 @@
 '\"
 '\" Copyright (c) 1996-1997 Sun Microsystems, Inc.
-'\" Contributions from Don Porter, NIST, 2005.  (not subject to US copyright)
 '\"
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: BoolObj.3,v 1.2 1998/09/14 18:39:46 stanton Exp $
+'\" 
 .so man.macros
-.TH Tcl_BooleanObj 3 8.5 Tcl "Tcl Library Procedures"
+.TH Tcl_BooleanObj 3 8.0 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_NewBooleanObj, Tcl_SetBooleanObj, Tcl_GetBooleanFromObj \- store/retrieve boolean value in a Tcl_Obj
+Tcl_NewBooleanObj, Tcl_SetBooleanObj, Tcl_GetBooleanFromObj \- manipulate Tcl objects as boolean values
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -22,14 +23,20 @@ Tcl_Obj *
 int
 \fBTcl_GetBooleanFromObj\fR(\fIinterp, objPtr, boolPtr\fR)
 .SH ARGUMENTS
-.AS Tcl_Interp boolValue in/out
+.AS Tcl_Interp *interp
 .AP int boolValue in
-Integer value to be stored as a boolean value in a Tcl_Obj.
+Integer value used to initialize or set a boolean object.
+If the integer is nonzero, the boolean object is set to 1;
+otherwise the boolean object is set to 0.
 .AP Tcl_Obj *objPtr in/out
-Points to the Tcl_Obj in which to store, or from which to
-retrieve a boolean value.
+For \fBTcl_SetBooleanObj\fR, this points to the object to be converted
+to boolean type.
+For \fBTcl_GetBooleanFromObj\fR, this refers to the object
+from which to get a boolean value; 
+if \fIobjPtr\fR does not already point to a boolean object,
+an attempt will be made to convert it to one.
 .AP Tcl_Interp *interp in/out
-If a boolean value cannot be retrieved,
+If an error occurs during conversion,
 an error message is left in the interpreter's result object
 unless \fIinterp\fR is NULL.
 .AP int *boolPtr out
@@ -39,57 +46,38 @@ stores the boolean value (0 or 1) obtained from \fIobjPtr\fR.

 .SH DESCRIPTION
 .PP
-These procedures are used to pass boolean values to and from
-Tcl as Tcl_Obj's.  When storing a boolean value into a Tcl_Obj,
-any non-zero integer value in \fIboolValue\fR is taken to be
-the boolean value \fB1\fR, and the integer value \fB0\fR is
-taken to be the boolean value \fB0\fR.
+These procedures are used to create, modify, and read
+boolean Tcl objects from C code.
+\fBTcl_NewBooleanObj\fR and \fBTcl_SetBooleanObj\fR
+will create a new object of boolean type
+or modify an existing object to have boolean type. 
+Both of these procedures set the object to have the
+boolean value (0 or 1) specified by \fIboolValue\fR;
+if \fIboolValue\fR is nonzero, the object is set to 1,
+otherwise to 0.
+\fBTcl_NewBooleanObj\fR returns a pointer to a newly created object
+with reference count zero.
+Both procedures set the object's type to be boolean
+and assign the boolean value to the object's internal representation
+\fIlongValue\fR member.
+\fBTcl_SetBooleanObj\fR invalidates any old string representation
+and, if the object is not already a boolean object,
+frees any old internal representation.
 .PP
-\fBTcl_NewBooleanObj\fR creates a new Tcl_Obj, stores the boolean
-value \fIboolValue\fR in it, and returns a pointer to the new Tcl_Obj.
-The new Tcl_Obj has reference count of zero.
-.PP
-\fBTcl_SetBooleanObj\fR accepts \fIobjPtr\fR, a pointer to
-an existing Tcl_Obj, and stores in the Tcl_Obj \fI*objPtr\fR 
-the boolean value \fIboolValue\fR.  This is a write operation
-on \fI*objPtr\fR, so \fIobjPtr\fR must be unshared.  Attempts to
-write to a shared Tcl_Obj will panic.  A successful write
-of \fIboolValue\fR into \fI*objPtr\fR implies the freeing of
-any former value stored in \fI*objPtr\fR.
-.PP
-\fBTcl_GetBooleanFromObj\fR attempts to retrieve a boolean value
-from the value stored in \fI*objPtr\fR.
-If \fIobjPtr\fR holds a string value recognized by \fBTcl_GetBoolean\fR,
-then the recognized boolean value is written at the address given
-by \fIboolPtr\fR.  
-If \fIobjPtr\fR holds any value recognized as
-a number by Tcl, then if that value is zero a 0 is written at
-the address given by \fIboolPtr\fR and if that
-value is non-zero a 1 is written at the address given by \fIboolPtr\fR.
-In all cases where a value is written at the address given
-by \fIboolPtr\fR, \fBTcl_GetBooleanFromObj\fR returns \fBTCL_OK\fR.
-If the value of \fIobjPtr\fR does not meet any of the conditions
-above, then \fBTCL_ERROR\fR is returned and an error message is 
-left in the interpreter's result unless \fIinterp\fR is NULL.
-\fBTcl_GetBooleanFromObj\fR may also make changes to the internal
-fields of \fI*objPtr\fR so that future calls to 
-\fBTcl_GetBooleanFromObj\fR on the same \fIobjPtr\fR can be
-performed more efficiently.
-.PP
-Note that the routines \fBTcl_GetBooleanFromObj\fR and
-\fBTcl_GetBoolean\fR are not functional equivalents.
-The set of values for which \fBTcl_GetBooleanFromObj\fR
-will return \fBTCL_OK\fR is strictly larger than
-the set of values for which \fBTcl_GetBoolean\fR will do the same.
-For example, the value
-.QW 5
-passed to \fBTcl_GetBooleanFromObj\fR
-will lead to a \fBTCL_OK\fR return (and the boolean value 1),
-while the same value passed to \fBTcl_GetBoolean\fR will lead to
-a \fBTCL_ERROR\fR return.
+\fBTcl_GetBooleanFromObj\fR attempts to return a boolean value
+from the Tcl object \fIobjPtr\fR.
+If the object is not already a boolean object,
+it will attempt to convert it to one.
+If an error occurs during conversion, it returns \fBTCL_ERROR\fR
+and leaves an error message in the interpreter's result object
+unless \fIinterp\fR is NULL.
+Otherwise, \fBTcl_GetBooleanFromObj\fR returns \fBTCL_OK\fR
+and stores the boolean value in the address given by \fIboolPtr\fR.
+If the object is not already a boolean object,
+the conversion will free any old internal representation.

 .SH "SEE ALSO"
-Tcl_NewObj, Tcl_IsShared, Tcl_GetBoolean
+Tcl_NewObj, Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_GetObjResult

 .SH KEYWORDS
-boolean, object
+boolean, boolean object, boolean type, internal representation, object, object type, string representation
@@ -4,6 +4,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: ByteArrObj.3,v 1.3 2001/04/04 16:07:20 kennykb Exp $
+'\" 
 .so man.macros
 .TH Tcl_ByteArrayObj 3 8.1 Tcl "Tcl Library Procedures"
 .BS
@@ -25,8 +27,8 @@ unsigned char *
 unsigned char *
 \fBTcl_SetByteArrayLength\fR(\fIobjPtr, length\fR)
 .SH ARGUMENTS
-.AS "const unsigned char" *lengthPtr in/out
-.AP "const unsigned char" *bytes in
+.AS "unsigned char" *lengthPtr in/out
+.AP "CONST unsigned char" *bytes in
 The array of bytes used to initialize or set a byte-array object.
 .AP int length in
 The length of the array of bytes.  It must be >= 0.
@@ -48,7 +50,7 @@ results of binary IO operations or data structures created with the
 \fBbinary\fR command.  In Tcl, an array of bytes is not equivalent to a
 string.  Conceptually, a string is an array of Unicode characters, while a
 byte-array is an array of 8-bit quantities with no implicit meaning.
-Accessor functions are provided to get the string representation of a
+Accesser functions are provided to get the string representation of a
 byte-array or to convert an arbitrary object to a byte-array.  Obtaining the
 string representation of a byte-array object (by calling
 \fBTcl_GetStringFromObj\fR) produces a properly formed UTF-8 sequence with a
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CallDel.3,v 1.2 1998/09/14 18:39:46 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_CallWhenDeleted 3 7.0 Tcl "Tcl Library Procedures"
 .BS
@@ -38,8 +40,8 @@ time of the call.
 type \fBTcl_InterpDeleteProc\fR:
 .CS
 typedef void Tcl_InterpDeleteProc(
-        ClientData \fIclientData\fR,
-        Tcl_Interp *\fIinterp\fR);
+	ClientData \fIclientData\fR,
+	Tcl_Interp *\fIinterp\fR);
 .CE
 The \fIclientData\fR and \fIinterp\fR parameters are
 copies of the \fIclientData\fR and \fIinterp\fR arguments given
@@ -51,7 +53,7 @@ interpreter is about to go away.
 .PP
 \fBTcl_DontCallWhenDeleted\fR cancels a previous call to
 \fBTcl_CallWhenDeleted\fR with the same arguments, so that
-\fIproc\fR will not be called after all when \fIinterp\fR is
+\fIproc\fR won't be called after all when \fIinterp\fR is
 deleted.
 If there is no deletion callback that matches \fIinterp\fR,
 \fIproc\fR, and \fIclientData\fR then the call to
@@ -3,12 +3,14 @@
 '\"
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+'\"
+'\" RCS: @(#) $Id: ChnlStack.3,v 1.4 2002/01/23 21:22:06 andreas_kupries Exp $
 .so man.macros
 .TH Tcl_StackChannel 3 8.3 Tcl "Tcl Library Procedures"
 .BS
 '\" Note:  do not modify the .SH NAME line immediately below!
 .SH NAME
-Tcl_StackChannel, Tcl_UnstackChannel, Tcl_GetStackedChannel, Tcl_GetTopChannel \- manipulate stacked I/O channels
+Tcl_StackChannel, Tcl_UnstackChannel, Tcl_GetStackedChannel, Tcl_GetTopChannel \- stack an I/O channel on top of another, and undo it
 .SH SYNOPSIS
 .nf
 .nf
@@ -27,17 +29,17 @@ Tcl_Channel
 \fBTcl_GetTopChannel\fR(\fIchannel\fR)
 .sp
 .SH ARGUMENTS
-.AS Tcl_ChannelType clientData
+.AS Tcl_ChannelType
 .AP Tcl_Interp *interp in
-Interpreter for error reporting.
+Interpreter for error reporting - can be NULL.
 .AP Tcl_ChannelType *typePtr in
-The new channel I/O procedures to use for \fIchannel\fR.
+The new channel I/O procedures to use for \fIchannel\fP.
 .AP ClientData clientData in
 Arbitrary one-word value to pass to channel I/O procedures.
 .AP int mask in
 Conditions under which \fIchannel\fR will be used: OR-ed combination of
 \fBTCL_READABLE\fR, \fBTCL_WRITABLE\fR and \fBTCL_EXCEPTION\fR.
-This can be a subset of the operations currently allowed on \fIchannel\fR.
+This can be a subset of the operations currently allowed on \fIchannel\fP.
 .AP Tcl_Channel channel in
 An existing Tcl channel such as returned by \fBTcl_CreateChannel\fR.
 .BE
@@ -55,9 +57,9 @@ stacked channels.  Anyone using stacked channels or creating stacked
 channel drivers should update to the new \fBTCL_CHANNEL_VERSION_2\fR
 \fBTcl_ChannelType\fR structure.  See \fBTcl_CreateChannel\fR for details.
 .PP
-\fBTcl_StackChannel\fR stacks a new \fIchannel\fR on an existing channel
-with the same name that was registered for \fIchannel\fR by
-\fBTcl_RegisterChannel\fR.
+\fBTcl_StackChannel\fR stacks a new \fIchannel\fP on an existing channel
+with the same name that was registered for \fIchannel\fP by
+\fBTcl_RegisterChannel\fP.
 .PP
 \fBTcl_StackChannel\fR works by creating a new channel structure and
 placing itself on top of the channel stack.  EOL translation, encoding and
@@ -68,7 +70,7 @@ remain at the top of the channel stack.  A pointer to the new top channel
 structure is returned.  If an error occurs when stacking the channel, NULL
 is returned instead.
 .PP
-The \fImask\fR parameter specifies the operations that are allowed on the
+The \fImask\fP parameter specifies the operations that are allowed on the
 new channel.  These can be a subset of the operations allowed on the
 original channel.  For example, a read-write channel may become read-only
 after the \fBTcl_StackChannel\fR call.
@@ -77,10 +79,10 @@ Closing a channel closes the channels stacked below it.  The close of
 stacked channels is executed in a way that allows buffered data to be
 properly flushed.
 .PP
-\fBTcl_UnstackChannel\fR reverses the process.  The old channel is
+\fBTcl_UnstackChannel\fP reverses the process.  The old channel is
 associated with the channel name, and the processing module added by
 \fBTcl_StackChannel\fR is destroyed.  If there is no old channel, then
-\fBTcl_UnstackChannel\fR is equivalent to \fBTcl_Close\fR.  If an error
+\fBTcl_UnstackChannel\fP is equivalent to \fBTcl_Close\fP.  If an error
 occurs unstacking the channel, \fBTCL_ERROR\fR is returned, otherwise
 \fBTCL_OK\fR is returned.
 .PP
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CmdCmplt.3,v 1.2 1998/09/14 18:39:46 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_CommandComplete 3 "" Tcl "Tcl Library Procedures"
 .BS
@@ -17,8 +19,8 @@ Tcl_CommandComplete \- Check for unmatched braces in a Tcl command
 int
 \fBTcl_CommandComplete\fR(\fIcmd\fR)
 .SH ARGUMENTS
-.AS "const char" *cmd
-.AP "const char" *cmd in
+.AS char *cmd
+.AP char *cmd in
 Command string to test for completeness.
 .BE

@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Concat.3,v 1.3 2001/09/24 21:10:32 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_Concat 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -14,13 +16,12 @@ Tcl_Concat \- concatenate a collection of strings
 .nf
 \fB#include <tcl.h>\fR
 .sp
-const char *
+char *
 \fBTcl_Concat\fR(\fIargc, argv\fR)
 .SH ARGUMENTS
-.AS "const char *const" argv[]
 .AP int argc in
 Number of strings.
-.AP "const char *const" argv[] in
+.AP "char * CONST" argv[] in
 Array of strings to concatenate.  Must have \fIargc\fR entries.
 .BE

@@ -42,9 +43,12 @@ copies strings from \fBargv\fR to the result.  If an element of
 is ignored entirely.  This white-space removal was added to make
 the output of the \fBconcat\fR command cleaner-looking.
 .PP
+.VS
 The result string is dynamically allocated
 using \fBTcl_Alloc\fR;  the caller must eventually release the space
 by calling \fBTcl_Free\fR.
+.VE
+.VS
 .SH "SEE ALSO"
 Tcl_ConcatObj
 .SH KEYWORDS
@@ -4,12 +4,14 @@
 '\"
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+'\"
+'\" RCS: @(#) $Id: CrtChannel.3,v 1.14 2002/01/23 21:22:06 andreas_kupries Exp $
 .so man.macros
-.TH Tcl_CreateChannel 3 8.4 Tcl "Tcl Library Procedures"
+.TH Tcl_CreateChannel 3 8.3 Tcl "Tcl Library Procedures"
 .BS
 '\" Note:  do not modify the .SH NAME line immediately below!
 .SH NAME
-Tcl_CreateChannel, Tcl_GetChannelInstanceData, Tcl_GetChannelType, Tcl_GetChannelName, Tcl_GetChannelHandle, Tcl_GetChannelMode, Tcl_GetChannelBufferSize, Tcl_SetChannelBufferSize, Tcl_NotifyChannel, Tcl_BadChannelOption, Tcl_ChannelName, Tcl_ChannelVersion, Tcl_ChannelBlockModeProc, Tcl_ChannelCloseProc, Tcl_ChannelClose2Proc, Tcl_ChannelInputProc, Tcl_ChannelOutputProc, Tcl_ChannelSeekProc, Tcl_ChannelWideSeekProc, Tcl_ChannelTruncateProc, Tcl_ChannelSetOptionProc, Tcl_ChannelGetOptionProc, Tcl_ChannelWatchProc, Tcl_ChannelGetHandleProc, Tcl_ChannelFlushProc, Tcl_ChannelHandlerProc, Tcl_ChannelThreadActionProc, Tcl_IsChannelShared, Tcl_IsChannelRegistered, Tcl_CutChannel, Tcl_SpliceChannel, Tcl_IsChannelExisting, Tcl_ClearChannelHandlers, Tcl_GetChannelThread, Tcl_ChannelBuffered \- procedures for creating and manipulating channels
+Tcl_CreateChannel, Tcl_GetChannelInstanceData, Tcl_GetChannelType, Tcl_GetChannelName, Tcl_GetChannelHandle, Tcl_GetChannelMode, Tcl_GetChannelBufferSize, Tcl_SetChannelBufferSize, Tcl_NotifyChannel, Tcl_BadChannelOption, Tcl_ChannelName, Tcl_ChannelVersion, Tcl_ChannelBlockModeProc, Tcl_ChannelCloseProc, Tcl_ChannelClose2Proc, Tcl_ChannelInputProc, Tcl_ChannelOutputProc, Tcl_ChannelSeekProc, Tcl_ChannelSetOptionProc, Tcl_ChannelGetOptionProc, Tcl_ChannelWatchProc, Tcl_ChannelGetHandleProc, Tcl_ChannelFlushProc, Tcl_ChannelHandlerProc, Tcl_IsChannelShared, Tcl_IsChannelRegistered, Tcl_CutChannel, Tcl_SpliceChannel, Tcl_IsChannelExisting, Tcl_ClearChannelHandlers, Tcl_GetChannelThread, Tcl_ChannelBuffered \- procedures for creating and manipulating channels
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -23,17 +25,16 @@ ClientData
 Tcl_ChannelType *
 \fBTcl_GetChannelType\fR(\fIchannel\fR)
 .sp
-const char *
+CONST char *
 \fBTcl_GetChannelName\fR(\fIchannel\fR)
 .sp
 int
 \fBTcl_GetChannelHandle\fR(\fIchannel, direction, handlePtr\fR)
 .sp
+.VS 8.4
 Tcl_ThreadId
 \fBTcl_GetChannelThread\fR(\fIchannel\fR)
-.sp
-int
-\fBTcl_GetChannelMode\fR(\fIchannel\fR)
+.VE
 .sp
 int
 \fBTcl_GetChannelBufferSize\fR(\fIchannel\fR)
@@ -44,6 +45,7 @@ int
 .sp
 int
 \fBTcl_BadChannelOption\fR(\fIinterp, optionName, optionList\fR)
+.VS 8.4
 .sp
 int
 \fBTcl_IsChannelShared\fR(\fIchannel\fR)
@@ -62,11 +64,13 @@ void
 .sp
 void
 \fBTcl_ClearChannelHandlers\fR(\fIchannel\fR)
+.VE
+.VS 8.3.2
 .sp
 int
 \fBTcl_ChannelBuffered\fR(\fIchannel\fR)
 .sp
-const char *
+CONST char *
 \fBTcl_ChannelName\fR(\fItypePtr\fR)
 .sp
 Tcl_ChannelTypeVersion
@@ -90,17 +94,6 @@ Tcl_DriverOutputProc *
 Tcl_DriverSeekProc *
 \fBTcl_ChannelSeekProc\fR(\fItypePtr\fR)
 .sp
-Tcl_DriverWideSeekProc *
-\fBTcl_ChannelWideSeekProc\fR(\fItypePtr\fR)
-.sp
-Tcl_DriverThreadActionProc *
-\fBTcl_ChannelThreadActionProc\fR(\fItypePtr\fR)
-.sp
-.VS 8.5
-Tcl_DriverTruncateProc *
-\fBTcl_ChannelTruncateProc\fR(\fItypePtr\fR)
-.VE 8.5
-.sp
 Tcl_DriverSetOptionProc *
 \fBTcl_ChannelSetOptionProc\fR(\fItypePtr\fR)
 .sp
@@ -118,13 +111,14 @@ Tcl_DriverFlushProc *
 .sp
 Tcl_DriverHandlerProc *
 \fBTcl_ChannelHandlerProc\fR(\fItypePtr\fR)
+.VE
 .sp
 .SH ARGUMENTS
-.AS "const Tcl_ChannelType" *channelName
-.AP "const Tcl_ChannelType" *typePtr in
+.AS Tcl_ChannelType *channelName in
+.AP Tcl_ChannelType *typePtr in
 Points to a structure containing the addresses of procedures that
 can be called to perform I/O and other functions on the channel.
-.AP "const char" *channelName in
+.AP "CONST char" *channelName in
 The name of this channel, such as \fBfile3\fR; must not be in use
 by any other channel. Can be NULL, in which case the channel is
 created without a name.
@@ -150,11 +144,10 @@ and \fBTCL_EXCEPTION\fR that indicates events that have occurred on
 this channel.
 .AP Tcl_Interp *interp in
 Current interpreter. (can be NULL)
-.AP "const char" *optionName in
+.AP "CONST char" *optionName in
 Name of the invalid option.
-.AP "const char" *optionList in
-Specific options list (space separated words, without
-.QW \- )
+.AP "CONST char" *optionList in
+Specific options list (space separated words, without "-") 
 to append to the standard generic options list.
 Can be NULL for generic options error message only.

@@ -178,7 +171,7 @@ driver provides a \fBTcl_ChannelType\fR structure containing pointers to
 functions implementing the various operations used by the generic layer to
 communicate with the channel driver. The \fBTcl_ChannelType\fR structure
 and the functions referenced by it are described in the section
-\fBTCL_CHANNELTYPE\fR, below.
+TCL_CHANNELTYPE, below.
 .PP
 Second, channel drivers usually provide a Tcl command to create
 instances of that type of channel. For example, the Tcl \fBopen\fR
@@ -205,7 +198,7 @@ structure to perform operations on the channel.
 \fItypePtr\fR and \fIinstanceData\fR with it. The channel is opened in the
 mode indicated by \fImask\fR.
 For a discussion of channel drivers, their operations and the
-\fBTcl_ChannelType\fR structure, see the section \fBTCL_CHANNELTYPE\fR, below.
+\fBTcl_ChannelType\fR structure, see the section TCL_CHANNELTYPE, below.
 .PP
 \fBTcl_CreateChannel\fR interacts with the code managing the standard
 channels. Once a standard channel was initialized either through a
@@ -236,10 +229,12 @@ the channel does not have a device handle for the specified direction,
 then \fBTCL_ERROR\fR is returned instead.  Different channel drivers
 will return different types of handle.  Refer to the manual entries
 for each driver to determine what type of handle is returned.
+.VS 8.4
 .PP
 \fBTcl_GetChannelThread\fR returns the id of the thread currently managing
 the specified \fIchannel\fR. This allows channel drivers to send their file
 events to the correct event queue even for a multi-threaded core.
+.VE
 .PP
 \fBTcl_GetChannelMode\fR returns an OR-ed combination of \fBTCL_READABLE\fR
 and \fBTCL_WRITABLE\fR, indicating whether the channel is open for input
@@ -263,24 +258,27 @@ occurred on the channel.  Channel drivers are responsible for invoking
 this function whenever the channel handlers need to be called for the
 channel.  See \fBWATCHPROC\fR below for more details.
 .PP
-\fBTcl_BadChannelOption\fR is called from driver specific
-\fIsetOptionProc\fR or \fIgetOptionProc\fR to generate a complete
-error message.
+\fBTcl_BadChannelOption\fR is called from driver specific set or get option
+procs to generate a complete error message.
+.VE
 .PP
+.VS 8.3.2
 \fBTcl_ChannelBuffered\fR returns the number of bytes of input
 currently buffered in the internal buffer (push back area) of the
 channel itself. It does not report about the data in the overall
 buffers for the stack of channels the supplied channel is part of.
+.VE
 .PP
+.VS 8.4
 \fBTcl_IsChannelShared\fR checks the refcount of the specified
 \fIchannel\fR and returns whether the \fIchannel\fR was shared among
 multiple interpreters (result == 1) or not (result == 0).
 .PP
-\fBTcl_IsChannelRegistered\fR checks whether the specified \fIchannel\fR is
+\fBTcl_IsChannelRegistered\fR checks wether the specified \fIchannel\fR is
 registered in the given \fIinterp\fRreter (result == 1) or not
 (result == 0).
 .PP
-\fBTcl_IsChannelExisting\fR checks whether a channel with the specified
+\fBTcl_IsChannelExisting\fR checks wether a channel with the specified
 name is registered in the (thread)-global list of all channels (result
 == 1) or not (result == 0).
 .PP
@@ -288,68 +286,54 @@ name is registered in the (thread)-global list of all channels (result
 (thread)global list of all channels (of the current thread).
 Application to a channel still registered in some interpreter
 is not allowed.
-.VS 8.5
-Also notifies the driver if the \fBTcl_ChannelType\fR version is
-\fBTCL_CHANNEL_VERSION_4\fR (or higher), and
-\fBTcl_DriverThreadActionProc\fR is defined for it.
-.VE 8.5
 .PP
 \fBTcl_SpliceChannel\fR adds the specified \fIchannel\fR to the
 (thread)global list of all channels (of the current thread).
 Application to a channel registered in some interpreter is not allowed.
-.VS 8.5
-Also notifies the driver if the \fBTcl_ChannelType\fR version is
-\fBTCL_CHANNEL_VERSION_4\fR (or higher), and
-\fBTcl_DriverThreadActionProc\fR is defined for it.
-.VE 8.5
 .PP
-\fBTcl_ClearChannelHandlers\fR removes all channel handlers and event
+\fBTcl_ClearChannelHandlers\fR removes all channelhandlers and event
 scripts associated with the specified \fIchannel\fR, thus shutting
 down all event processing for this channel.
+.VE
+
 .SH TCL_CHANNELTYPE
 .PP
 A channel driver provides a \fBTcl_ChannelType\fR structure that contains
 pointers to functions that implement the various operations on a channel;
 these operations are invoked as needed by the generic layer.  The structure
 was versioned starting in Tcl 8.3.2/8.4 to correct a problem with stacked
-channel drivers.  See the \fBOLD CHANNEL TYPES\fR section below for
-details about the old structure.
+channel drivers.  See the \fBOLD_CHANNEL\fR section below for details about
+the old structure.
 .PP
 The \fBTcl_ChannelType\fR structure contains the following fields:
 .CS
 typedef struct Tcl_ChannelType {
-        char *\fItypeName\fR;
-        Tcl_ChannelTypeVersion \fIversion\fR;
-        Tcl_DriverCloseProc *\fIcloseProc\fR;
-        Tcl_DriverInputProc *\fIinputProc\fR;
-        Tcl_DriverOutputProc *\fIoutputProc\fR;
-        Tcl_DriverSeekProc *\fIseekProc\fR;
-        Tcl_DriverSetOptionProc *\fIsetOptionProc\fR;
-        Tcl_DriverGetOptionProc *\fIgetOptionProc\fR;
-        Tcl_DriverWatchProc *\fIwatchProc\fR;
-        Tcl_DriverGetHandleProc *\fIgetHandleProc\fR;
-        Tcl_DriverClose2Proc *\fIclose2Proc\fR;
-        Tcl_DriverBlockModeProc *\fIblockModeProc\fR;
-        Tcl_DriverFlushProc *\fIflushProc\fR;
-        Tcl_DriverHandlerProc *\fIhandlerProc\fR;
-        Tcl_DriverWideSeekProc *\fIwideSeekProc\fR;
-        Tcl_DriverThreadActionProc *\fIthreadActionProc\fR;
-.VS 8.5
-        Tcl_DriverTruncateProc *\fItruncateProc\fR;
-.VE 8.5
+	char *\fItypeName\fR;
+	Tcl_ChannelTypeVersion \fIversion\fR;
+	Tcl_DriverCloseProc *\fIcloseProc\fR;
+	Tcl_DriverInputProc *\fIinputProc\fR;
+	Tcl_DriverOutputProc *\fIoutputProc\fR;
+	Tcl_DriverSeekProc *\fIseekProc\fR;
+	Tcl_DriverSetOptionProc *\fIsetOptionProc\fR;
+	Tcl_DriverGetOptionProc *\fIgetOptionProc\fR;
+	Tcl_DriverWatchProc *\fIwatchProc\fR;
+	Tcl_DriverGetHandleProc *\fIgetHandleProc\fR;
+	Tcl_DriverClose2Proc *\fIclose2Proc\fR;
+	Tcl_DriverBlockModeProc *\fIblockModeProc\fR;	
+	Tcl_DriverFlushProc *\fIflushProc\fR;	
+	Tcl_DriverHandlerProc *\fIhandlerProc\fR;	
 } Tcl_ChannelType;
 .CE
 .PP
-It is not necessary to provide implementations for all channel
-operations.  Those which are not necessary may be set to NULL in the
-struct: \fIblockModeProc\fR, \fIseekProc\fR, \fIsetOptionProc\fR,
-\fIgetOptionProc\fR, and \fIclose2Proc\fR, in addition to
-\fIflushProc\fR, \fIhandlerProc\fR, \fIthreadActionProc\fR, and
-\fItruncateProc\fR.  Other functions that cannot be implemented in a
-meaningful way should return \fBEINVAL\fR when called, to indicate
-that the operations they represent are not available. Also note that
-\fIwideSeekProc\fR can be NULL if \fIseekProc\fR is.
+The driver must provide implementations for all functions except
+\fIblockModeProc\fR, \fIseekProc\fR, \fIsetOptionProc\fR,
+\fIgetOptionProc\fR, and \fIclose2Proc\fR, which may be specified as
+NULL.  Other functions that can not be implemented for this type of
+device should return \fBEINVAL\fR when invoked to indicate that they
+are not implemented, except in the case of \fIflushProc\fR and
+\fIhandlerProc\fR, which should specified as NULL if not otherwise defined.
 .PP
+.VS 8.3.2
 The user should only use the above structure for \fBTcl_ChannelType\fR
 instantiation.  When referencing fields in a \fBTcl_ChannelType\fR
 structure, the following functions should be used to obtain the values:
@@ -357,54 +341,42 @@ structure, the following functions should be used to obtain the values:
 \fBTcl_ChannelBlockModeProc\fR, \fBTcl_ChannelCloseProc\fR,
 \fBTcl_ChannelClose2Proc\fR, \fBTcl_ChannelInputProc\fR,
 \fBTcl_ChannelOutputProc\fR, \fBTcl_ChannelSeekProc\fR,
-\fBTcl_ChannelWideSeekProc\fR, \fBTcl_ChannelThreadActionProc\fR,
-.VS 8.5
-\fBTcl_ChannelTruncateProc\fR,
-.VE 8.5
 \fBTcl_ChannelSetOptionProc\fR, \fBTcl_ChannelGetOptionProc\fR,
 \fBTcl_ChannelWatchProc\fR, \fBTcl_ChannelGetHandleProc\fR,
 \fBTcl_ChannelFlushProc\fR, or \fBTcl_ChannelHandlerProc\fR.
 .PP
 The change to the structures was made in such a way that standard channel
 types are binary compatible.  However, channel types that use stacked
-channels (i.e. TLS, Trf) have new versions to correspond to the above change
+channels (ie: TLS, Trf) have new versions to correspond to the above change
 since the previous code for stacked channels had problems.
-.SS TYPENAME
+.VE
+
+.SH TYPENAME
 .PP
 The \fItypeName\fR field contains a null-terminated string that
 identifies the type of the device implemented by this driver, e.g.
 \fBfile\fR or \fBsocket\fR.
 .PP
+.VS 8.3.2
 This value can be retrieved with \fBTcl_ChannelName\fR, which returns
 a pointer to the string.
-.SS VERSION
-.PP
+.VE

-The \fIversion\fR field should be set to the version of the structure
-that you require. \fBTCL_CHANNEL_VERSION_2\fR is the minimum recommended.
-\fBTCL_CHANNEL_VERSION_3\fR must be set to specify the \fIwideSeekProc\fR member.
-\fBTCL_CHANNEL_VERSION_4\fR must be set to specify the \fIthreadActionProc\fR member
-(includes \fIwideSeekProc\fR).
-.VS 8.5
-\fBTCL_CHANNEL_VERSION_5\fR must be set to specify the
-\fItruncateProc\fR members (includes
-\fIwideSeekProc\fR and \fIthreadActionProc\fR).
-.VE 8.5
-If it is not set to any of these, then this
-\fBTcl_ChannelType\fR is assumed to have the original structure.  See
-\fBOLD CHANNEL TYPES\fR for more details.  While Tcl will recognize
-and function with either structures, stacked channels must be of at
-least \fBTCL_CHANNEL_VERSION_2\fR to function correctly.
+.VS 8.3.2
+.SH VERSION
+.PP
+The \fIversion\fR field should be set to \fBTCL_CHANNEL_VERSION_2\fR.
+If it is not set to this value \fBTCL_CHANNEL_VERSION_2\fR, then this
+\fBTcl_ChannelType\fR is assumed to have the older structure.  See
+\fBOLD_CHANNEL\fR for more details.  While Tcl will recognize and
+function with either structure, stacked channels must be of the newer
+style to function correctly.
 .PP
 This value can be retrieved with \fBTcl_ChannelVersion\fR, which returns
-one of
-.VS 8.5
-\fBTCL_CHANNEL_VERSION_5\fR,
-.VE 8.5
-\fBTCL_CHANNEL_VERSION_4\fR,
-\fBTCL_CHANNEL_VERSION_3\fR,
-\fBTCL_CHANNEL_VERSION_2\fR or \fBTCL_CHANNEL_VERSION_1\fR.
-.SS BLOCKMODEPROC
+either \fBTCL_CHANNEL_VERSION_2\fR or \fBTCL_CHANNEL_VERSION_1\fR.
+.VE
+
+.SH BLOCKMODEPROC
 .PP
 The \fIblockModeProc\fR field contains the address of a function called by
 the generic layer to set blocking and nonblocking mode on the device.
@@ -412,8 +384,8 @@ the generic layer to set blocking and nonblocking mode on the device.
 .PP
 .CS
 typedef int Tcl_DriverBlockModeProc(
-        ClientData \fIinstanceData\fR,
-        int \fImode\fR);
+	ClientData \fIinstanceData\fR,
+	int \fImode\fR);
 .CE
 .PP
 The \fIinstanceData\fR is the same as the value passed to
@@ -430,16 +402,12 @@ For some device types, the blocking and nonblocking behavior can be
 implemented by the underlying operating system; for other device types, the
 behavior must be emulated in the channel driver.
 .PP
+.VS 8.3.2
 This value can be retrieved with \fBTcl_ChannelBlockModeProc\fR, which returns
 a pointer to the function.
-.PP
-A channel driver \fBnot\fR supplying a \fIblockModeProc\fR has to be
-very, very careful. It has to tell the generic layer exactly which
-blocking mode is acceptable to it, and should this also document for
-the user so that the blocking mode of the channel is not changed to an
-unacceptable value. Any confusion here may lead the interpreter into a
-(spurious and difficult to find) deadlock.
-.SS "CLOSEPROC AND CLOSE2PROC"
+.VE
+
+.SH "CLOSEPROC AND CLOSE2PROC"
 .PP
 The \fIcloseProc\fR field contains the address of a function called by the
 generic layer to clean up driver-related information when the channel is
@@ -447,8 +415,8 @@ closed. \fICloseProc\fR must match the following prototype:
 .PP
 .CS
 typedef int Tcl_DriverCloseProc(
-        ClientData \fIinstanceData\fR,
-        Tcl_Interp *\fIinterp\fR);
+	ClientData \fIinstanceData\fR,
+	Tcl_Interp *\fIinterp\fR);
 .CE
 .PP
 The \fIinstanceData\fR argument is the same as the value provided to
@@ -469,9 +437,9 @@ following prototype:
 .PP
 .CS
 typedef int Tcl_DriverClose2Proc(
-        ClientData \fIinstanceData\fR,
-        Tcl_Interp *\fIinterp\fR,
-        int \fIflags\fR);
+	ClientData \fIinstanceData\fR,
+	Tcl_Interp *\fIinterp\fR,
+	int \fIflags\fR);
 .CE
 .PP
 The \fIclose2Proc\fR will be called with \fIflags\fR set to an OR'ed
@@ -489,10 +457,13 @@ return a nonzero POSIX error code. In addition, if an error occurs and
 \fIinterp\fR is not NULL, the procedure should store an error message
 in the interpreter's result.
 .PP
-The \fIcloseProc\fR and \fIclose2Proc\fR values can be retrieved with
-\fBTcl_ChannelCloseProc\fR or \fBTcl_ChannelClose2Proc\fR, which
-return a pointer to the respective function.
-.SS INPUTPROC
+.VS 8.3.2
+These value can be retrieved with \fBTcl_ChannelCloseProc\fR or
+\fBTcl_ChannelClose2Proc\fR, which returns a pointer to the respective
+function.
+.VE
+
+.SH INPUTPROC
 .PP
 The \fIinputProc\fR field contains the address of a function called by the
 generic layer to read data from the file or device and store it in an
@@ -500,10 +471,10 @@ internal buffer. \fIInputProc\fR must match the following prototype:
 .PP
 .CS
 typedef int Tcl_DriverInputProc(
-        ClientData \fIinstanceData\fR,
-        char *\fIbuf\fR,
-        int \fIbufSize\fR,
-        int *\fIerrorCodePtr\fR);
+	ClientData \fIinstanceData\fR,
+	char *\fIbuf\fR,
+	int \fIbufSize\fR,
+	int *\fIerrorCodePtr\fR);
 .CE
 .PP
 \fIInstanceData\fR is the same as the value passed to
@@ -534,9 +505,12 @@ for the shortest possible time until at least one byte of data can be read
 from the device; then, it should return as much data as it can read without
 blocking.
 .PP
+.VS 8.3.2
 This value can be retrieved with \fBTcl_ChannelInputProc\fR, which returns
 a pointer to the function.
-.SS OUTPUTPROC
+.VE
+
+.SH OUTPUTPROC
 .PP
 The \fIoutputProc\fR field contains the address of a function called by the
 generic layer to transfer data from an internal buffer to the output device.
@@ -544,10 +518,10 @@ generic layer to transfer data from an internal buffer to the output device.
 .PP
 .CS
 typedef int Tcl_DriverOutputProc(
-        ClientData \fIinstanceData\fR,
-        const char *\fIbuf\fR,
-        int \fItoWrite\fR,
-        int *\fIerrorCodePtr\fR);
+	ClientData \fIinstanceData\fR,
+	CONST char *\fIbuf\fR,
+	int \fItoWrite\fR,
+	int *\fIerrorCodePtr\fR);
 .CE
 .PP
 \fIInstanceData\fR is the same as the value passed to
@@ -572,9 +546,12 @@ If the channel is nonblocking and the output device is unable to absorb any
 data whatsoever, the function should return -1 with an \fBEAGAIN\fR error
 without writing any data.
 .PP
+.VS 8.3.2
 This value can be retrieved with \fBTcl_ChannelOutputProc\fR, which returns
 a pointer to the function.
-.SS "SEEKPROC AND WIDESEEKPROC"
+.VE
+
+.SH SEEKPROC
 .PP
 The \fIseekProc\fR field contains the address of a function called by the
 generic layer to move the access point at which subsequent input or output
@@ -583,10 +560,10 @@ prototype:
 .PP
 .CS
 typedef int Tcl_DriverSeekProc(
-        ClientData \fIinstanceData\fR,
-        long \fIoffset\fR,
-        int \fIseekMode\fR,
-        int *\fIerrorCodePtr\fR);
+	ClientData \fIinstanceData\fR,
+	long \fIoffset\fR,
+	int \fIseekMode\fR,
+	int *\fIerrorCodePtr\fR);
 .CE
 .PP
 The \fIinstanceData\fR argument is the same as the value given to
@@ -603,31 +580,12 @@ does not implement seeking.
 The return value is the new access point or -1 in case of error. If an
 error occurred, the function should not move the access point.
 .PP
-If there is a non-NULL \fIseekProc\fR field, the \fIwideSeekProc\fR
-field may contain the address of an alternative function to use which
-handles wide (i.e. larger than 32-bit) offsets, so allowing seeks
-within files larger than 2GB.  The \fIwideSeekProc\fR will be called
-in preference to the \fIseekProc\fR, but both must be defined if the
-\fIwideSeekProc\fR is defined.  \fIWideSeekProc\fR must match the
-following prototype:
-.PP
-.CS
-typedef Tcl_WideInt Tcl_DriverWideSeekProc(
-        ClientData \fIinstanceData\fR,
-        Tcl_WideInt \fIoffset\fR,
-        int \fIseekMode\fR,
-        int *\fIerrorCodePtr\fR);
-.CE
-.PP
-The arguments and return values mean the same thing as with
-\fIseekProc\fR above, except that the type of offsets and the return
-type are different.
-.PP
-The \fIseekProc\fR value can be retrieved with
-\fBTcl_ChannelSeekProc\fR, which returns a pointer to the function,
-and similarly the \fIwideSeekProc\fR can be retrieved with
-\fBTcl_ChannelWideSeekProc\fR.
-.SS SETOPTIONPROC
+.VS 8.3.2
+This value can be retrieved with \fBTcl_ChannelSeekProc\fR, which returns
+a pointer to the function.
+.VE
+
+.SH SETOPTIONPROC
 .PP
 The \fIsetOptionProc\fR field contains the address of a function called by
 the generic layer to set a channel type specific option on a channel.
@@ -635,10 +593,10 @@ the generic layer to set a channel type specific option on a channel.
 .PP
 .CS
 typedef int Tcl_DriverSetOptionProc(
-        ClientData \fIinstanceData\fR,
-        Tcl_Interp *\fIinterp\fR,
-        const char *\fIoptionName\fR,
-        const char *\fInewValue\fR);
+	ClientData \fIinstanceData\fR,
+	Tcl_Interp *\fIinterp\fR,
+	CONST char *\fIoptionName\fR,
+	CONST char *\fInewValue\fR);
 .CE
 .PP
 \fIoptionName\fR is the name of an option to set, and \fInewValue\fR is
@@ -648,7 +606,7 @@ created. The function should do whatever channel type specific action is
 required to implement the new value of the option.
 .PP
 Some options are handled by the generic code and this function is never
-called to set them, e.g. \fB\-blockmode\fR. Other options are specific to
+called to set them, e.g. \fB-blockmode\fR. Other options are specific to
 each channel type and the \fIsetOptionProc\fR procedure of the channel
 driver will get called to implement them. The \fIsetOptionProc\fR field can
 be NULL, which indicates that this channel type supports no type specific
@@ -666,9 +624,12 @@ the function should leave an error message in the
 function should also call \fBTcl_SetErrno\fR to store an appropriate POSIX
 error code.
 .PP
+.VS 8.3.2
 This value can be retrieved with \fBTcl_ChannelSetOptionProc\fR, which returns
 a pointer to the function.
-.SS GETOPTIONPROC
+.VE
+
+.SH GETOPTIONPROC
 .PP
 The \fIgetOptionProc\fR field contains the address of a function called by
 the generic layer to get the value of a channel type specific option on a
@@ -676,10 +637,10 @@ channel. \fIgetOptionProc\fR must match the following prototype:
 .PP
 .CS
 typedef int Tcl_DriverGetOptionProc(
-        ClientData \fIinstanceData\fR,
-        Tcl_Interp *\fIinterp\fR,
-        const char *\fIoptionName\fR,
-        Tcl_DString *\fIoptionValue\fR);
+	ClientData \fIinstanceData\fR,
+	Tcl_Interp *\fIinterp\fR,
+	CONST char *\fIoptionName\fR,
+	Tcl_DString *\fIoptionValue\fR);
 .CE
 .PP
 \fIOptionName\fR is the name of an option supported by this type of
@@ -697,15 +658,18 @@ function should also call \fBTcl_SetErrno\fR to store an appropriate POSIX
 error code.
 .PP
 Some options are handled by the generic code and this function is never
-called to retrieve their value, e.g. \fB\-blockmode\fR. Other options are
+called to retrieve their value, e.g. \fB-blockmode\fR. Other options are
 specific to each channel type and the \fIgetOptionProc\fR procedure of the
 channel driver will get called to implement them. The \fIgetOptionProc\fR
 field can be NULL, which indicates that this channel type supports no type
 specific options.
 .PP
+.VS 8.3.2
 This value can be retrieved with \fBTcl_ChannelGetOptionProc\fR, which returns
 a pointer to the function.
-.SS WATCHPROC
+.VE
+
+.SH WATCHPROC
 .PP
 The \fIwatchProc\fR field contains the address of a function called
 by the generic layer to initialize the event notification mechanism to
@@ -714,8 +678,8 @@ notice events of interest on this channel.
 .PP
 .CS
 typedef void Tcl_DriverWatchProc(
-        ClientData \fIinstanceData\fR,
-        int \fImask\fR);
+	ClientData \fIinstanceData\fR,
+	int \fImask\fR);
 .CE
 .PP
 The \fIinstanceData\fR is the same as the value passed to
@@ -735,9 +699,12 @@ the Tcl event queue to allow the channel event to be scheduled in sequence
 with other events.  See the description of \fBTcl_QueueEvent\fR for
 details on how to queue an event.
 .PP
+.VS 8.3.2
 This value can be retrieved with \fBTcl_ChannelWatchProc\fR, which returns
 a pointer to the function.
-.SS GETHANDLEPROC
+.VE
+
+.SH GETHANDLEPROC
 .PP
 The \fIgetHandleProc\fR field contains the address of a function called by
 the generic layer to retrieve a device-specific handle from the channel.
@@ -745,9 +712,9 @@ the generic layer to retrieve a device-specific handle from the channel.
 .PP
 .CS
 typedef int Tcl_DriverGetHandleProc(
-        ClientData \fIinstanceData\fR,
-        int \fIdirection\fR,
-        ClientData *\fIhandlePtr\fR);
+	ClientData \fIinstanceData\fR,
+	int \fIdirection\fR,
+	ClientData *\fIhandlePtr\fR);
 .CE
 .PP
 \fIInstanceData\fR is the same as the value passed to
@@ -764,9 +731,13 @@ stored in the location referred to by \fIhandlePtr\fR, and
 specified direction, or if the channel implementation does not use
 device handles, the function should return \fBTCL_ERROR\fR.
 .PP
+.VS 8.3.2
 This value can be retrieved with \fBTcl_ChannelGetHandleProc\fR, which returns
 a pointer to the function.
-.SS FLUSHPROC
+.VE
+
+.VS 8.3.2
+.SH FLUSHPROC
 .PP
 The \fIflushProc\fR field is currently reserved for future use.
 It should be set to NULL.
@@ -774,132 +745,80 @@ It should be set to NULL.
 .PP
 .CS
 typedef int Tcl_DriverFlushProc(
-        ClientData \fIinstanceData\fR);
+	ClientData \fIinstanceData\fR);
 .CE
 .PP
 This value can be retrieved with \fBTcl_ChannelFlushProc\fR, which returns
 a pointer to the function.
-.SS HANDLERPROC
+
+.SH HANDLERPROC
 .PP
 The \fIhandlerProc\fR field contains the address of a function called by
-the generic layer to notify the channel that an event occurred.  It should
+the generic layer to notify the channel that an event occured.  It should
 be defined for stacked channel drivers that wish to be notified of events
 that occur on the underlying (stacked) channel.
 \fIHandlerProc\fR should match the following prototype:
 .PP
 .CS
 typedef int Tcl_DriverHandlerProc(
-        ClientData \fIinstanceData\fR,
-        int \fIinterestMask\fR);
+	ClientData \fIinstanceData\fR,
+	int \fIinterestMask\fR);
 .CE
 .PP
 \fIInstanceData\fR is the same as the value passed to \fBTcl_CreateChannel\fR
 when this channel was created.  The \fIinterestMask\fR is an OR-ed
 combination of \fBTCL_READABLE\fR or \fBTCL_WRITABLE\fR; it indicates what
-type of event occurred on this channel.
+type of event occured on this channel.
 .PP
 This value can be retrieved with \fBTcl_ChannelHandlerProc\fR, which returns
 a pointer to the function.
+.VE

-.SS "THREADACTIONPROC"
-.PP
-The \fIthreadActionProc\fR field contains the address of the function
-called by the generic layer when a channel is created, closed, or
-going to move to a different thread, i.e. whenever thread-specific
-driver state might have to initialized or updated. It can be NULL.
-The action \fITCL_CHANNEL_THREAD_REMOVE\fR is used to notify the
-driver that it should update or remove any thread-specific data it
-might be maintaining for the channel.
-.PP
-The action \fITCL_CHANNEL_THREAD_INSERT\fR is used to notify the
-driver that it should update or initialize any thread-specific data it
-might be maintaining using the calling thread as the associate. See
-\fBTcl_CutChannel\fR and \fBTcl_SpliceChannel\fR for more detail.
-.PP
-.CS
-typedef void Tcl_DriverThreadActionProc(
-        ClientData \fIinstanceData\fR,
-        int        \fIaction\fR);
-.CE
-.PP
-\fIInstanceData\fR is the same as the value passed to
-\fBTcl_CreateChannel\fR when this channel was created.
-.PP
-These values can be retrieved with \fBTcl_ChannelThreadActionProc\fR,
-which returns a pointer to the function.
-.SS "TRUNCATEPROC"
-.PP
-The \fItruncateProc\fR field contains the address of the function
-called by the generic layer when a channel is truncated to some
-length. It can be NULL.
-.PP
-.CS
-typedef int Tcl_DriverTruncateProc(
-        ClientData \fIinstanceData\fR,
-        Tcl_WideInt \fIlength\fR);
-.CE
-.PP
-\fIInstanceData\fR is the same as the value passed to
-\fBTcl_CreateChannel\fR when this channel was created, and
-\fIlength\fR is the new length of the underlying file, which should
-not be negative. The result should be 0 on success or an errno code
-(suitable for use with \fBTcl_SetErrno\fR) on failure.
-.PP
-These values can be retrieved with \fBTcl_ChannelTruncateProc\fR,
-which returns a pointer to the function.
 .SH TCL_BADCHANNELOPTION
 .PP
-This procedure generates a
-.QW "bad option"
-error message in an
+This procedure generates a "bad option" error message in an
 (optional) interpreter.  It is used by channel drivers when 
-an invalid Set/Get option is requested. Its purpose is to concatenate
+a invalid Set/Get option is requested. Its purpose is to concatenate
 the generic options list to the specific ones and factorize
 the generic options error message string.
 .PP
-It always returns \fBTCL_ERROR\fR
+It always return \fBTCL_ERROR\fR
 .PP
 An error message is generated in \fIinterp\fR's result object to
-indicate that a command was invoked with a bad option.
+indicate that a command was invoked with the a bad option
 The message has the form
 .CS
    bad option "blah": should be one of 
    <...generic options...>+<...specific options...>
-.CE
 so you get for instance:
-.CS
    bad option "-blah": should be one of -blocking,
    -buffering, -buffersize, -eofchar, -translation,
    -peername, or -sockname
+when called with \fIoptionList\fR="peername sockname"
 .CE
-when called with \fIoptionList\fR equal to
-.QW "peername sockname"
-.PP
-.QW blah
-is the \fIoptionName\fR argument and
-.QW "<specific options>"
+``blah'' is the \fIoptionName\fR argument and ``<specific options>''
 is a space separated list of specific option words.
 The function takes good care of inserting minus signs before
-each option, commas after, and an
-.QW or
-before the last option.
-.SH "OLD CHANNEL TYPES"
+each option, commas after, and an ``or'' before the last option.
+
+.SH OLD_CHANNEL
+
 The original (8.3.1 and below) \fBTcl_ChannelType\fR structure contains
 the following fields:
 .PP
 .CS
 typedef struct Tcl_ChannelType {
-        char *\fItypeName\fR;
-        Tcl_DriverBlockModeProc *\fIblockModeProc\fR;
-        Tcl_DriverCloseProc *\fIcloseProc\fR;
-        Tcl_DriverInputProc *\fIinputProc\fR;
-        Tcl_DriverOutputProc *\fIoutputProc\fR;
-        Tcl_DriverSeekProc *\fIseekProc\fR;
-        Tcl_DriverSetOptionProc *\fIsetOptionProc\fR;
-        Tcl_DriverGetOptionProc *\fIgetOptionProc\fR;
-        Tcl_DriverWatchProc *\fIwatchProc\fR;
-        Tcl_DriverGetHandleProc *\fIgetHandleProc\fR;
-        Tcl_DriverClose2Proc *\fIclose2Proc\fR;
+	char *\fItypeName\fR;
+	Tcl_DriverBlockModeProc *\fIblockModeProc\fR;	
+	Tcl_DriverCloseProc *\fIcloseProc\fR;
+	Tcl_DriverInputProc *\fIinputProc\fR;
+	Tcl_DriverOutputProc *\fIoutputProc\fR;
+	Tcl_DriverSeekProc *\fIseekProc\fR;
+	Tcl_DriverSetOptionProc *\fIsetOptionProc\fR;
+	Tcl_DriverGetOptionProc *\fIgetOptionProc\fR;
+	Tcl_DriverWatchProc *\fIwatchProc\fR;
+	Tcl_DriverGetHandleProc *\fIgetHandleProc\fR;
+	Tcl_DriverClose2Proc *\fIclose2Proc\fR;
 } Tcl_ChannelType;
 .CE
 .PP
@@ -908,33 +827,6 @@ internal channel code will determine the version.  It is imperative to use
 the new \fBTcl_ChannelType\fR structure if you are creating a stacked
 channel driver, due to problems with the earlier stacked channel
 implementation (in 8.2.0 to 8.3.1).
-.PP
-Prior to 8.4.0 (i.e. during the later releases of 8.3 and early part
-of the 8.4 development cycle) the \fBTcl_ChannelType\fR structure
-contained the following fields:
-.PP
-.CS
-typedef struct Tcl_ChannelType {
-        char *\fItypeName\fR;
-        Tcl_ChannelTypeVersion \fIversion\fR;
-        Tcl_DriverCloseProc *\fIcloseProc\fR;
-        Tcl_DriverInputProc *\fIinputProc\fR;
-        Tcl_DriverOutputProc *\fIoutputProc\fR;
-        Tcl_DriverSeekProc *\fIseekProc\fR;
-        Tcl_DriverSetOptionProc *\fIsetOptionProc\fR;
-        Tcl_DriverGetOptionProc *\fIgetOptionProc\fR;
-        Tcl_DriverWatchProc *\fIwatchProc\fR;
-        Tcl_DriverGetHandleProc *\fIgetHandleProc\fR;
-        Tcl_DriverClose2Proc *\fIclose2Proc\fR;
-        Tcl_DriverBlockModeProc *\fIblockModeProc\fR;
-        Tcl_DriverFlushProc *\fIflushProc\fR;
-        Tcl_DriverHandlerProc *\fIhandlerProc\fR;
-        Tcl_DriverTruncateProc *\fItruncateProc\fR;
-} Tcl_ChannelType;
-.CE
-.PP
-When the above structure is registered as a channel type, the
-\fIversion\fR field should always be \fBTCL_CHANNEL_VERSION_2\fR.

 .SH "SEE ALSO"
 Tcl_Close(3), Tcl_OpenFileChannel(3), Tcl_SetErrno(3), Tcl_QueueEvent(3), Tcl_StackChannel(3), Tcl_GetStdChannel(3)
@@ -4,6 +4,7 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\"
+'\" RCS: @(#) $Id: CrtChnlHdlr.3,v 1.2 1998/09/14 18:39:46 stanton Exp $
 .so man.macros
 .TH Tcl_CreateChannelHandler 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -48,8 +49,8 @@ what it means for a channel to be readable or writable.
 \fIProc\fR must conform to the following prototype:
 .CS
 typedef void Tcl_ChannelProc(
-        ClientData \fIclientData\fR,
-        int \fImask\fR);
+	ClientData \fIclientData\fR,
+	int \fImask\fR);
 .CE
 .PP
 The \fIclientData\fR argument is the same as the value passed to
@@ -62,7 +63,7 @@ contain a subset of the bits from the \fImask\fR argument to
 .PP
 Each channel handler is identified by a unique combination of \fIchannel\fR,
 \fIproc\fR and \fIclientData\fR.
-There may be many handlers for a given channel as long as they do not
+There may be many handlers for a given channel as long as they don't
 have the same \fIchannel\fR, \fIproc\fR, and \fIclientData\fR.
 If \fBTcl_CreateChannelHandler\fR is invoked when there is already a handler
 for \fIchannel\fR, \fIproc\fR, and \fIclientData\fR, then no new
@@ -4,6 +4,7 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\"
+'\" RCS: @(#) $Id: CrtCloseHdlr.3,v 1.2 1998/09/14 18:39:47 stanton Exp $
 .so man.macros
 .TH Tcl_CreateCloseHandler 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -21,7 +22,7 @@ void
 \fBTcl_DeleteCloseHandler\fR(\fIchannel, proc, clientData\fR)
 .sp
 .SH ARGUMENTS
-.AS Tcl_CloseProc clientData
+.AS Tcl_CloseProc callbackData in
 .AP Tcl_Channel channel in
 The channel for which to create or delete a close callback.
 .AP Tcl_CloseProc *proc in
@@ -39,7 +40,7 @@ Arbitrary one-word value to pass to \fIproc\fR.
 .PP
 .CS
 typedef void Tcl_CloseProc(
-        ClientData \fIclientData\fR);
+	ClientData \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR is the same as the value provided in the call to
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CrtCommand.3,v 1.4 2001/04/24 20:59:17 kennykb Exp $
+'\" 
 .so man.macros
 .TH Tcl_CreateCommand 3 "" Tcl "Tcl Library Procedures"
 .BS
@@ -17,10 +19,12 @@ Tcl_CreateCommand \- implement new commands in C
 Tcl_Command
 \fBTcl_CreateCommand\fR(\fIinterp, cmdName, proc, clientData, deleteProc\fR)
 .SH ARGUMENTS
-.AS Tcl_CmdDeleteProc *deleteProc
+.AS Tcl_CmdDeleteProc **deleteProcPtr
 .AP Tcl_Interp *interp in
 Interpreter in which to create new command.
-.AP "const char" *cmdName in
+.VS 8.4
+.AP "CONST char" *cmdName in
+.VE
 Name of command.
 .AP Tcl_CmdProc *proc in
 Implementation of new command:  \fIproc\fR will be called whenever
@@ -77,10 +81,10 @@ and it returns NULL.
 \fBTcl_CmdProc\fR:
 .CS
 typedef int Tcl_CmdProc(
-        ClientData \fIclientData\fR,
-        Tcl_Interp *\fIinterp\fR,
-        int \fIargc\fR,
-        const char *\fIargv\fR[]);
+	ClientData \fIclientData\fR,
+	Tcl_Interp *\fIinterp\fR,
+	int \fIargc\fR,
+	char *\fIargv\fR[]);
 .CE
 When \fIproc\fR is invoked the \fIclientData\fR and \fIinterp\fR
 parameters will be copies of the \fIclientData\fR and \fIinterp\fR
@@ -93,23 +97,21 @@ the command name) and \fIargv\fR giving the values of the arguments
 as strings.  The \fIargv\fR array will contain \fIargc\fR+1 values;
 the first \fIargc\fR values point to the argument strings, and the
 last value is NULL.  
+.VS
 Note that the argument strings should not be modified as they may
 point to constant strings or may be shared with other parts of the
 interpreter.
+.VE
 .PP
-Note that the argument strings are encoded in normalized UTF-8 since
-version 8.1 of Tcl.
-.PP
-\fIProc\fR must return an integer code that is expected to be one of
-\fBTCL_OK\fR, \fBTCL_ERROR\fR, \fBTCL_RETURN\fR, \fBTCL_BREAK\fR, or
-\fBTCL_CONTINUE\fR.  See the Tcl overview man page
+\fIProc\fR must return an integer code that is either \fBTCL_OK\fR, \fBTCL_ERROR\fR,
+\fBTCL_RETURN\fR, \fBTCL_BREAK\fR, or \fBTCL_CONTINUE\fR.  See the Tcl overview man page
 for details on what these codes mean.  Most normal commands will only
 return \fBTCL_OK\fR or \fBTCL_ERROR\fR.  In addition, \fIproc\fR must set
 the interpreter result to point to a string value;
 in the case of a \fBTCL_OK\fR return code this gives the result
 of the command, and in the case of \fBTCL_ERROR\fR it gives an error message.
 The \fBTcl_SetResult\fR procedure provides an easy interface for setting
-the return value;  for complete details on how the interpreter result
+the return value;  for complete details on how the the interpreter result
 field is managed, see the \fBTcl_Interp\fR man page.
 Before invoking a command procedure,
 \fBTcl_Eval\fR sets the interpreter result to point to an empty string,
@@ -130,11 +132,11 @@ application an opportunity to release any structures associated
 with the command.  \fIDeleteProc\fR should have arguments and
 result that match the type \fBTcl_CmdDeleteProc\fR:
 .CS
-typedef void Tcl_CmdDeleteProc(
-        ClientData \fIclientData\fR);
+typedef void Tcl_CmdDeleteProc(ClientData \fIclientData\fR);
 .CE
 The \fIclientData\fR argument will be the same as the \fIclientData\fR
 argument passed to \fBTcl_CreateCommand\fR.
+.PP

 .SH "SEE ALSO"
 Tcl_CreateObjCommand, Tcl_DeleteCommand, Tcl_GetCommandInfo, Tcl_SetCommandInfo, Tcl_GetCommandName, Tcl_SetObjResult
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CrtFileHdlr.3,v 1.2 1998/09/14 18:39:47 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_CreateFileHandler 3 8.0 Tcl "Tcl Library Procedures"
 .BS
@@ -13,14 +15,18 @@ Tcl_CreateFileHandler, Tcl_DeleteFileHandler \- associate procedure callbacks wi
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
+.VS
 .sp
 \fBTcl_CreateFileHandler\fR(\fIfd, mask, proc, clientData\fR)
 .sp
 \fBTcl_DeleteFileHandler\fR(\fIfd\fR)
+.VE
 .SH ARGUMENTS
 .AS Tcl_FileProc clientData
+.VS
 .AP int fd in
 Unix file descriptor for an open file or device.
+.VE
 .AP int mask in
 Conditions under which \fIproc\fR should be called:
 OR-ed combination of \fBTCL_READABLE\fR, \fBTCL_WRITABLE\fR,
@@ -35,10 +41,12 @@ Arbitrary one-word value to pass to \fIproc\fR.

 .SH DESCRIPTION
 .PP
+.VS
 \fBTcl_CreateFileHandler\fR arranges for \fIproc\fR to be
 invoked in the future whenever I/O becomes possible on a file
 or an exceptional condition exists for the file.  The file
 is indicated by \fIfd\fR, and the conditions of interest
+.VE
 are indicated by \fImask\fR.  For example, if \fImask\fR
 is \fBTCL_READABLE\fR, \fIproc\fR will be called when
 the file is readable.
@@ -51,8 +59,8 @@ as \fBvwait\fR.
 type \fBTcl_FileProc\fR:
 .CS
 typedef void Tcl_FileProc(
-        ClientData \fIclientData\fR,
-        int \fImask\fR);
+	ClientData \fIclientData\fR,
+	int \fImask\fR);
 .CE
 The \fIclientData\fR parameter to \fIproc\fR is a copy
 of the \fIclientData\fR
@@ -79,12 +87,14 @@ events while waiting for files to become ready for I/O.  For this to work
 correctly, the application may need to use non-blocking I/O operations on
 the files for which handlers are declared.  Otherwise the application may
 block if it reads or writes too much data; while waiting for the I/O to
-complete the application will not be able to service other events. Use
+complete the application won't be able to service other events. Use
 \fBTcl_SetChannelOption\fR with \fB\-blocking\fR to set the channel into
 blocking or nonblocking mode as required.
 .PP
+.VS
 Note that these interfaces are only supported by the Unix
 implementation of the Tcl notifier.   
+.VE

 .SH KEYWORDS
 callback, file, handler
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CrtInterp.3,v 1.6 2001/12/14 20:31:22 msofer Exp $
+'\" 
 .so man.macros
 .TH Tcl_CreateInterp 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -101,6 +103,8 @@ has been called. To ensure that the interpreter is properly deleted when
 it is no longer needed, call \fBTcl_InterpDeleted\fR to test if some other
 code already called \fBTcl_DeleteInterp\fR; if not, call
 \fBTcl_DeleteInterp\fR before calling \fBTcl_Release\fR in your own code.
+Do not call \fBTcl_DeleteInterp\fR on an interpreter for which
+\fBTcl_InterpDeleted\fR returns nonzero.
 .TP
 Retrieving An Interpreter From A Data Structure
 When an interpreter is retrieved from a data structure (e.g. the client
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CrtMathFnc.3,v 1.5 2001/05/30 08:57:05 dkf Exp $
+'\" 
 .so man.macros
 .TH Tcl_CreateMathFunc 3 8.4 Tcl "Tcl Library Procedures"
 .BS
@@ -17,17 +19,20 @@ Tcl_CreateMathFunc, Tcl_GetMathFuncInfo, Tcl_ListMathFuncs \- Define, query and
 void
 \fBTcl_CreateMathFunc\fR(\fIinterp, name, numArgs, argTypes, proc, clientData\fR)
 .sp
+.VS 8.4
 int
-\fBTcl_GetMathFuncInfo\fR(\fIinterp, name, numArgsPtr, argTypesPtr, procPtr,
-                    clientDataPtr\fR)
+\fBTcl_GetMathFuncInfo\fR(\fIinterp, name, numArgsPtr, argTypesPtr, procPtr, clientDataPtr\fR)
 .sp
 Tcl_Obj *
 \fBTcl_ListMathFuncs\fR(\fIinterp, pattern\fR)
+.VE
 .SH ARGUMENTS
-.AS Tcl_ValueType *clientDataPtr out
+.AS Tcl_ValueType *clientDataPtr
 .AP Tcl_Interp *interp in
 Interpreter in which new function will be defined.
-.AP "const char" *name in
+.VS 8.4
+.AP "CONST char" *name in
+.VE
 Name for new function.
 .AP int numArgs in
 Number of arguments to new function;  also gives size of \fIargTypes\fR array.
@@ -41,19 +46,19 @@ Arbitrary one-word value to pass to \fIproc\fR when it is invoked.
 .AP int *numArgsPtr out
 Points to a variable that will be set to contain the number of
 arguments to the function.
-.AP Tcl_ValueType **argTypesPtr out
+.AP Tcl_ValueType *argTypesPtr out
 Points to a variable that will be set to contain a pointer to an array
 giving the permissible types for each argument to the function which
 will need to be freed up using \fITcl_Free\fR.
-.AP Tcl_MathProc **procPtr out
+.AP Tcl_MathProc *procPtr out
 Points to a variable that will be set to contain a pointer to the
 implementation code for the function (or NULL if the function is
-implemented directly in bytecode).
+implemented directly in bytecode.)
 .AP ClientData *clientDataPtr out
 Points to a variable that will be set to contain the clientData
 argument passed to \fITcl_CreateMathFunc\fR when the function was
 created if the function is not implemented directly in bytecode.
-.AP "const char" *pattern in
+.AP "CONST char" *pattern in
 Pattern to match against function names so as to filter them (by
 passing to \fITcl_StringMatch\fR), or NULL to not apply any filter.
 .BE
@@ -62,35 +67,25 @@ passing to \fITcl_StringMatch\fR), or NULL to not apply any filter.
 .PP
 Tcl allows a number of mathematical functions to be used in
 expressions, such as \fBsin\fR, \fBcos\fR, and \fBhypot\fR.
-These functions are represented by commands in the namespace,
-\fBtcl::mathfunc\fR.  The \fBTcl_CreateMathFunc\fR function is
-an obsolete way for applications to add additional functions
+\fBTcl_CreateMathFunc\fR allows applications to add additional functions
 to those already provided by Tcl or to replace existing functions.
-It should not be used by new applications, which should create
-math functions using \fBTcl_CreateObjCommand\fR to create a command
-in the \fBtcl::mathfunc\fR namespace.
-.PP
-In the \fBTcl_CreateMathFunc\fR interface,
 \fIName\fR is the name of the function as it will appear in expressions.
-If \fIname\fR does not already exist in the \fB::tcl::mathfunc\fR
-namespace, then a new command is created in that namespace.
-If \fIname\fR does exist, then the existing function is replaced.
+If \fIname\fR doesn't already exist as a function then a new function
+is created.  If it does exist, then the existing function is replaced.
 \fINumArgs\fR and \fIargTypes\fR describe the arguments to the function.
-Each entry in the \fIargTypes\fR array must be
-one of \fBTCL_INT\fR, \fBTCL_DOUBLE\fR, \fBTCL_WIDE_INT\fR,
-or \fBTCL_EITHER\fR to indicate whether the corresponding argument must be an
-integer, a double-precision floating value, a wide (64-bit) integer,
-or any, respectively.
+Each entry in the \fIargTypes\fR array must be either TCL_INT, TCL_DOUBLE,
+or TCL_EITHER to indicate whether the corresponding argument must be an
+integer, a double-precision floating value, or either, respectively.
 .PP
 Whenever the function is invoked in an expression Tcl will invoke
 \fIproc\fR.  \fIProc\fR should have arguments and result that match
 the type \fBTcl_MathProc\fR:
 .CS
 typedef int Tcl_MathProc(
-        ClientData \fIclientData\fR,
-        Tcl_Interp *\fIinterp\fR,
-        Tcl_Value *\fIargs\fR,
-        Tcl_Value *\fIresultPtr\fR);
+	ClientData \fIclientData\fR,
+	Tcl_Interp *\fIinterp\fR,
+	Tcl_Value *\fIargs\fR,
+	Tcl_Value *\fIresultPtr\fR);
 .CE
 .PP
 When \fIproc\fR is invoked the \fIclientData\fR and \fIinterp\fR
@@ -99,33 +94,31 @@ arguments will be the same as those passed to \fBTcl_CreateMathFunc\fR.
 which describe the actual arguments to the function:
 .CS
 typedef struct Tcl_Value {
-        Tcl_ValueType \fItype\fR;
-        long \fIintValue\fR;
-        double \fIdoubleValue\fR;
-        Tcl_WideInt \fIwideValue\fR;
+	Tcl_ValueType \fItype\fR;
+	long \fIintValue\fR;
+	double \fIdoubleValue\fR;
 } Tcl_Value;
 .CE
 .PP
 The \fItype\fR field indicates the type of the argument and is
-one of \fBTCL_INT\fR, \fBTCL_DOUBLE\fR or \fBTCL_WIDE_INT\fR.
+either TCL_INT or TCL_DOUBLE.
 It will match the \fIargTypes\fR value specified for the function unless
-the \fIargTypes\fR value was \fBTCL_EITHER\fR. Tcl converts
+the \fIargTypes\fR value was TCL_EITHER. Tcl converts
 the argument supplied in the expression to the type requested in
 \fIargTypes\fR, if that is necessary.
-Depending on the value of the \fItype\fR field, the \fIintValue\fR,
-\fIdoubleValue\fR or \fIwideValue\fR
-field will contain the actual value of the argument.
+Depending on the value of the \fItype\fR field, the \fIintValue\fR
+or \fIdoubleValue\fR field will contain the actual value of the argument.
 .PP
 \fIProc\fR should compute its result and store it either as an integer
 in \fIresultPtr->intValue\fR or as a floating value in
 \fIresultPtr->doubleValue\fR.
-It should set also \fIresultPtr->type\fR to one of
-\fBTCL_INT\fR, \fBTCL_DOUBLE\fR or \fBTCL_WIDE_INT\fR
+It should set also \fIresultPtr->type\fR to either TCL_INT or TCL_DOUBLE
 to indicate which value was set.
-Under normal circumstances \fIproc\fR should return \fBTCL_OK\fR.
+Under normal circumstances \fIproc\fR should return TCL_OK.
 If an error occurs while executing the function, \fIproc\fR should
-return \fBTCL_ERROR\fR and leave an error message in the interpreter's result.
+return TCL_ERROR and leave an error message in the interpreter's result.
 .PP
+.VS 8.4
 \fBTcl_GetMathFuncInfo\fR retrieves the values associated with
 function \fIname\fR that were passed to a preceding
 \fBTcl_CreateMathFunc\fR call.  Normally, the return code is
@@ -136,21 +129,20 @@ result.
 If an error did not occur, the array reference placed in the variable
 pointed to by \fIargTypesPtr\fR is newly allocated, and should be
 released by passing it to \fBTcl_Free\fR.  Some functions (the
-standard set implemented in the core, and those defined by placing
-commands in the \fBtcl::mathfunc\fR namespace) do not have
-argument type information; attempting to retrieve values for
-them causes a NULL to be stored in the variable pointed to by 
-\fIprocPtr\fR and the variable pointed to by \fIclientDataPtr\fR
-will not be modified.  The variable pointed to by \fInumArgsPointer\fR
-will contain -1, and no argument types will be stored in the variable
-pointed to by \fIargTypesPointer\fR.
+standard set implemented in the core) are implemented directly at the
+bytecode level; attempting to retrieve values for them causes a NULL
+to be stored in the variable pointed to by \fIprocPtr\fR and the
+variable pointed to by \fIclientDataPtr\fR will not be modified.
 .PP
 \fBTcl_ListMathFuncs\fR returns a Tcl object containing a list of all
 the math functions defined in the interpreter whose name matches
-\fIpattern\fR.  The returned object has a reference count of zero.
-
-.SH "SEE ALSO"
-expr(n), info(n), Tcl_CreateObjCommand(3), Tcl_Free(3), Tcl_NewListObj(3)
+\fIpattern\fR.  In the case of an error, NULL is returned and an error
+message is left in the interpreter result, and otherwise the returned
+object will have a reference count of zero.
+.VE

 .SH KEYWORDS
 expression, mathematical function
+
+.SH "SEE ALSO"
+expr(n), info(n), Tcl_Free(3), Tcl_NewListObj(3)
@@ -4,11 +4,13 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CrtObjCmd.3,v 1.5 2001/04/24 20:59:17 kennykb Exp $
+'\" 
 .so man.macros
 .TH Tcl_CreateObjCommand 3 8.0 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_CreateObjCommand, Tcl_DeleteCommand, Tcl_DeleteCommandFromToken, Tcl_GetCommandInfo, Tcl_GetCommandInfoFromToken, Tcl_SetCommandInfo, Tcl_SetCommandInfoFromToken, Tcl_GetCommandName, Tcl_GetCommandFullName, Tcl_GetCommandFromObj \- implement new commands in C
+Tcl_CreateObjCommand, Tcl_DeleteCommand, Tcl_DeleteCommandFromToken, Tcl_GetCommandInfo, Tcl_SetCommandInfo, Tcl_GetCommandName \- implement new commands in C
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -28,25 +30,17 @@ int
 int
 \fBTcl_SetCommandInfo\fR(\fIinterp, cmdName, infoPtr\fR)
 .sp
-int
-\fBTcl_GetCommandInfoFromToken\fR(\fItoken, infoPtr\fR)
-.sp
-int
-\fBTcl_SetCommandInfoFromToken\fR(\fItoken, infoPtr\fR)
-.sp
-const char *
+.VS 8.4
+CONST char *
+.VE
 \fBTcl_GetCommandName\fR(\fIinterp, token\fR)
-.sp
-void
-\fBTcl_GetCommandFullName\fR(\fIinterp, token, objPtr\fR)
-.sp
-Tcl_Command
-\fBTcl_GetCommandFromObj\fR(\fIinterp, objPtr\fR)
 .SH ARGUMENTS
-.AS Tcl_CmdDeleteProc *deleteProc in/out
+.AS Tcl_ObjCmdProc *deleteProc in/out
 .AP Tcl_Interp *interp in
 Interpreter in which to create a new command or that contains a command.
+.VS 8.4
 .AP char *cmdName in
+.VE
 Name of command.
 .AP Tcl_ObjCmdProc *proc in
 Implementation of the new command: \fIproc\fR will be called whenever
@@ -63,8 +57,6 @@ The command must not have been deleted.
 .AP Tcl_CmdInfo *infoPtr in/out
 Pointer to structure containing various information about a
 Tcl command.
-.AP Tcl_Obj *objPtr in
-Object containing the name of a Tcl command.
 .BE
 .SH DESCRIPTION
 .PP
@@ -90,10 +82,11 @@ and it returns NULL.
 \fBTcl_ObjCmdProc\fR:
 .CS
 typedef int Tcl_ObjCmdProc(
-        ClientData \fIclientData\fR,
-        Tcl_Interp *\fIinterp\fR,
-        int \fIobjc\fR,
-        Tcl_Obj *const \fIobjv\fR[]);
+	ClientData \fIclientData\fR,
+	Tcl_Interp *\fIinterp\fR,
+	int \fIobjc\fR,
+.VS
+	Tcl_Obj *CONST \fIobjv\fR[]);
 .CE
 When \fIproc\fR is invoked, the \fIclientData\fR and \fIinterp\fR parameters
 will be copies of the \fIclientData\fR and \fIinterp\fR arguments given to
@@ -110,7 +103,7 @@ Additionally, when \fIproc\fR is invoked, it must not modify the contents
 of the \fIobjv\fR array by assigning new pointer values to any element of the
 array (for example, \fIobjv\fR[\fB2\fR] = \fBNULL\fR) because this will
 cause memory to be lost and the runtime stack to be corrupted.  The
-\fBconst\fR in the declaration of \fIobjv\fR will cause ANSI-compliant
+\fBCONST\fR in the declaration of \fIobjv\fR will cause ANSI-compliant
 compilers to report any such attempted assignment as an error.  However,
 it is acceptable to modify the internal representation of any individual
 object argument.  For instance, the user may call
@@ -118,6 +111,7 @@ object argument.  For instance, the user may call
 representation of that object; that call may change the type of the object
 that \fIobjv\fR[\fB2\fR] points at, but will not change where
 \fIobjv\fR[\fB2\fR] points.
+.VE
 .PP
 \fIproc\fR must return an integer code that is either \fBTCL_OK\fR,
 \fBTCL_ERROR\fR, \fBTCL_RETURN\fR, \fBTCL_BREAK\fR, or \fBTCL_CONTINUE\fR.
@@ -160,8 +154,7 @@ application an opportunity to release any structures associated
 with the command.  \fIDeleteProc\fR should have arguments and
 result that match the type \fBTcl_CmdDeleteProc\fR:
 .CS
-typedef void Tcl_CmdDeleteProc(
-        ClientData \fIclientData\fR);
+typedef void Tcl_CmdDeleteProc(ClientData \fIclientData\fR);
 .CE
 The \fIclientData\fR argument will be the same as the \fIclientData\fR
 argument passed to \fBTcl_CreateObjCommand\fR.
@@ -169,7 +162,7 @@ argument passed to \fBTcl_CreateObjCommand\fR.
 \fBTcl_DeleteCommand\fR deletes a command from a command interpreter.
 Once the call completes, attempts to invoke \fIcmdName\fR in
 \fIinterp\fR will result in errors.
-If \fIcmdName\fR is not bound as a command in \fIinterp\fR then
+If \fIcmdName\fR isn't bound as a command in \fIinterp\fR then
 \fBTcl_DeleteCommand\fR does nothing and returns -1;  otherwise
 it returns 0.
 There are no restrictions on \fIcmdName\fR:  it may refer to
@@ -199,14 +192,14 @@ pointed to by \fIinfoPtr\fR and returns 1.
 A \fBTcl_CmdInfo\fR structure has the following fields:
 .CS
 typedef struct Tcl_CmdInfo {
-    int \fIisNativeObjectProc\fR;
-    Tcl_ObjCmdProc *\fIobjProc\fR;
-    ClientData \fIobjClientData\fR;
-    Tcl_CmdProc *\fIproc\fR;
-    ClientData \fIclientData\fR;
-    Tcl_CmdDeleteProc *\fIdeleteProc\fR;
-    ClientData \fIdeleteData\fR;
-    Tcl_Namespace *\fInamespacePtr\fR;
+    int isNativeObjectProc;
+    Tcl_ObjCmdProc *objProc;
+    ClientData objClientData;
+    Tcl_CmdProc *proc;
+    ClientData clientData;
+    Tcl_CmdDeleteProc *deleteProc;
+    ClientData deleteData;
+    Tcl_Namespace *namespacePtr;
 } Tcl_CmdInfo;
 .CE
 The \fIisNativeObjectProc\fR field has the value 1
@@ -237,12 +230,6 @@ to pass to \fIdeleteProc\fR;  it is normally the same as
 The field \fInamespacePtr\fR holds a pointer to the
 Tcl_Namespace that contains the command.
 .PP
-\fBTcl_GetCommandInfoFromToken\fR is identical to
-\fBTcl_GetCommandInfo\fR except that it uses a command token returned
-from \fBTcl_CreateObjCommand\fR in place of the command name.  If the
-\fItoken\fR parameter is NULL, it returns 0; otherwise, it returns 1
-and fills in the structure designated by \fIinfoPtr\fR.
-.PP
 \fBTcl_SetCommandInfo\fR is used to modify the procedures and
 ClientData values associated with a command.
 Its \fIcmdName\fR argument is the name of a command in \fIinterp\fR.
@@ -251,22 +238,11 @@ to identify a command in a particular namespace.
 If this command does not exist then \fBTcl_SetCommandInfo\fR returns 0.
 Otherwise, it copies the information from \fI*infoPtr\fR to
 Tcl's internal structure for the command and returns 1.
-.PP
-\fBTcl_SetCommandInfoFromToken\fR is identical to
-\fBTcl_SetCommandInfo\fR except that it takes a command token as
-returned by \fBTcl_CreateObjCommand\fR instead of the command name.
-If the \fItoken\fR parameter is NULL, it returns 0.  Otherwise, it
-copies the information from \fI*infoPtr\fR to Tcl's internal structure
-for the command and returns 1.
-.PP
-Note that \fBTcl_SetCommandInfo\fR and
-\fBTcl_SetCommandInfoFromToken\fR both allow the ClientData for a
-command's deletion procedure to be given a different value than the
-ClientData for its command procedure.
-.PP
-Note that neither \fBTcl_SetCommandInfo\fR nor
-\fBTcl_SetCommandInfoFromToken\fR will change a command's namespace.
-Use \fBTcl_Eval\fR to call the \fBrename\fR command to do that.
+Note that this procedure allows the ClientData for a command's
+deletion procedure to be given a different value than the ClientData
+for its command procedure.
+Note that \fBTcl_SetCmdInfo\fR will not change a command's namespace;
+you must use \fBTcl_RenameCommand\fR to do that.
 .PP
 \fBTcl_GetCommandName\fR provides a mechanism for tracking commands
 that have been renamed.
@@ -278,18 +254,9 @@ This name does not include any \fB::\fR namespace qualifiers.
 The command corresponding to \fItoken\fR must not have been deleted.
 The string returned by \fBTcl_GetCommandName\fR is in dynamic memory
 owned by Tcl and is only guaranteed to retain its value as long as the
-command is not deleted or renamed;  callers should copy the string if
+command isn't deleted or renamed;  callers should copy the string if
 they need to keep it for a long time.
-.PP
-\fBTcl_GetCommandFullName\fR produces the fully qualified name
-of a command from a command token.  
-The name, including all namespace prefixes,
-is appended to the object specified by \fIobjPtr\fR.
-.PP
-\fBTcl_GetCommandFromObj\fR returns a token for the command
-specified by the name in a \fBTcl_Obj\fR.
-The command name is resolved relative to the current namespace.
-Returns NULL if the command is not found.
+
 .SH "SEE ALSO"
 Tcl_CreateCommand, Tcl_ResetResult, Tcl_SetObjResult

@@ -4,11 +4,13 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CrtSlave.3,v 1.6 2002/01/16 06:02:33 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_CreateSlave 3 7.6 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_IsSafe, Tcl_MakeSafe, Tcl_CreateSlave, Tcl_GetSlave, Tcl_GetMaster, Tcl_GetInterpPath, Tcl_CreateAlias, Tcl_CreateAliasObj, Tcl_GetAlias, Tcl_GetAliasObj, Tcl_ExposeCommand, Tcl_HideCommand \- manage multiple Tcl interpreters, aliases and hidden commands
+Tcl_IsSafe, Tcl_MakeSafe, Tcl_CreateSlave, Tcl_GetSlave, Tcl_GetMaster, Tcl_GetInterpPath, Tcl_CreateAlias, Tcl_CreateAliasObj, Tcl_GetAlias, Tcl_GetAliasObj, Tcl_ExposeCommand, Tcl_HideCommand \- manage multiple Tcl interpreters, aliases and hidden commands.
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -31,21 +33,20 @@ Tcl_Interp *
 int
 \fBTcl_GetInterpPath\fR(\fIaskingInterp, slaveInterp\fR)
 .sp
+.VS
 int
-\fBTcl_CreateAlias\fR(\fIslaveInterp, slaveCmd, targetInterp, targetCmd,
-                argc, argv\fR)
+\fBTcl_CreateAlias\fR(\fIslaveInterp, slaveCmd, targetInterp, targetCmd, argc, argv\fR)
 .sp
 int
-\fBTcl_CreateAliasObj\fR(\fIslaveInterp, slaveCmd, targetInterp, targetCmd,
-                   objc, objv\fR)
+\fBTcl_CreateAliasObj\fR(\fIslaveInterp, slaveCmd, targetInterp, targetCmd, objc, objv\fR)
+.VE
 .sp
 int
-\fBTcl_GetAlias\fR(\fIinterp, slaveCmd, targetInterpPtr, targetCmdPtr,
-             argcPtr, argvPtr\fR)
+\fBTcl_GetAlias\fR(\fIinterp, slaveCmd, targetInterpPtr, targetCmdPtr, argcPtr, argvPtr\fR)
 .sp
+.VS
 int
-\fBTcl_GetAliasObj\fR(\fIinterp, slaveCmd, targetInterpPtr, targetCmdPtr,
-                objcPtr, objvPtr\fR)
+\fBTcl_GetAliasObj\fR(\fIinterp, slaveCmd, targetInterpPtr, targetCmdPtr, objcPtr, objvPtr\fR)
 .sp
 int
 \fBTcl_ExposeCommand\fR(\fIinterp, hiddenCmdName, cmdName\fR)
@@ -53,46 +54,44 @@ int
 int
 \fBTcl_HideCommand\fR(\fIinterp, cmdName, hiddenCmdName\fR)
 .SH ARGUMENTS
-.AS "const char *const" **targetInterpPtr out
+.AS Tcl_InterpDeleteProc **hiddenCmdName
 .AP Tcl_Interp *interp in
 Interpreter in which to execute the specified command.
-.AP "const char" *slaveName in
+.AP "CONST char" *slaveName in
 Name of slave interpreter to create or manipulate.
 .AP int isSafe in
-If non-zero, a
-.QW safe
-slave that is suitable for running untrusted code
+If non-zero, a ``safe'' slave that is suitable for running untrusted code
 is created, otherwise a trusted slave is created.
 .AP Tcl_Interp *slaveInterp in
 Interpreter to use for creating the source command for an alias (see
 below).
-.AP "const char" *slaveCmd in
+.AP "CONST char" *slaveCmd in
 Name of source command for alias.
 .AP Tcl_Interp *targetInterp in
 Interpreter that contains the target command for an alias.
-.AP "const char" *targetCmd in
+.AP "CONST char" *targetCmd in
 Name of target command for alias in \fItargetInterp\fR.
 .AP int argc in
 Count of additional arguments to pass to the alias command.
-.AP "const char *const" *argv in
+.AP "char * CONST" *argv in
 Vector of strings, the additional arguments to pass to the alias command.
 This storage is owned by the caller.
 .AP int objc in
 Count of additional object arguments to pass to the alias object command.
-.AP Tcl_Obj **objv in
-Vector of Tcl_Obj structures, the additional object arguments to pass to
+.AP Tcl_Object **objv in
+Vector of Tcl_Obj structures, the additional object argumenst to pass to
 the alias object command.
 This storage is owned by the caller.
 .AP Tcl_Interp **targetInterpPtr in
 Pointer to location to store the address of the interpreter where a target
 command is defined for an alias.
-.AP "const char" **targetCmdPtr out
+.AP "CONST char" **targetCmdPtr out
 Pointer to location to store the address of the name of the target command
 for an alias.
 .AP int *argcPtr out
 Pointer to location to store count of additional arguments to be passed to
 the alias. The location is in storage owned by the caller.
-.AP "const char" ***argvPtr out
+.AP char ***argvPtr out
 Pointer to location to store a vector of strings, the additional arguments
 to pass to an alias. The location is in storage owned by the caller, the
 vector of strings is owned by the called function.
@@ -104,11 +103,17 @@ Pointer to location to store a vector of Tcl_Obj structures, the additional
 arguments to pass to an object alias command. The location is in storage
 owned by the caller, the vector of Tcl_Obj structures is owned by the
 called function.
-.AP "const char" *cmdName in
+.VS
+.VS 8.4
+.AP "CONST char" *cmdName in
+.VE
 Name of an exposed command to hide or create.
-.AP "const char" *hiddenCmdName in
+.VS 8.4
+.AP "CONST char" *hiddenCmdName in
+.VE
 Name under which a hidden command is stored and with which it can be
 exposed or invoked.
+.VE
 .BE

 .SH DESCRIPTION
@@ -126,29 +131,19 @@ It also creates a slave command named \fIslaveName\fR in \fIinterp\fR which
 allows \fIinterp\fR to manipulate the new slave. 
 If \fIisSafe\fR is zero, the command creates a trusted slave in which Tcl
 code has access to all the Tcl commands.
-If it is \fB1\fR, the command creates a
-.QW safe
-slave in which Tcl code has access only to set of Tcl commands defined as
-.QW "Safe Tcl" ;
-see the manual entry for the Tcl \fBinterp\fR command for details.
+If it is \fB1\fR, the command creates a ``safe'' slave in which Tcl code
+has access only to set of Tcl commands defined as ``Safe Tcl''; see the
+manual entry for the Tcl \fBinterp\fR command for details.
 If the creation of the new slave interpreter failed, \fBNULL\fR is returned.
 .PP
-\fBTcl_IsSafe\fR returns \fB1\fR if \fIinterp\fR is
-.QW safe
-(was created with the \fBTCL_SAFE_INTERPRETER\fR flag specified),
+\fBTcl_IsSafe\fR returns \fB1\fR if \fIinterp\fR is ``safe'' (was created
+with the \fBTCL_SAFE_INTERPRETER\fR flag specified),
 \fB0\fR otherwise.
 .PP
-\fBTcl_MakeSafe\fR marks \fIinterp\fR as
-.QW safe ,
-so that future
-calls to \fBTcl_IsSafe\fR will return 1.  It also removes all known
-potentially-unsafe core functionality (both commands and variables)
-from \fIinterp\fR.  However, it cannot know what parts of an extension
-or application are safe and does not make any attempt to remove those
-parts, so safety is not guaranteed after calling \fBTcl_MakeSafe\fR.
-Callers will want to take care with their use of \fBTcl_MakeSafe\fR
-to avoid false claims of safety.  For many situations, \fBTcl_CreateSlave\fR
-may be a better choice, since it creates interpreters in a known-safe state.
+\fBTcl_MakeSafe\fR makes \fIinterp\fR ``safe'' by removing all
+non-core and core unsafe functionality. Note that if you call this after
+adding some extension to an interpreter, all traces of that extension will
+be removed from the interpreter.
 .PP
 \fBTcl_GetSlave\fR returns a pointer to a slave interpreter of
 \fIinterp\fR. The slave interpreter is identified by \fIslaveName\fR.
@@ -165,6 +160,7 @@ of the relative path succeeds, \fBTCL_OK\fR is returned, else
 \fBTCL_ERROR\fR is returned and the \fIresult\fR field in
 \fIaskingInterp\fR contains the error message.
 .PP
+.VS
 \fBTcl_CreateAlias\fR creates an object command named \fIslaveCmd\fR in
 \fIslaveInterp\fR that when invoked, will cause the command \fItargetCmd\fR
 to be invoked in \fItargetInterp\fR. The arguments specified by the strings
@@ -181,6 +177,7 @@ restrictions on how they are related.
 \fBTcl_CreateAliasObj\fR is similar to \fBTcl_CreateAlias\fR except 
 that it takes a vector of objects to pass as additional arguments instead
 of a vector of strings.
+.VE
 .PP
 \fBTcl_GetAlias\fR returns information about an alias \fIaliasName\fR
 in \fIinterp\fR. Any of the result fields can be \fBNULL\fR, in
@@ -188,6 +185,7 @@ which case the corresponding datum is not returned. If a result field is
 non\-\fBNULL\fR, the address indicated is set to the corresponding datum.
 For example, if \fItargetNamePtr\fR is non\-\fBNULL\fR it is set to a
 pointer to the string containing the name of the target command.
+.VS
 .PP
 \fBTcl_GetAliasObj\fR is similar to \fBTcl_GetAlias\fR except that it
 returns a pointer to a vector of Tcl_Obj structures instead of a vector of
@@ -233,4 +231,5 @@ interp

 .SH KEYWORDS
 alias, command, exposed commands, hidden commands, interpreter, invoke,
-master, slave
+master, slave, 
+
@@ -5,11 +5,14 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CrtTimerHdlr.3,v 1.2 1998/09/14 18:39:47 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_CreateTimerHandler 3 7.5 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_CreateTimerHandler, Tcl_DeleteTimerHandler \- call a procedure at a given time
+Tcl_CreateTimerHandler, Tcl_DeleteTimerHandler \- call a procedure at a
+given time
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -27,7 +30,7 @@ Procedure to invoke after \fImilliseconds\fR have elapsed.
 .AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .AP Tcl_TimerToken token in
-Token for previously created timer handler (the return value
+Token for previously-created timer handler (the return value
 from some previous call to \fBTcl_CreateTimerHandler\fR).
 .BE

@@ -42,7 +45,7 @@ dispatch events through \fBTcl_DoOneEvent\fR or through Tcl commands
 such as \fBvwait\fR.
 The call to \fIproc\fR may not be made at the exact time given by
 \fImilliseconds\fR:  it will be made at the next opportunity
-after that time.  For example, if \fBTcl_DoOneEvent\fR is not
+after that time.  For example, if \fBTcl_DoOneEvent\fR isn't
 called until long after the time has elapsed, or if there
 are other pending events to process before the call to
 \fIproc\fR, then the call to \fIproc\fR will be delayed.
@@ -60,7 +63,7 @@ structure containing application-specific information about
 what to do in \fIproc\fR.
 .PP
 \fBTcl_DeleteTimerHandler\fR may be called to delete a
-previously created timer handler.  It deletes the handler
+previously-created timer handler.  It deletes the handler
 indicated by \fItoken\fR so that no call to \fIproc\fR
 will be made;  if that handler no longer exists
 (e.g. because the time period has already elapsed and \fIproc\fR
@@ -1,16 +1,17 @@
 '\"
 '\" Copyright (c) 1989-1993 The Regents of the University of California.
 '\" Copyright (c) 1994-1996 Sun Microsystems, Inc.
-'\" Copyright (c) 2002 by Kevin B. Kenny <kennykb@acm.org>.  All rights reserved.
 '\"
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: CrtTrace.3,v 1.2 1998/09/14 18:39:47 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_CreateTrace 3 "" Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_CreateTrace, Tcl_CreateObjTrace, Tcl_DeleteTrace \- arrange for command execution to be traced
+Tcl_CreateTrace, Tcl_DeleteTrace \- arrange for command execution to be traced
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -18,109 +19,73 @@ Tcl_CreateTrace, Tcl_CreateObjTrace, Tcl_DeleteTrace \- arrange for command exec
 Tcl_Trace
 \fBTcl_CreateTrace\fR(\fIinterp, level, proc, clientData\fR)
 .sp
-Tcl_Trace
-\fBTcl_CreateObjTrace\fR(\fIinterp, level, flags, objProc, clientData, deleteProc\fR)
-.sp
 \fBTcl_DeleteTrace\fR(\fIinterp, trace\fR)
 .SH ARGUMENTS
-.AS Tcl_CmdObjTraceDeleteProc *deleteProc
+.AS Tcl_CmdTraceProc (clientData)()
 .AP Tcl_Interp *interp in
 Interpreter containing command to be traced or untraced.
 .AP int level in
-Only commands at or below this nesting level will be traced unless
-0 is specified.  1 means
+Only commands at or below this nesting level will be traced.  1 means
 top-level commands only, 2 means top-level commands or those that are
 invoked as immediate consequences of executing top-level commands
 (procedure bodies, bracketed commands, etc.) and so on.
-A value of 0 means that commands at any level are traced.
-.AP int flags in
-Flags governing the trace execution.  See below for details.
-.AP Tcl_CmdObjTraceProc *objProc in
-Procedure to call for each command that is executed.  See below for
-details of the calling sequence.
 .AP Tcl_CmdTraceProc *proc in
-Procedure to call for each command that is executed.  See below for
+Procedure to call for each command that's executed.  See below for
 details on the calling sequence.
 .AP ClientData clientData in
-Arbitrary one-word value to pass to \fIobjProc\fR or \fIproc\fR.
-.AP Tcl_CmdObjTraceDeleteProc *deleteProc in
-Procedure to call when the trace is deleted.  See below for details of
-the calling sequence.  A NULL pointer is permissible and results in no
-callback when the trace is deleted.
+Arbitrary one-word value to pass to \fIproc\fR.
 .AP Tcl_Trace trace in
 Token for trace to be removed (return value from previous call
 to \fBTcl_CreateTrace\fR).
 .BE
+
 .SH DESCRIPTION
 .PP
-\fBTcl_CreateObjTrace\fR arranges for command tracing.  After it is
-called, \fIobjProc\fR will be invoked before the Tcl interpreter calls
-any command procedure when evaluating commands in \fIinterp\fR.
-The return value from \fBTcl_CreateObjTrace\fR is a token for the trace,
-which may be passed to \fBTcl_DeleteTrace\fR to remove the trace.
-There may be many traces in effect simultaneously for the same
-interpreter.
+\fBTcl_CreateTrace\fR arranges for command tracing.  From now on, \fIproc\fR
+will be invoked before Tcl calls command procedures to process
+commands in \fIinterp\fR.  The return value from
+\fBTcl_CreateTrace\fR is a token for the trace,
+which may be passed to \fBTcl_DeleteTrace\fR to remove the trace.  There may
+be many traces in effect simultaneously for the same command interpreter.
 .PP
-\fIobjProc\fR should have arguments and result that match the type,
-\fBTcl_CmdObjTraceProc\fR:
+\fIProc\fR should have arguments and result that match the
+type \fBTcl_CmdTraceProc\fR:
 .CS
-typedef int \fBTcl_CmdObjTraceProc\fR( 
-        \fBClientData\fR \fIclientData\fR,
-        \fBTcl_Interp\fR* \fIinterp\fR,
-        int \fIlevel\fR,
-        const char *\fIcommand\fR,
-        \fBTcl_Command\fR \fIcommandToken\fR,
-        int \fIobjc\fR,
-        \fBTcl_Obj\fR *const \fIobjv\fR[] );
+typedef void Tcl_CmdTraceProc(
+	ClientData \fIclientData\fR,
+	Tcl_Interp *\fIinterp\fR,
+	int \fIlevel\fR,
+	char *\fIcommand\fR,
+	Tcl_CmdProc *\fIcmdProc\fR,
+	ClientData \fIcmdClientData\fR,
+	int \fIargc\fR,
+	char *\fIargv\fR[]);
 .CE
-The \fIclientData\fR and \fIinterp\fR parameters are copies of the
-corresponding arguments given to \fBTcl_CreateTrace\fR.
-\fIClientData\fR typically points to an application-specific data
-structure that describes what to do when \fIobjProc\fR is invoked.  The
-\fIlevel\fR parameter gives the nesting level of the command (1 for
-top-level commands passed to \fBTcl_Eval\fR by the application, 2 for
-the next-level commands passed to \fBTcl_Eval\fR as part of parsing or
-interpreting level-1 commands, and so on). The \fIcommand\fR parameter
-points to a string containing the text of the command, before any
-argument substitution.  The \fIcommandToken\fR parameter is a Tcl
-command token that identifies the command to be invoked.  The token
-may be passed to \fBTcl_GetCommandName\fR,
-\fBTcl_GetCommandInfoFromToken\fR, or \fBTcl_SetCommandInfoFromToken\fR to
-manipulate the definition of the command. The \fIobjc\fR and \fIobjv\fR
-parameters designate the final parameter count and parameter vector
-that will be passed to the command, and have had all substitutions
-performed.
-.PP
-The \fIobjProc\fR callback is expected to return a standard Tcl status
-return code.  If this code is \fBTCL_OK\fR (the normal case), then
-the Tcl interpreter will invoke the command.  Any other return code
-is treated as if the command returned that status, and the command is
-\fInot\fR invoked.
-.PP
-The \fIobjProc\fR callback must not modify \fIobjv\fR in any way.  It
-is, however, permissible to change the command by calling
-\fBTcl_SetCommandTokenInfo\fR prior to returning.  Any such change
-takes effect immediately, and the command is invoked with the new
-information.
+The \fIclientData\fR and \fIinterp\fR parameters are
+copies of the corresponding arguments given to \fBTcl_CreateTrace\fR.
+\fIClientData\fR typically points to an application-specific
+data structure that describes what to do when \fIproc\fR
+is invoked.  \fILevel\fR gives the nesting level of the command
+(1 for top-level commands passed to \fBTcl_Eval\fR by the application,
+2 for the next-level commands passed to \fBTcl_Eval\fR as part of parsing
+or interpreting level-1 commands, and so on).  \fICommand\fR
+points to a string containing the text of the
+command, before any argument substitution.
+\fICmdProc\fR contains the address of the command procedure that
+will be called to process the command (i.e. the \fIproc\fR argument
+of some previous call to \fBTcl_CreateCommand\fR) and \fIcmdClientData\fR
+contains the associated client data for \fIcmdProc\fR (the \fIclientData\fR
+value passed to \fBTcl_CreateCommand\fR).  \fIArgc\fR and \fIargv\fR give
+the final argument information that will be passed to \fIcmdProc\fR, after
+command, variable, and backslash substitution.
+\fIProc\fR must not modify the \fIcommand\fR or \fIargv\fR strings.
 .PP
 Tracing will only occur for commands at nesting level less than
 or equal to the \fIlevel\fR parameter (i.e. the \fIlevel\fR
-parameter to \fIobjProc\fR will always be less than or equal to the
+parameter to \fIproc\fR will always be less than or equal to the
 \fIlevel\fR parameter to \fBTcl_CreateTrace\fR).
 .PP
-Tracing has a significant effect on runtime performance because it
-causes the bytecode compiler to refrain from generating in-line code
-for Tcl commands such as \fBif\fR and \fBwhile\fR in order that they
-may be traced.  If traces for the built-in commands are not required,
-the \fIflags\fR parameter may be set to the constant value
-\fBTCL_ALLOW_INLINE_COMPILATION\fR.  In this case, traces on built-in
-commands may or may not result in trace callbacks, depending on the
-state of the interpreter, but run-time performance will be improved
-significantly.  (This functionality is desirable, for example, when
-using \fBTcl_CreateObjTrace\fR to implement an execution time
-profiler.)
-.PP
-Calls to \fIobjProc\fR will be made by the Tcl parser immediately before
+Calls to \fIproc\fR will be made by the Tcl parser immediately before
 it calls the command procedure for the command (\fIcmdProc\fR).  This
 occurs after argument parsing and substitution, so tracing for
 substituted commands occurs before tracing of the commands
@@ -128,58 +93,14 @@ containing the substitutions.  If there is a syntax error in a
 command, or if there is no command procedure associated with a
 command name, then no tracing will occur for that command.  If a
 string passed to Tcl_Eval contains multiple commands (bracketed, or
-on different lines) then multiple calls to \fIobjProc\fR will occur,
-one for each command.
+on different lines) then multiple calls to \fIproc\fR will occur,
+one for each command.  The \fIcommand\fR string for each of these
+trace calls will reflect only a single command, not the entire string
+passed to Tcl_Eval.
 .PP
 \fBTcl_DeleteTrace\fR removes a trace, so that no future calls will be
 made to the procedure associated with the trace.  After \fBTcl_DeleteTrace\fR
 returns, the caller should never again use the \fItrace\fR token.
-.PP
-When \fBTcl_DeleteTrace\fR is called, the interpreter invokes the
-\fIdeleteProc\fR that was passed as a parameter to
-\fBTcl_CreateObjTrace\fR.  The \fIdeleteProc\fR must match the type,
-\fBTcl_CmdObjTraceDeleteProc\fR:
-.CS
-typedef void \fBTcl_CmdObjTraceDeleteProc\fR( 
-        \fBClientData\fR \fIclientData\fR);
-.CE
-The \fIclientData\fR parameter will be the same as the
-\fIclientData\fR parameter that was originally passed to
-\fBTcl_CreateObjTrace\fR.
-.PP
-\fBTcl_CreateTrace\fR is an alternative interface for command tracing,
-\fInot recommended for new applications\fR.  It is provided for backward
-compatibility with code that was developed for older versions of the
-Tcl interpreter.  It is similar to \fBTcl_CreateObjTrace\fR, except
-that its \fIproc\fR parameter should have arguments and result that
-match the type \fBTcl_CmdTraceProc\fR:
-.CS
-typedef void Tcl_CmdTraceProc(
-        ClientData \fIclientData\fR,
-        Tcl_Interp *\fIinterp\fR,
-        int \fIlevel\fR,
-        char *\fIcommand\fR,
-        Tcl_CmdProc *\fIcmdProc\fR,
-        ClientData \fIcmdClientData\fR,
-        int \fIargc\fR,
-        const char *\fIargv\fR[]);
-.CE
-The parameters to the \fIproc\fR callback are similar to those of the
-\fIobjProc\fR callback above. The \fIcommandToken\fR is
-replaced with \fIcmdProc\fR, a pointer to the (string-based) command
-procedure that will be invoked; and \fIcmdClientData\fR, the client
-data that will be passed to the procedure.  The \fIobjc\fR parameter
-is replaced with an \fIargv\fR parameter, that gives the arguments to
-the command as character strings.
-\fIProc\fR must not modify the \fIcommand\fR or \fIargv\fR strings.
-.PP
-If a trace created with \fBTcl_CreateTrace\fR is in effect, inline
-compilation of Tcl commands such as \fBif\fR and \fBwhile\fR is always
-disabled.  There is no notification when a trace created with
-\fBTcl_CreateTrace\fR is deleted.
-There is no way to be notified when the trace created by
-\fBTcl_CreateTrace\fR is deleted.  There is no way for the \fIproc\fR
-associated with a call to \fBTcl_CreateTrace\fR to abort execution of
-\fIcommand\fR.
+
 .SH KEYWORDS
 command, create, delete, interpreter, trace
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: DString.3,v 1.8 2002/01/17 15:24:43 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_DString 3 7.4 Tcl "Tcl Library Procedures"
 .BS
@@ -16,11 +18,11 @@ Tcl_DStringInit, Tcl_DStringAppend, Tcl_DStringAppendElement, Tcl_DStringStartSu
 .sp
 \fBTcl_DStringInit\fR(\fIdsPtr\fR)
 .sp
-char *
-\fBTcl_DStringAppend\fR(\fIdsPtr, bytes, length\fR)
+CONST char *
+\fBTcl_DStringAppend\fR(\fIdsPtr, string, length\fR)
 .sp
-char *
-\fBTcl_DStringAppendElement\fR(\fIdsPtr, element\fR)
+CONST char *
+\fBTcl_DStringAppendElement\fR(\fIdsPtr, string\fR)
 .sp
 \fBTcl_DStringStartSublist\fR(\fIdsPtr\fR)
 .sp
@@ -42,15 +44,13 @@ char *
 .sp
 \fBTcl_DStringGetResult\fR(\fIinterp, dsPtr\fR)
 .SH ARGUMENTS
-.AS Tcl_DString newLength in/out
+.AS Tcl_DString newLength
 .AP Tcl_DString *dsPtr in/out
 Pointer to structure that is used to manage a dynamic string.
-.AP "const char" *bytes in
-Pointer to characters to append to dynamic string.
-.AP "const char" *element in
-Pointer to characters to append as list element to dynamic string.
+.AP "CONST char" *string in
+Pointer to characters to add to dynamic string.
 .AP int length in
-Number of bytes from \fIbytes\fR to add to dynamic string.  If -1,
+Number of characters from string to add to dynamic string.  If -1,
 add all characters up to null terminating character.
 .AP int newLength in
 New length for dynamic string, not including null terminating
@@ -77,7 +77,7 @@ string.
 .PP
 \fBTcl_DStringAppend\fR adds new information to a dynamic string,
 allocating more memory for the string if needed.
-If \fIlength\fR is less than zero then everything in \fIbytes\fR
+If \fIlength\fR is less than zero then everything in \fIstring\fR
 is appended to the dynamic string;  otherwise \fIlength\fR
 specifies the number of bytes to append.
 \fBTcl_DStringAppend\fR returns a pointer to the characters of
@@ -85,16 +85,14 @@ the new string.  The string can also be retrieved from the
 \fIstring\fR field of the Tcl_DString structure.
 .PP
 \fBTcl_DStringAppendElement\fR is similar to \fBTcl_DStringAppend\fR
-except that it does not take a \fIlength\fR argument (it appends
-all of \fIelement\fR) and it converts the string to a proper list element
+except that it doesn't take a \fIlength\fR argument (it appends
+all of \fIstring\fR) and it converts the string to a proper list element
 before appending.
 \fBTcl_DStringAppendElement\fR adds a separator space before the
 new list element unless the new list element is the first in a
 list or sub-list (i.e. either the current string is empty, or it
-contains the single character
-.QW { ,
-or the last two characters of the current string are
-.QW " {" ).
+contains the single character ``{'', or the last two characters of
+the current string are `` {'').
 \fBTcl_DStringAppendElement\fR returns a pointer to the
 characters of the new string.
 .PP
@@ -132,7 +130,7 @@ will still need to be called.
 This procedure is now deprecated.  \fBTcl_DStringSetLength\fR  should
 be used instead.
 .PP
-\fBTcl_DStringFree\fR should be called when you are finished using
+\fBTcl_DStringFree\fR should be called when you're finished using
 the string.  It frees up any memory that was allocated for the string
 and reinitializes the string's value to an empty string.
 .PP
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: DetachPids.3,v 1.3 2001/04/03 14:53:45 andreas_kupries Exp $
+'\" 
 .so man.macros
 .TH Tcl_DetachPids 3 "" Tcl "Tcl Library Procedures"
 .BS
@@ -19,18 +21,18 @@ Tcl_DetachPids, Tcl_ReapDetachedProcs, Tcl_WaitPid \- manage child processes in
 \fBTcl_ReapDetachedProcs\fR()
 .sp
 Tcl_Pid
-\fBTcl_WaitPid\fR(\fIpid, statusPtr, options\fR)
+\fBTcl_WaitPid\fR(\fIpid, statPtr, options\fR)
 .SH ARGUMENTS
-.AS Tcl_Pid *statusPtr out
+.AS int *statusPtr
 .AP int numPids in
 Number of process ids contained in the array pointed to by \fIpidPtr\fR.
 .AP int *pidPtr in
 Address of array containing \fInumPids\fR process ids.
 .AP Tcl_Pid pid in
 The id of the process (pipe) to wait for.
-.AP int *statusPtr out
+.AP int* statPtr out
 The result of waiting on a process (pipe). Either 0 or ECHILD.
-.AP int options in
+.AP int options
 The options controlling the wait. WNOHANG specifies not to wait when
 checking the process.
 .BE
@@ -49,16 +51,16 @@ overflow, even if all the children have exited.
 \fBTcl_DetachPids\fR may be called to ask Tcl to take responsibility
 for one or more processes whose process ids are contained in the
 \fIpidPtr\fR array passed as argument.  The caller presumably
-has started these processes running in background and does not
+has started these processes running in background and doesn't
 want to have to deal with them again.
 .PP
 \fBTcl_ReapDetachedProcs\fR invokes the \fBwaitpid\fR kernel call
 on each of the background processes so that its state can be cleaned
-up if it has exited.  If the process has not exited yet,
-\fBTcl_ReapDetachedProcs\fR does not wait for it to exit;  it will check again
+up if it has exited.  If the process hasn't exited yet,
+\fBTcl_ReapDetachedProcs\fR doesn't wait for it to exit;  it will check again
 the next time it is invoked.
 Tcl automatically calls \fBTcl_ReapDetachedProcs\fR each time the
-\fBexec\fR command is executed, so in most cases it is not necessary
+\fBexec\fR command is executed, so in most cases it isn't necessary
 for any code outside of Tcl to invoke \fBTcl_ReapDetachedProcs\fR.
 However, if you call \fBTcl_DetachPids\fR in situations where the
 \fBexec\fR command may never get executed, you may wish to call
@@ -1,234 +0,0 @@
-'\"
-'\" Copyright (c) 2003 Donal K. Fellows
-'\"
-'\" See the file "license.terms" for information on usage and redistribution
-'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-'\" 
-.so man.macros
-.TH Tcl_DictObj 3 8.5 Tcl "Tcl Library Procedures"
-.BS
-'\" Note:  do not modify the .SH NAME line immediately below!
-.SH NAME
-Tcl_NewDictObj, Tcl_DictObjPut, Tcl_DictObjGet, Tcl_DictObjRemove, Tcl_DictObjSize, Tcl_DictObjFirst, Tcl_DictObjNext, Tcl_DictObjDone, Tcl_DictObjPutKeyList, Tcl_DictObjRemoveKeyList \- manipulate Tcl objects as dictionaries
-.SH SYNOPSIS
-.nf
-\fB#include <tcl.h>\fR
-.sp
-Tcl_Obj *
-\fBTcl_NewDictObj\fR()
-.sp
-int
-\fBTcl_DictObjGet\fR(\fIinterp, dictPtr, keyPtr, valuePtrPtr\fR)
-.sp
-int
-\fBTcl_DictObjPut\fR(\fIinterp, dictPtr, keyPtr, valuePtr\fR)
-.sp
-int
-\fBTcl_DictObjRemove\fR(\fIinterp, dictPtr, keyPtr\fR)
-.sp
-int
-\fBTcl_DictObjSize\fR(\fIinterp, dictPtr, sizePtr\fR)
-.sp
-int
-\fBTcl_DictObjFirst\fR(\fIinterp, dictPtr, searchPtr,
-                 keyPtrPtr, valuePtrPtr, donePtr\fR)
-.sp
-void
-\fBTcl_DictObjNext\fR(\fIsearchPtr, keyPtrPtr, valuePtrPtr, donePtr\fR)
-.sp
-void
-\fBTcl_DictObjDone\fR(\fIsearchPtr\fR)
-.sp
-int
-\fBTcl_DictObjPutKeyList\fR(\fIinterp, dictPtr, keyc, keyv, valuePtr\fR)
-.sp
-int
-\fBTcl_DictObjRemoveKeyList\fR(\fIinterp, dictPtr, keyc, keyv\fR)
-.SH ARGUMENTS
-.AS Tcl_DictSearch "**valuePtrPtr" in/out
-.AP Tcl_Interp *interp in
-If an error occurs while converting an object to be a dictionary object,
-an error message is left in the interpreter's result object
-unless \fIinterp\fR is NULL.
-.AP Tcl_Obj *dictPtr in/out
-Points to the dictionary object to be manipulated.
-If \fIdictPtr\fR does not already point to a dictionary object,
-an attempt will be made to convert it to one.
-.AP Tcl_Obj *keyPtr in
-Points to the key for the key/value pair being manipulated within the
-dictionary object.
-.AP Tcl_Obj **keyPtrPtr out
-Points to a variable that will have the key from a key/value pair
-placed within it.  May be NULL to indicate that the caller is not
-interested in the key.
-.AP Tcl_Obj *valuePtr in
-Points to the value for the key/value pair being manipulate within the
-dictionary object (or sub-object, in the case of
-\fBTcl_DictObjPutKeyList\fR.)
-.AP Tcl_Obj **valuePtrPtr out
-Points to a variable that will have the value from a key/value pair
-placed within it.  For \fBTcl_DictObjFirst\fR and
-\fBTcl_DictObjNext\fR, this may be NULL to indicate that the caller is
-not interested in the value.
-.AP int *sizePtr out
-Points to a variable that will have the number of key/value pairs
-contained within the dictionary placed within it.
-.AP Tcl_DictSearch *searchPtr in/out
-Pointer to record to use to keep track of progress in enumerating all
-key/value pairs in a dictionary.  The contents of the record will be
-initialized by the call to \fBTcl_DictObjFirst\fR.  If the enumerating
-is to be terminated before all values in the dictionary have been
-returned, the search record \fImust\fR be passed to
-\fBTcl_DictObjDone\fR to enable the internal locks to be released.
-.AP int *donePtr out
-Points to a variable that will have a non-zero value written into it
-when the enumeration of the key/value pairs in a dictionary has
-completed, and a zero otherwise.
-.AP int keyc in
-Indicates the number of keys that will be supplied in the \fIkeyv\fR
-array.
-.AP "Tcl_Obj *const" *keyv in
-Array of \fIkeyc\fR pointers to objects that
-\fBTcl_DictObjPutKeyList\fR and \fBTcl_DictObjRemoveKeyList\fR will
-use to locate the key/value pair to manipulate within the
-sub-dictionaries of the main dictionary object passed to them.
-.BE
-
-.SH DESCRIPTION
-.PP
-Tcl dictionary objects have an internal representation that supports
-efficient mapping from keys to values and which guarantees that the
-particular ordering of keys within the dictionary remains the same
-modulo any keys being deleted (which removes them from the order) or
-added (which adds them to the end of the order). If reinterpreted as a
-list, the values at the even-valued indices in the list will be the
-keys of the dictionary, and each will be followed (in the odd-valued
-index) by the value associated with that key.
-.PP
-The procedures described in this man page are used to
-create, modify, index, and iterate over dictionary objects from C code.
-.PP
-\fBTcl_NewDictObj\fR creates a new, empty dictionary object.  The
-string representation of the object will be invalid, and the reference
-count of the object will be zero.
-.PP
-\fBTcl_DictObjGet\fR looks up the given key within the given
-dictionary and writes a pointer to the value associated with that key
-into the variable pointed to by \fIvaluePtrPtr\fR, or a NULL if the
-key has no mapping within the dictionary.  The result of this
-procedure is \fBTCL_OK\fR, or \fBTCL_ERROR\fR if the \fIdictPtr\fR cannot be
-converted to a dictionary.
-.PP
-\fBTcl_DictObjPut\fR updates the given dictionary so that the given
-key maps to the given value; any key may exist at most once in any
-particular dictionary.  The dictionary must not be shared, but the key
-and value may be.  This procedure may increase the reference count of
-both key and value if it proves necessary to store them.  Neither key
-nor value should be NULL.  The result of this procedure is \fBTCL_OK\fR, or
-\fBTCL_ERROR\fR if the \fIdictPtr\fR cannot be converted to a dictionary.
-.PP
-\fBTcl_DictObjRemove\fR updates the given dictionary so that the given
-key has no mapping to any value.  The dictionary must not be shared,
-but the key may be.  The key actually stored in the dictionary will
-have its reference count decremented if it was present.  It is not an
-error if the key did not previously exist.  The result of this
-procedure is \fBTCL_OK\fR, or \fBTCL_ERROR\fR if the \fIdictPtr\fR cannot be
-converted to a dictionary.
-.PP
-\fBTcl_DictObjSize\fR updates the given variable with the number of
-key/value pairs currently in the given dictionary. The result of this
-procedure is \fBTCL_OK\fR, or \fBTCL_ERROR\fR if the \fIdictPtr\fR cannot be
-converted to a dictionary.
-.PP
-\fBTcl_DictObjFirst\fR commences an iteration across all the key/value
-pairs in the given dictionary, placing the key and value in the
-variables pointed to by the \fIkeyPtrPtr\fR and \fIvaluePtrPtr\fR
-arguments (which may be NULL to indicate that the caller is
-uninterested in they key or variable respectively.)  The next
-key/value pair in the dictionary may be retrieved with
-\fBTcl_DictObjNext\fR.  Concurrent updates of the dictionary's
-internal representation will not modify the iteration processing
-unless the dictionary is unshared, when this will trigger premature
-termination of the iteration instead (which Tcl scripts cannot trigger
-via the \fBdict\fR command.)  The \fIsearchPtr\fR argument points to a
-piece of context that is used to identify which particular iteration
-is being performed, and is initialized by the call to
-\fBTcl_DictObjFirst\fR.  The \fIdonePtr\fR argument points to a
-variable that is updated to be zero of there are further key/value
-pairs to be iterated over, or non-zero if the iteration is complete.
-The order of iteration is implementation-defined.  If the
-\fIdictPtr\fR argument cannot be converted to a dictionary,
-\fBTcl_DictObjFirst\fR returns \fBTCL_ERROR\fR and the iteration is not
-commenced, and otherwise it returns \fBTCL_OK\fR.
-.PP
-When \fBTcl_DictObjFirst\fR is called upon a dictionary, a lock is placed on
-the dictionary to enable that dictionary to be iterated over safely without
-regard for whether the dictionary is modified during the iteration. Because of
-this, once the iteration over a dictionary's keys has finished (whether
-because all values have been iterated over as indicated by the variable
-indicated by the \fIdonePtr\fR argument being set to one, or because no
-further values are required) the \fBTcl_DictObjDone\fR function must be called
-with the same \fIsearchPtr\fR as was passed to \fBTcl_DictObjFirst\fR so that
-the internal locks can be released. Once a particular \fIsearchPtr\fR is
-passed to \fBTcl_DictObjDone\fR, passing it to \fBTcl_DictObjNext\fR (without
-first initializing it with \fBTcl_DictObjFirst\fR) will result in no values
-being produced and the variable pointed to by \fIdonePtr\fR being set to one.
-It is safe to call \fBTcl_DictObjDone\fR multiple times on the same
-\fIsearchPtr\fR for each call to \fBTcl_DictObjFirst\fR.
-.PP
-The procedures \fBTcl_DictObjPutKeyList\fR and
-\fBTcl_DictObjRemoveKeyList\fR are the close analogues of
-\fBTcl_DictObjPut\fR and \fBTcl_DictObjRemove\fR respectively, except
-that instead of working with a single dictionary, they are designed to
-operate on a nested tree of dictionaries, with inner dictionaries
-stored as values inside outer dictionaries.  The \fIkeyc\fR and
-\fIkeyv\fR arguments specify a list of keys (with outermost keys
-first) that acts as a path to the key/value pair to be affected.  Note
-that there is no corresponding operation for reading a value for a
-path as this is easy to construct from repeated use of
-\fBTcl_DictObjGet\fR. With \fBTcl_DictObjPutKeyList\fR, nested
-dictionaries are created for non-terminal keys where they do not
-already exist. With \fBTcl_DictObjRemoveKeyList\fR, all non-terminal
-keys must exist and have dictionaries as their values.
-.SH EXAMPLE
-Using the dictionary iteration interface to search determine if there
-is a key that maps to itself:
-.PP
-.CS
-Tcl_DictSearch search;
-Tcl_Obj *key, *value;
-int done;
-
-/*
- * Assume interp and objPtr are parameters.  This is the
- * idiomatic way to start an iteration over the dictionary; it
- * sets a lock on the internal representation that ensures that
- * there are no concurrent modification issues when normal
- * reference count management is also used.  The lock is
- * released automatically when the loop is finished, but must
- * be released manually when an exceptional exit from the loop
- * is performed. However it is safe to try to release the lock
- * even if we've finished iterating over the loop.
- */
-if (\fBTcl_DictObjFirst\fR(interp, objPtr, &search,
-        &key, &value, &done) != TCL_OK) {
-    return TCL_ERROR;
-}
-for (; !done ; \fBTcl_DictObjNext\fR(&search, &key, &value, &done)) {
-    /*
-     * Note that strcmp() is not a good way of comparing
-     * objects and is just used here for demonstration
-     * purposes.
-     */
-    if (!strcmp(Tcl_GetString(key), Tcl_GetString(value))) {
-        break;
-    }
-}
-\fBTcl_DictObjDone\fR(&search);
-Tcl_SetObjResult(interp, Tcl_NewBooleanObj(!done));
-return TCL_OK;
-.CE
-.SH "SEE ALSO"
-Tcl_NewObj, Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_InitObjHashTable
-.SH KEYWORDS
-dict, dict object, dictionary, dictionary object, hash table, iteration, object
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: DoOneEvent.3,v 1.2 1998/09/14 18:39:48 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_DoOneEvent 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -21,9 +23,9 @@ int
 .AP int flags in
 This parameter is normally zero.  It may be an OR-ed combination
 of any of the following flag bits:  
-\fBTCL_WINDOW_EVENTS\fR, \fBTCL_FILE_EVENTS\fR,
-\fBTCL_TIMER_EVENTS\fR, \fBTCL_IDLE_EVENTS\fR, \fBTCL_ALL_EVENTS\fR,
-or \fBTCL_DONT_WAIT\fR.
+TCL_WINDOW_EVENTS,
+TCL_FILE_EVENTS, TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, TCL_ALL_EVENTS, or
+TCL_DONT_WAIT.
 .BE

 .SH DESCRIPTION
@@ -71,7 +73,7 @@ Process all kinds of events:  equivalent to OR-ing together all of the
 above flags or specifying none of them.
 .TP 27
 \fBTCL_DONT_WAIT\fR \-
-Do not sleep:  process only events that are ready at the time of the
+Don't sleep:  process only events that are ready at the time of the
 call.
 .LP
 If any of the flags \fBTCL_WINDOW_EVENTS\fR, \fBTCL_FILE_EVENTS\fR,
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: DoWhenIdle.3,v 1.2 1998/09/14 18:39:48 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_DoWhenIdle 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -30,7 +32,7 @@ Arbitrary one-word value to pass to \fIproc\fR.
 \fBTcl_DoWhenIdle\fR arranges for \fIproc\fR to be invoked
 when the application becomes idle.  The application is
 considered to be idle when \fBTcl_DoOneEvent\fR has been
-called, could not find any events to handle, and is about
+called, couldn't find any events to handle, and is about
 to go to sleep waiting for an event to occur.  At this
 point all pending \fBTcl_DoWhenIdle\fR handlers are
 invoked.  For each call to \fBTcl_DoWhenIdle\fR there will
@@ -59,7 +61,7 @@ all of the handlers are removed.  If no existing handlers match
 \fIproc\fR and \fIclientData\fR then nothing happens.
 .PP
 \fBTcl_DoWhenIdle\fR is most useful in situations where
-(a) a piece of work will have to be done but (b) it is
+(a) a piece of work will have to be done but (b) it's
 possible that something will happen in the near future
 that will change what has to be done or require something
 different to be done.  \fBTcl_DoWhenIdle\fR allows the
@@ -4,6 +4,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: DoubleObj.3,v 1.2 1998/09/14 18:39:48 stanton Exp $
+'\" 
 .so man.macros
 .TH Tcl_DoubleObj 3 8.0 Tcl "Tcl Library Procedures"
 .BS
@@ -23,42 +25,55 @@ int
 .SH ARGUMENTS
 .AS Tcl_Interp doubleValue in/out
 .AP double doubleValue in
-A double-precision floating-point value used to initialize or set a Tcl object.
+A double-precision floating point value used to initialize or set a double object.
 .AP Tcl_Obj *objPtr in/out
-For \fBTcl_SetDoubleObj\fR, this points to the object in which to store a
-double value.
+For \fBTcl_SetDoubleObj\fR, this points to the object to be converted
+to double type.
 For \fBTcl_GetDoubleFromObj\fR, this refers to the object
-from which to retrieve a double value. 
+from which to get a double value; 
+if \fIobjPtr\fR does not already point to a double object,
+an attempt will be made to convert it to one.
 .AP Tcl_Interp *interp in/out
-When non-NULL, an error message is left here when double value retrieval fails.
+If an error occurs during conversion,
+an error message is left in the interpreter's result object
+unless \fIinterp\fR is NULL.
 .AP double *doublePtr out
-Points to place to store the double value obtained from \fIobjPtr\fR.
+Points to place to store the double value
+obtained from \fIobjPtr\fR.
 .BE

 .SH DESCRIPTION
 .PP
-These procedures are used to create, modify, and read Tcl objects that
-hold double-precision floating-point values.
+These procedures are used to create, modify, and read
+double Tcl objects from C code.
+\fBTcl_NewDoubleObj\fR and \fBTcl_SetDoubleObj\fR
+will create a new object of double type
+or modify an existing object to have double type. 
+Both of these procedures set the object to have the
+double-precision floating point value given by \fIdoubleValue\fR;
+\fBTcl_NewDoubleObj\fR returns a pointer to a newly created object
+with reference count zero.
+Both procedures set the object's type to be double
+and assign the double value to the object's internal representation
+\fIdoubleValue\fR member.
+\fBTcl_SetDoubleObj\fR invalidates any old string representation
+and, if the object is not already a double object,
+frees any old internal representation.
 .PP
-\fBTcl_NewDoubleObj\fR creates and returns a new Tcl object initialized to
-the double value \fIdoubleValue\fR.  The returned Tcl object is unshared.
-.PP
-\fBTcl_SetDoubleObj\fR sets the value of an existing Tcl object pointed to
-by \fIobjPtr\fR to the double value \fIdoubleValue\fR.  The \fIobjPtr\fR
-argument must point to an unshared Tcl object.  Any attempt to set the value
-of a shared Tcl object violates Tcl's copy-on-write policy.  Any existing
-string representation or internal representation in the unshared Tcl object
-will be freed as a consequence of setting the new value.
-.PP
-\fBTcl_GetDoubleFromObj\fR attempts to retrieve a double value from the
-Tcl object \fIobjPtr\fR.  If the attempt succeeds, then \fBTCL_OK\fR is
-returned, and the double value is written to the storage pointed to by
-\fIdoublePtr\fR.  If the attempt fails, then \fBTCL_ERROR\fR is returned,
-and if \fIinterp\fR is non-NULL, an error message is left in \fIinterp\fR.
-The \fBTcl_ObjType\fR of \fIobjPtr\fR may be changed to make subsequent
-calls to \fBTcl_GetDoubleFromObj\fR more efficient. 
-'\" TODO: add discussion of treatment of NaN value
+\fBTcl_GetDoubleFromObj\fR attempts to return a double value
+from the Tcl object \fIobjPtr\fR.
+If the object is not already a double object,
+it will attempt to convert it to one.
+If an error occurs during conversion, it returns \fBTCL_ERROR\fR
+and leaves an error message in the interpreter's result object
+unless \fIinterp\fR is NULL.
+Otherwise, it returns \fBTCL_OK\fR and stores the double value
+in the address given by \fIdoublePtr\fR.
+If the object is not already a double object,
+the conversion will free any old internal representation.
+
 .SH "SEE ALSO"
 Tcl_NewObj, Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_GetObjResult
+
 .SH KEYWORDS
 double, double object, double type, internal representation, object, object type, string representation
@@ -3,11 +3,13 @@
 '\" Copyright (c) 2000 by Scriptics Corporation.
 '\" All rights reserved.
 '\" 
+'\" RCS: @(#) $Id: DumpActiveMemory.3,v 1.5 2001/12/28 23:36:31 dgp Exp $
+'\" 
 .so man.macros
 .TH "Tcl_DumpActiveMemory" 3 8.1 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_DumpActiveMemory, Tcl_InitMemory, Tcl_ValidateAllMemory \- Validated memory allocation interface
+Tcl_DumpActiveMemory, Tcl_InitMemory, Tcl_ValidateAllMemory \- Validated memory allocation interface.
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -22,10 +24,9 @@ void
 \fBTcl_ValidateAllMemory\fR(\fIfileName, line\fR)

 .SH ARGUMENTS
-.AS Tcl_Interp *fileName
 .AP Tcl_Interp *interp in
 Tcl interpreter in which to add commands.
-.AP "const char" *fileName in
+.AP "CONST char" *fileName in
 For \fBTcl_DumpActiveMemory\fR, name of the file to which memory
 information will be written.  For \fBTcl_ValidateAllMemory\fR, name of
 the file from which the call is being made (normally \fB__FILE__\fR).
@@ -4,11 +4,13 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Encoding.3,v 1.7 1999/10/13 00:32:05 hobbs Exp $
+'\" 
 .so man.macros
 .TH Tcl_GetEncoding 3 "8.1" Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_GetEncoding, Tcl_FreeEncoding, Tcl_GetEncodingFromObj, Tcl_ExternalToUtfDString, Tcl_ExternalToUtf, Tcl_UtfToExternalDString, Tcl_UtfToExternal, Tcl_WinTCharToUtf, Tcl_WinUtfToTChar, Tcl_GetEncodingName, Tcl_SetSystemEncoding, Tcl_GetEncodingNameFromEnvironment, Tcl_GetEncodingNames, Tcl_CreateEncoding, Tcl_GetEncodingSearchPath, Tcl_SetEncodingSearchPath, Tcl_GetDefaultEncodingDir, Tcl_SetDefaultEncodingDir \- procedures for creating and using encodings
+Tcl_GetEncoding, Tcl_FreeEncoding, Tcl_ExternalToUtfDString, Tcl_ExternalToUtf, Tcl_UtfToExternalDString, Tcl_UtfToExternal, Tcl_WinTCharToUtf, Tcl_WinUtfToTChar, Tcl_GetEncodingName, Tcl_SetSystemEncoding, Tcl_GetEncodingNames, Tcl_CreateEncoding, Tcl_GetDefaultEncodingDir, Tcl_SetDefaultEncodingDir \- procedures for creating and using encodings.
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -19,24 +21,19 @@ Tcl_Encoding
 void
 \fBTcl_FreeEncoding\fR(\fIencoding\fR)
 .sp
-.VS 8.5
-int
-\fBTcl_GetEncodingFromObj\fR(\fIinterp, objPtr, encodingPtr\fR)
-.VE 8.5
-.sp
 char *
 \fBTcl_ExternalToUtfDString\fR(\fIencoding, src, srcLen, dstPtr\fR)
 .sp
-char *
+int
+\fBTcl_ExternalToUtf\fR(\fIinterp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, 
+	dstCharsPtr\fR)
+.sp
+char * 
 \fBTcl_UtfToExternalDString\fR(\fIencoding, src, srcLen, dstPtr\fR)
 .sp
 int
-\fBTcl_ExternalToUtf\fR(\fIinterp, encoding, src, srcLen, flags, statePtr,
-                  dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr\fR)
-.sp
-int
-\fBTcl_UtfToExternal\fR(\fIinterp, encoding, src, srcLen, flags, statePtr,
-                  dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr\fR)
+\fBTcl_UtfToExternal\fR(\fIinterp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, 
+	dstCharsPtr\fR)
 .sp
 char *
 \fBTcl_WinTCharToUtf\fR(\fItsrc, srcLen, dstPtr\fR)
@@ -44,60 +41,41 @@ char *
 TCHAR *
 \fBTcl_WinUtfToTChar\fR(\fIsrc, srcLen, dstPtr\fR)
 .sp
-const char *
+char *
 \fBTcl_GetEncodingName\fR(\fIencoding\fR)
 .sp
 int
 \fBTcl_SetSystemEncoding\fR(\fIinterp, name\fR)
 .sp
-.VS 8.5
-const char *
-\fBTcl_GetEncodingNameFromEnvironment\fR(\fIbufPtr\fR)
-.VE 8.5
-.sp
 void
 \fBTcl_GetEncodingNames\fR(\fIinterp\fR)
 .sp
 Tcl_Encoding
 \fBTcl_CreateEncoding\fR(\fItypePtr\fR)
 .sp
-.VS 8.5
-Tcl_Obj *
-\fBTcl_GetEncodingSearchPath\fR()
-.sp
-int
-\fBTcl_SetEncodingSearchPath\fR(\fIsearchPath\fR)
-.VE 8.5
-.sp
-const char *
+char *
 \fBTcl_GetDefaultEncodingDir\fR(\fIvoid\fR)
 .sp
 void
 \fBTcl_SetDefaultEncodingDir\fR(\fIpath\fR)
+
+
 .SH ARGUMENTS
-.AS "const Tcl_EncodingType" *dstWrotePtr in/out
+.AS Tcl_EncodingState *dstWrotePtr
 .AP Tcl_Interp *interp in
 Interpreter to use for error reporting, or NULL if no error reporting is
 desired.
-.AP "const char" *name in
+.AP "CONST char" *name in
 Name of encoding to load.
 .AP Tcl_Encoding encoding in
 The encoding to query, free, or use for converting text.  If \fIencoding\fR is 
 NULL, the current system encoding is used.
-.AP Tcl_Obj *objPtr in
-.VS 8.5
-Name of encoding to get token for.
-.VE 8.5
-.AP Tcl_Encoding *encodingPtr out
-.VS 8.5
-Points to storage where encoding token is to be written.
-.VE 8.5
-.AP "const char" *src in
+.AP "CONST char" *src in
 For the \fBTcl_ExternalToUtf\fR functions, an array of bytes in the
 specified encoding that are to be converted to UTF-8.  For the
 \fBTcl_UtfToExternal\fR and \fBTcl_WinUtfToTChar\fR functions, an array of
 UTF-8 characters to be converted to the specified encoding.  
-.AP "const TCHAR" *tsrc in
+.AP "CONST TCHAR" *tsrc in
 An array of Windows TCHAR characters to convert to UTF-8.
 .AP int srcLen in 
 Length of \fIsrc\fR or \fItsrc\fR in bytes.  If the length is negative, the 
@@ -107,21 +85,21 @@ Pointer to an uninitialized or free \fBTcl_DString\fR in which the converted
 result will be stored.
 .AP int flags in
 Various flag bits OR-ed together.  
-\fBTCL_ENCODING_START\fR signifies that the
+TCL_ENCODING_START signifies that the
 source buffer is the first block in a (potentially multi-block) input
 stream, telling the conversion routine to reset to an initial state and
 perform any initialization that needs to occur before the first byte is
-converted. \fBTCL_ENCODING_END\fR signifies that the source buffer is the last
+converted.  TCL_ENCODING_END signifies that the source buffer is the last
 block in a (potentially multi-block) input stream, telling the conversion
 routine to perform any finalization that needs to occur after the last
 byte is converted and then to reset to an initial state.
-\fBTCL_ENCODING_STOPONERROR\fR signifies that the conversion routine should
-return immediately upon reading a source character that does not exist in
+TCL_ENCODING_STOPONERROR signifies that the conversion routine should
+return immediately upon reading a source character that doesn't exist in
 the target encoding; otherwise a default fallback character will
 automatically be substituted.  
 .AP Tcl_EncodingState *statePtr in/out
 Used when converting a (generally long or indefinite length) byte stream
-in a piece-by-piece fashion.  The conversion routine stores its current
+in a piece by piece fashion.  The conversion routine stores its current
 state in \fI*statePtr\fR after \fIsrc\fR (the buffer containing the
 current piece) has been converted; that state information must be passed
 back when converting the next piece of the stream so the conversion
@@ -144,17 +122,9 @@ buffer as a result of the conversion.  May be NULL.
 .AP int *dstCharsPtr out
 Filled with the number of characters that correspond to the number of bytes
 stored in the output buffer.  May be NULL.
-.AP Tcl_DString *bufPtr out
-.VS 8.5
-Storage for the prescribed system encoding name.
-.VE 8.5
-.AP "const Tcl_EncodingType" *typePtr in
+.AP Tcl_EncodingType *typePtr in
 Structure that defines a new type of encoding.  
-.AP Tcl_Obj *searchPath in
-.VS 8.5
-List of filesystem directories in which to search for encoding data files.
-.VE 8.5
-.AP "const char" *path in
+.AP char *path in
 A path to the location of the encoding file.  
 .BE
 .SH INTRODUCTION
@@ -181,7 +151,7 @@ platform-independent manner.
 .SH DESCRIPTION
 .PP
 \fBTcl_GetEncoding\fR finds an encoding given its \fIname\fR.  The name may
-refer to a built-in Tcl encoding, a user-defined encoding registered by
+refer to a builtin Tcl encoding, a user-defined encoding registered by
 calling \fBTcl_CreateEncoding\fR, or a dynamically-loadable encoding
 file.  The return value is a token that represents the encoding and can be
 used in subsequent calls to procedures such as \fBTcl_GetEncodingName\fR,
@@ -202,23 +172,9 @@ anywhere (i.e., it has been freed as many times as it has been gotten)
 \fBTcl_FreeEncoding\fR will release all storage the encoding was using
 and delete it from the database. 
 .PP
-.VS 8.5
-\fBTcl_GetEncodingFromObj\fR treats the string representation of
-\fIobjPtr\fR as an encoding name, and finds an encoding with that
-name, just as \fBTcl_GetEncoding\fR does. When an encoding is found,
-it is cached within the \fBobjPtr\fR value for future reference, the
-\fBTcl_Encoding\fR token is written to the storage pointed to by
-\fIencodingPtr\fR, and the value \fBTCL_OK\fR is returned. If no such
-encoding is found, the value \fBTCL_ERROR\fR is returned, and no
-writing to \fB*\fR\fIencodingPtr\fR takes place. Just as with
-\fBTcl_GetEncoding\fR, the caller should call \fBTcl_FreeEncoding\fR
-on the resulting encoding token when that token will no longer be
-used.
-.VE 8.5
-.PP
 \fBTcl_ExternalToUtfDString\fR converts a source buffer \fIsrc\fR from the
 specified \fIencoding\fR into UTF-8.  The converted bytes are stored in 
-\fIdstPtr\fR, which is then null-terminated.  The caller should eventually
+\fIdstPtr\fR, which is then NULL terminated.  The caller should eventually
 call \fBTcl_DStringFree\fR to free any information stored in \fIdstPtr\fR.
 When converting, if any of the characters in the source buffer cannot be
 represented in the target encoding, a default fallback character will be
@@ -238,7 +194,7 @@ All bytes of \fIsrc\fR were converted.
 The destination buffer was not large enough for all of the converted data; as
 many characters as could fit were converted though.
 .IP \fBTCL_CONVERT_MULTIBYTE\fR 29
-The last few bytes in the source buffer were the beginning of a multibyte
+The last fews bytes in the source buffer were the beginning of a multibyte
 sequence, but more bytes were needed to complete this sequence.  A
 subsequent call to the conversion routine should pass a buffer containing
 the unconverted bytes that remained in \fIsrc\fR plus some further bytes
@@ -250,13 +206,13 @@ if the input stream has been damaged or if the input encoding method was
 misidentified.
 .IP \fBTCL_CONVERT_UNKNOWN\fR 29
 The source buffer contained a character that could not be represented in
-the target encoding and \fBTCL_ENCODING_STOPONERROR\fR was specified.  
+the target encoding and TCL_ENCODING_STOPONERROR was specified.  
 .RE
 .LP
 \fBTcl_UtfToExternalDString\fR converts a source buffer \fIsrc\fR from UTF-8 
 into the specified \fIencoding\fR.  The converted bytes are stored in
 \fIdstPtr\fR, which is then terminated with the appropriate encoding-specific
-null.  The caller should eventually call \fBTcl_DStringFree\fR to free any
+NULL.  The caller should eventually call \fBTcl_DStringFree\fR to free any
 information stored in \fIdstPtr\fR.  When converting, if any of the
 characters in the source buffer cannot be represented in the target
 encoding, a default fallback character will be used.  The return value is
@@ -274,28 +230,21 @@ is filled with the corresponding number of bytes that were stored in
 \fBTcl_WinUtfToTChar\fR and \fBTcl_WinTCharToUtf\fR are
 Windows-only convenience
 functions for converting between UTF-8 and Windows strings.  On Windows 95
-(as with the Unix operating system),
-all strings exchanged between Tcl and the operating system are
-.QW "char"
+(as with the Macintosh and Unix operating systems),
+all strings exchanged between Tcl and the operating system are "char"
 based.  On Windows NT, some strings exchanged between Tcl and the
-operating system are
-.QW "char"
-oriented while others are in Unicode.  By
+operating system are "char" oriented while others are in Unicode.  By
 convention, in Windows a TCHAR is a character in the ANSI code page
 on Windows 95 and a Unicode character on Windows NT.
 .PP
-If you planned to use the same
-.QW "char"
-based interfaces on both Windows
+If you planned to use the same "char" based interfaces on both Windows
 95 and Windows NT, you could use \fBTcl_UtfToExternal\fR and
 \fBTcl_ExternalToUtf\fR (or their \fBTcl_DString\fR equivalents) with an
 encoding of NULL (the current system encoding).  On the other hand,
 if you planned to use the Unicode interface when running on Windows NT
-and the
-.QW "char"
-interfaces when running on Windows 95, you would have
+and the "char" interfaces when running on Windows 95, you would have
 to perform the following type of test over and over in your program
-(as represented in pseudo-code):
+(as represented in psuedo-code):
 .CS
 if (running NT) {
    encoding <- Tcl_GetEncoding("unicode");
@@ -303,7 +252,6 @@ if (running NT) {
    Tcl_FreeEncoding(encoding);
 } else {
    nativeBuffer <- Tcl_UtfToExternal(NULL, utfBuffer);
-}
 .CE
 \fBTcl_WinUtfToTChar\fR and \fBTcl_WinTCharToUtf\fR automatically
 handle this test and use the proper encoding based on the current
@@ -323,20 +271,11 @@ was used to create the encoding.  The string returned by
 whenever the user passes a NULL value for the \fIencoding\fR argument to
 any of the other encoding functions.  If \fIname\fR is NULL, the system
 encoding is reset to the default system encoding, \fBbinary\fR.  If the
-name did not refer to any known or loadable encoding, \fBTCL_ERROR\fR is
+name did not refer to any known or loadable encoding, TCL_ERROR is
 returned and an error message is left in \fIinterp\fR.  Otherwise, this
 procedure increments the reference count of the new system encoding,
 decrements the reference count of the old system encoding, and returns
-\fBTCL_OK\fR.
-.PP
-.VS 8.5
-\fBTcl_GetEncodingNameFromEnvironment\fR provides a means for the Tcl
-library to report the encoding name it believes to be the correct one
-to use as the system encoding, based on system calls and examination of
-the environment suitable for the platform.  It accepts \fIbufPtr\fR,
-a pointer to an uninitialized or freed \fBTcl_DString\fR and writes
-the encoding name to it.  The \fBTcl_DStringValue\fR is returned.
-.VE 8.5
+TCL_OK.
 .PP
 \fBTcl_GetEncodingNames\fR sets the \fIinterp\fR result to a list
 consisting of the names of all the encodings that are currently defined
@@ -364,12 +303,12 @@ convert between this encoding and UTF-8.  It is defined as follows:
 .PP
 .CS
 typedef struct Tcl_EncodingType {
-        const char *\fIencodingName\fR;
-        Tcl_EncodingConvertProc *\fItoUtfProc\fR;
-        Tcl_EncodingConvertProc *\fIfromUtfProc\fR;
-        Tcl_EncodingFreeProc *\fIfreeProc\fR;
-        ClientData \fIclientData\fR;
-        int \fInullSize\fR;
+	CONST char *\fIencodingName\fR;
+	Tcl_EncodingConvertProc *\fItoUtfProc\fR;
+	Tcl_EncodingConvertProc *\fIfromUtfProc\fR;
+	Tcl_EncodingFreeProc *\fIfreeProc\fR;
+	ClientData \fIclientData\fR;
+	int \fInullSize\fR;
 } Tcl_EncodingType;  
 .CE
 .PP
@@ -399,16 +338,16 @@ type \fBTcl_EncodingConvertProc\fR:
 .PP
 .CS
 typedef int Tcl_EncodingConvertProc(
-        ClientData \fIclientData\fR,
-        const char *\fIsrc\fR, 
-        int \fIsrcLen\fR, 
-        int \fIflags\fR, 
-        Tcl_EncodingState *\fIstatePtr\fR,
-        char *\fIdst\fR, 
-        int \fIdstLen\fR, 
-        int *\fIsrcReadPtr\fR,
-        int *\fIdstWrotePtr\fR,
-        int *\fIdstCharsPtr\fR);
+	ClientData \fIclientData\fR,
+	CONST char *\fIsrc\fR, 
+	int \fIsrcLen\fR, 
+	int \fIflags\fR, 
+	Tcl_Encoding *\fIstatePtr\fR,
+	char *\fIdst\fR, 
+	int \fIdstLen\fR, 
+	int *\fIsrcReadPtr\fR,
+	int *\fIdstWrotePtr\fR,
+	int *\fIdstCharsPtr\fR);
 .CE
 .PP
 The \fItoUtfProc\fR and \fIfromUtfProc\fR procedures are called by the
@@ -430,42 +369,20 @@ The callback procedure \fIfreeProc\fR, if non-NULL, should match the type
 \fBTcl_EncodingFreeProc\fR:
 .CS
 typedef void Tcl_EncodingFreeProc(
-        ClientData \fIclientData\fR);
+	ClientData \fIclientData\fR);
 .CE
 .PP
 This \fIfreeProc\fR function is called when the encoding is deleted.  The
 \fIclientData\fR parameter is the same as the \fIclientData\fR field
 specified to \fBTcl_CreateEncoding\fR when the encoding was created.  
 .PP
-.VS 8.5
-\fBTcl_GetEncodingSearchPath\fR and \fBTcl_SetEncodingSearchPath\fR
-are called to access and set the list of filesystem directories searched
-for encoding data files.  
-.PP
-The value returned by \fBTcl_GetEncodingSearchPath\fR
-is the value stored by the last successful call to
-\fBTcl_SetEncodingSearchPath\fR.  If no calls to
-\fBTcl_SetEncodingSearchPath\fR have occurred, Tcl will compute an initial
-value based on the environment.  There is one encoding search path for the
-entire process, shared by all threads in the process.
-.PP
-\fBTcl_SetEncodingSearchPath\fR stores \fIsearchPath\fR and returns
-\fBTCL_OK\fR, unless \fIsearchPath\fR is not a valid Tcl list, which
-causes \fBTCL_ERROR\fR to be returned.  The elements of \fIsearchPath\fR
-are not verified as existing readable filesystem directories.  When
-searching for encoding data files takes place, and non-existent or
-non-readable filesystem directories on the \fIsearchPath\fR are silently
-ignored.
-.PP
+
 \fBTcl_GetDefaultEncodingDir\fR and \fBTcl_SetDefaultEncodingDir\fR
-are obsolete interfaces best replaced with calls to
-\fBTcl_GetEncodingSearchPath\fR and \fBTcl_SetEncodingSearchPath\fR.
-They are called to access and set the first element of the \fIsearchPath\fR
-list.  Since Tcl searches \fIsearchPath\fR for encoding data files in
-list order, these routines establish the
-.QW default
-directory in which to find encoding data files.
-.VE 8.5
+access and set the directory to use when locating the default encoding
+files.  If this value is not NULL, the \fBTclpInitLibraryPath\fR routine
+appends the path to the head of the search path, and uses this path as
+the first place to look into when trying to locate the encoding file.
+
 .SH "ENCODING FILES"
 Space would prohibit precompiling into Tcl every possible encoding
 algorithm, so many encodings are stored on disk as dynamically-loadable
@@ -477,25 +394,23 @@ external encoding may consist of single-byte, multi-byte, or double-byte
 characters.  
 .PP
 Each dynamically-loadable encoding is represented as a text file.  The
-initial line of the file, beginning with a
-.QW #
-symbol, is a comment
+initial line of the file, beginning with a ``#'' symbol, is a comment
 that provides a human-readable description of the file.  The next line
 identifies the type of encoding file.  It can be one of the following
 letters:
-.IP "[1] \fBS\fR"
+.IP "[1]   \fBS\fR"
 A single-byte encoding, where one character is always one byte long in the
 encoding.  An example is \fBiso8859-1\fR, used by many European languages.
-.IP "[2] \fBD\fR"
+.IP "[2]   \fBD\fR"
 A double-byte encoding, where one character is always two bytes long in the
 encoding.  An example is \fBbig5\fR, used for Chinese text.
-.IP "[3] \fBM\fR"
+.IP "[3]   \fBM\fR"
 A multi-byte encoding, where one character may be either one or two bytes long.
-Certain bytes are lead bytes, indicating that another byte must follow
+Certain bytes are a lead bytes, indicating that another byte must follow
 and that together the two bytes represent one character.  Other bytes are not
 lead bytes and represent themselves.  An example is \fBshiftjis\fR, used by
 many Japanese computers.
-.IP "[4] \fBE\fR"
+.IP "[4]   \fBE\fR"
 An escape-sequence encoding, specifying that certain sequences of bytes
 do not represent characters, but commands that describe how following bytes
 should be interpreted.  
@@ -565,7 +480,7 @@ and 0x8163 in \fBshiftjis\fR map to 203E and 2026 in Unicode, respectively.
 Following the first page will be all the other pages, each in the same
 format as the first: one number identifying the page followed by 256
 double-byte Unicode characters.  If a character in the encoding maps to the
-Unicode character 0000, it means that the character does not actually exist.
+Unicode character 0000, it means that the character doesn't actually exist.
 If all characters on a page would map to 0000, that page can be omitted.
 .PP
 Case [4] is the escape-sequence encoding file.  The lines in an this type of
@@ -577,13 +492,13 @@ encoding:
 E
 init		{}
 final		{}
-iso8859-1	\ex1b(B
-jis0201		\ex1b(J
-jis0208		\ex1b$@
-jis0208		\ex1b$B
-jis0212		\ex1b$(D
-gb2312		\ex1b$A
-ksc5601		\ex1b$(C
+iso8859-1	\\x1b(B
+jis0201		\\x1b(J
+jis0208		\\x1b$@
+jis0208		\\x1b$B
+jis0212		\\x1b$(D
+gb2312		\\x1b$A
+ksc5601		\\x1b$(C
 .CE
 .PP
 In the file, the first column represents an option and the second column
@@ -592,16 +507,16 @@ the first character is converted, while \fBfinal\fR is a string to emit
 or expect after the last character.  All other options are names of
 table-based encodings; the associated value is the escape-sequence that
 marks that encoding.  Tcl syntax is used for the values; in the above
-example, for instance,
-.QW \fB{}\fR
-represents the empty string and
-.QW \fB\ex1b\fR
-represents character 27.
+example, for instance, ``\fB{}\fR'' represents the empty string and
+``\fB\\x1b\fR'' represents character 27.
 .PP
 When \fBTcl_GetEncoding\fR encounters an encoding \fIname\fR that has not
 been loaded, it attempts to load an encoding file called \fIname\fB.enc\fR
-from the \fBencoding\fR subdirectory of each directory that Tcl searches
-for its script library.  If the encoding file exists, but is
+from the \fBencoding\fR subdirectory of each directory specified in the
+library path \fB$tcl_libPath\fR.  If the encoding file exists, but is
 malformed, an error message will be left in \fIinterp\fR.
 .SH KEYWORDS
 utf, encoding, convert
+
+
+
@@ -1,188 +0,0 @@
-'\"
-'\" Copyright (c) 2005 Donal K. Fellows
-'\"
-'\" See the file "license.terms" for information on usage and redistribution
-'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-'\" 
-'\" This documents the C API introduced in TIP#235
-'\" 
-.so man.macros
-.TH Tcl_Ensemble 3 8.5 Tcl "Tcl Library Procedures"
-.BS
-.SH NAME
-Tcl_CreateEnsemble, Tcl_FindEnsemble, Tcl_GetEnsembleFlags, Tcl_GetEnsembleMappingDict, Tcl_GetEnsembleNamespace, Tcl_GetEnsembleUnknownHandler, Tcl_GetEnsembleSubcommandList, Tcl_IsEnsemble, Tcl_SetEnsembleFlags, Tcl_SetEnsembleMappingDict, Tcl_SetEnsembleSubcommandList, Tcl_SetEnsembleUnknownHandler \- manipulate ensemble commands
-.SH SYNOPSIS
-.nf
-\fB#include <tcl.h>\fR
-.sp
-Tcl_Command
-\fBTcl_CreateEnsemble\fR(\fIinterp, name, namespacePtr, ensFlags\fR)
-.sp
-Tcl_Command
-\fBTcl_FindEnsemble\fR(\fIinterp, cmdNameObj, flags\fR)
-.sp
-int
-\fBTcl_IsEnsemble\fR(\fItoken\fR)
-.sp
-int
-\fBTcl_GetEnsembleFlags\fR(\fIinterp, token, ensFlagsPtr\fR)
-.sp
-int
-\fBTcl_SetEnsembleFlags\fR(\fIinterp, token, ensFlags\fR)
-.sp
-int
-\fBTcl_GetEnsembleMappingDict\fR(\fIinterp, token, dictObjPtr\fR)
-.sp
-int
-\fBTcl_SetEnsembleMappingDict\fR(\fIinterp, token, dictObj\fR)
-.sp
-int
-\fBTcl_GetEnsembleSubcommandList\fR(\fIinterp, token, listObjPtr\fR)
-.sp
-int
-\fBTcl_SetEnsembleSubcommandList\fR(\fIinterp, token, listObj\fR)
-.sp
-int
-\fBTcl_GetEnsembleUnknownHandler\fR(\fIinterp, token, listObjPtr\fR)
-.sp
-int
-\fBTcl_SetEnsembleUnknownHandler\fR(\fIinterp, token, listObj\fR)
-.sp
-int
-\fBTcl_GetEnsembleNamespace\fR(\fIinterp, token, namespacePtrPtr\fR)
-.SH ARGUMENTS
-.AS Tcl_Namespace **namespacePtrPtr in/out
-.AP Tcl_Interp *interp in/out
-The interpreter in which the ensemble is to be created or found. Also
-where error result messages are written. The functions whose names
-start with \fBTcl_GetEnsemble\fR may have a NULL for the \fIinterp\fR,
-but all other functions must not.
-.AP "const char" *name in
-The name of the ensemble command to be created.
-.AP Tcl_Namespace *namespacePtr in
-The namespace to which the ensemble command is to be bound, or NULL
-for the current namespace.
-.AP int ensFlags in
-An ORed set of flag bits describing the basic configuration of the
-ensemble. Currently only one bit has meaning, TCL_ENSEMBLE_PREFIX,
-which is present when the ensemble command should also match
-unambiguous prefixes of subcommands.
-.AP Tcl_Obj *cmdNameObj in
-A value holding the name of the ensemble command to look up.
-.AP int flags in
-An ORed set of flag bits controlling the behavior of
-\fBTcl_FindEnsemble\fR. Currently only TCL_LEAVE_ERR_MSG is supported.
-.AP Tcl_Command token in
-A normal command token that refers to an ensemble command, or which
-you wish to use for testing as an ensemble command in \fBTcl_IsEnsemble\fR.
-.AP int *ensFlagsPtr out
-Pointer to a variable into which to write the current ensemble flag
-bits; currently only the bit TCL_ENSEMBLE_PREFIX is defined.
-.AP Tcl_Obj *dictObj in
-A dictionary value to use for the subcommand to implementation command
-prefix mapping dictionary in the ensemble. May be NULL if the mapping
-dictionary is to be removed.
-.AP Tcl_Obj **dictObjPtr out
-Pointer to a variable into which to write the current ensemble mapping
-dictionary.
-.AP Tcl_Obj *listObj in
-A list value to use for the defined list of subcommands in the
-dictionary or the unknown subcommmand handler command prefix. May be
-NULL if the subcommand list or unknown handler are to be removed.
-.AP Tcl_Obj **listObjPtr out
-Pointer to a variable into which to write the current defiend list of
-subcommands or the current unknown handler prefix.
-.AP Tcl_Namespace **namespacePtrPtr out
-Pointer to a variable into which to write the handle of the namespace
-to which the ensemble is bound.
-.BE
-
-.SH DESCRIPTION
-An ensemble is a command, bound to some namespace, which consists of a
-collection of subcommands implemented by other Tcl commands. The first
-argument to the ensemble command is always interpreted as a selector
-that states what subcommand to execute.
-.PP
-Ensembles are created using \fBTcl_CreateEnsemble\fR, which takes four
-arguments: the interpreter to work within, the name of the ensemble to
-create, the namespace within the interpreter to bind the ensemble to,
-and the default set of ensemble flags. The result of the function is
-the command token for the ensemble, which may be used to further
-configure the ensemble using the API described below in \fBENSEMBLE
-PROPERTIES\fR.
-.PP
-Given the name of an ensemble command, the token for that command may
-be retrieved using \fBTcl_FindEnsemble\fR. If the given command name
-(in \fIcmdNameObj\fR) does not refer to an ensemble command, the
-result of the function is NULL and (if the TCL_LEAVE_ERR_MSG bit is
-set in \fIflags\fR) an error message is left in the interpreter
-result.
-.PP
-A command token may be checked to see if it refers to an ensemble
-using \fBTcl_IsEnsemble\fR. This returns 1 if the token refers to an
-ensemble, or 0 otherwise.
-.SS "ENSEMBLE PROPERTIES"
-Every ensemble has four read-write properties and a read-only
-property. The properties are:
-.TP
-\fBflags\fR (read-write)
-The set of flags for the ensemble, expressed as a
-bit-field. Currently, the only public flag is TCL_ENSEMBLE_PREFIX
-which is set when unambiguous prefixes of subcommands are permitted to
-be resolved to implementations as well as exact matches. The flags may
-be read and written using \fBTcl_GetEnsembleFlags\fR and
-\fBTcl_SetEnsembleFlags\fR respectively. The result of both of those
-functions is a Tcl result code (TCL_OK, or TCL_ERROR if the token does
-not refer to an ensemble).
-.TP
-\fBmapping dictionary\fR (read-write)
-A dictionary containing a mapping from subcommand names to lists of
-words to use as a command prefix (replacing the first two words of the
-command which are the ensemble command itself and the subcommand
-name), or NULL if every subcommand is to be mapped to the command with
-the same unqualified name in the ensemble's bound namespace. Defaults
-to NULL. May be read and written using
-\fBTcl_GetEnsembleMappingDict\fR and \fBTcl_SetEnsembleMappingDict\fR
-respectively. The result of both of those functions is a Tcl result
-code (TCL_OK, or TCL_ERROR if the token does not refer to an
-ensemble) and the dictionary obtained from
-\fBTcl_GetEnsembleMappingDict\fR should always be treated as immutable
-even if it is unshared.
-All command names in prefixes set via \fBTcl_SetEnsembleMappingDict\fR
-must be fully qualified.
-.TP
-\fBsubcommand list\fR (read-write)
-A list of all the subcommand names for the ensemble, or NULL if this
-is to be derived from either the keys of the mapping dictionary (see
-above) or (if that is also NULL) from the set of commands exported by
-the bound namespace. May be read and written using
-\fBTcl_GetEnsembleSubcommandList\fR and
-\fBTcl_SetEnsembleSubcommandList\fR respectively. The result of both
-of those functions is a Tcl result code (TCL_OK, or TCL_ERROR if the
-token does not refer to an ensemble) and the list obtained from
-\fBTcl_GetEnsembleSubcommandList\fR should always be treated as
-immutable even if it is unshared.
-.TP
-\fBunknown subcommand handler command prefix\fR (read-write)
-A list of words to prepend on the front of any subcommand when the
-subcommand is unknown to the ensemble (according to the current prefix
-handling rule); see the \fBnamespace ensemble\fR command for more
-details. If NULL, the default behavior \- generate a suitable error
-message \- will be used when an unknown subcommand is encountered. May
-be read and written using \fBTcl_GetEnsembleUnknownHandler\fR and
-\fBTcl_SetEnsembleUnknownHandler\fR respectively. The result of both
-functions is a Tcl result code (TCL_OK, or TCL_ERROR if the token does
-not refer to an ensemble) and the list obtained from
-\fBTcl_GetEnsembleUnknownHandler\fR should always be treated as
-immutable even if it is unshared.
-.TP
-\fBbound namespace\fR (read-only)
-The namespace to which the ensemble is bound; when the namespace is
-deleted, so too will the ensemble, and this namespace is also the
-namespace whose list of exported commands is used if both the mapping
-dictionary and the subcommand list properties are NULL. May be read
-using \fBTcl_GetEnsembleNamespace\fR which returns a Tcl result code
-(TCL_OK, or TCL_ERROR if the token does not refer to an ensemble).
-
-.SH "SEE ALSO"
-namespace(n), Tcl_DeleteCommandFromToken(3)
@@ -4,6 +4,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Environment.3,v 1.1 2001/04/04 21:32:18 andreas_kupries Exp $
+'\" 
 .so man.macros
 .TH Tcl_PutEnv 3 "7.5" Tcl "Tcl Library Procedures"
 .BS
@@ -14,25 +16,21 @@ Tcl_PutEnv \- procedures to manipulate the environment
 \fB#include <tcl.h>\fR
 .sp
 int
-\fBTcl_PutEnv\fR(\fIassignment\fR)
+\fBTcl_PutEnv\fR(\fIstring\fR)
 .SH ARGUMENTS
-.AS "const char" *assignment
-.AP "const char" *assignment in
-Info about environment variable in the format
-.QW \fINAME\fB=\fIvalue\fR .
-The \fIassignment\fR argument is in the system encoding.
+.AP "CONST char" *string in
+Info about environment variable in the form NAME=value. The string is
+in native format.
 .BE
+
 .SH DESCRIPTION
 .PP
 \fBTcl_PutEnv\fR sets an environment variable. The information is
-passed in a single string of the form
-.QW \fINAME\fB=\fIvalue\fR .
-This procedure is
+passed in a single string of the form NAME=value.  This procedure is
 intended to be a stand-in for the UNIX \fBputenv\fR system call. All
-Tcl-based applications using \fBputenv\fR should redefine it to
+tcl-based applications using \fBputenv\fR should redefine it to
 \fBTcl_PutEnv\fR so that they will interface properly to the Tcl
 runtime.
-.SH "SEE ALSO"
-tclvars(n)
+
 .SH KEYWORDS
 environment, variable
@@ -6,6 +6,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Eval.3,v 1.10 2002/01/15 21:19:06 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_Eval 3 8.1 Tcl "Tcl Library Procedures"
 .BS
@@ -15,6 +17,7 @@ Tcl_EvalObjEx, Tcl_EvalFile, Tcl_EvalObjv, Tcl_Eval, Tcl_EvalEx, Tcl_GlobalEval,
 .nf
 \fB#include <tcl.h>\fR
 .sp
+.VS
 int
 \fBTcl_EvalObjEx\fR(\fIinterp, objPtr, flags\fR)
 .sp
@@ -34,15 +37,15 @@ int
 \fBTcl_GlobalEval\fR(\fIinterp, script\fR)
 .sp
 int
-\fBTcl_GlobalEvalObj\fR(\fIinterp, objPtr\fR)
+\fBTcl_GlobalEvalObj\fR(\fIinterp, objPtr, flags\fR)
 .sp
 int
-\fBTcl_VarEval\fR(\fIinterp, part, part, ... \fB(char *) NULL\fR)
+\fBTcl_VarEval\fR(\fIinterp, string, string, ... \fB(char *) NULL\fR)
 .sp
 int
 \fBTcl_VarEvalVA\fR(\fIinterp, argList\fR)
 .SH ARGUMENTS
-.AS Tcl_Interp **termPtr
+.AS Tcl_Interp **termPtr;
 .AP Tcl_Interp *interp in
 Interpreter in which to execute the script.  The interpreter's result is
 modified to hold the result or error message from the script.
@@ -51,7 +54,7 @@ A Tcl object containing the script to execute.
 .AP int flags in
 ORed combination of flag bits that specify additional options.
 \fBTCL_EVAL_GLOBAL\fR and \fBTCL_EVAL_DIRECT\fR are currently supported.
-.AP "const char" *fileName in
+.AP "CONST char" *fileName in
 Name of a file containing a Tcl script.
 .AP int objc in
 The number of objects in the array pointed to by \fIobjPtr\fR;
@@ -63,13 +66,15 @@ value of a single word in the command to execute.
 The number of bytes in \fIscript\fR, not including any
 null terminating character.  If \-1, then all characters up to the
 first null byte are used.
-.AP "const char" *script in
-Points to first byte of script to execute (null-terminated and UTF-8).
-.AP char *part in
+.AP char *script in
+Points to first byte of script to execute (NULL terminated and UTF-8).
+This script must be in writable memory: temporary modifications are made
+to it during parsing.
+.AP char *string in
 String forming part of a Tcl script.
 .AP va_list argList in
-An argument list which must have been initialized using
-\fBva_start\fR, and cleared using \fBva_end\fR.
+An argument list which must have been initialised using
+\fBTCL_VARARGS_START\fR, and cleared using \fBva_end\fR.
 .BE

 .SH DESCRIPTION
@@ -88,41 +93,33 @@ can be skipped if the object is evaluated again in the future.
 The return value from \fBTcl_EvalObjEx\fR (and all the other procedures
 described here) is a Tcl completion code with
 one of the values \fBTCL_OK\fR, \fBTCL_ERROR\fR, \fBTCL_RETURN\fR,
-\fBTCL_BREAK\fR, or \fBTCL_CONTINUE\fR, or possibly some other
-integer value originating in an extension.
+\fBTCL_BREAK\fR, or \fBTCL_CONTINUE\fR.
 In addition, a result value or error message is left in \fIinterp\fR's
 result; it can be retrieved using \fBTcl_GetObjResult\fR.
 .PP
 \fBTcl_EvalFile\fR reads the file given by \fIfileName\fR and evaluates
 its contents as a Tcl script.  It returns the same information as
 \fBTcl_EvalObjEx\fR.
-If the file could not be read then a Tcl error is returned to describe
-why the file could not be read.
-The eofchar for files is
-.QW \e32
-(^Z) for all platforms. If you require a
-.QW ^Z
-in code for string comparison, you can use
-.QW \e032
-or
-.QW \eu001a ,
-which will be safely substituted by the Tcl interpreter into
-.QW ^Z .
+If the file couldn't be read then a Tcl error is returned to describe
+why the file couldn't be read.
+.VS 8.4
+The eofchar for files is '\\32' (^Z) for all platforms.
+If you require a ``^Z'' in code for string comparison, you can use
+``\\032'' or ``\\u001a'', which will be safely substituted by the Tcl
+interpreter into ``^Z''.
+.VE 8.4
 .PP
 \fBTcl_EvalObjv\fR executes a single pre-parsed command instead of a
 script.  The \fIobjc\fR and \fIobjv\fR arguments contain the values
 of the words for the Tcl command, one word in each object in
 \fIobjv\fR.  \fBTcl_EvalObjv\fR evaluates the command and returns
 a completion code and result just like \fBTcl_EvalObjEx\fR.
-The caller of \fBTcl_EvalObjv\fR has to manage the reference count of the
-elements of \fIobjv\fR, insuring that the objects are valid until
-\fBTcl_EvalObjv\fR returns.  
 .PP
 \fBTcl_Eval\fR is similar to \fBTcl_EvalObjEx\fR except that the script to
 be executed is supplied as a string instead of an object and no compilation
 occurs.  The string should be a proper UTF-8 string as converted by
 \fBTcl_ExternalToUtfDString\fR or \fBTcl_ExternalToUtf\fR when it is known
-to possibly contain upper ASCII characters whose possible combinations
+to possibly contain upper ascii characters who's possible combinations
 might be a UTF-8 special code.  The string is parsed and executed directly
 (using \fBTcl_EvalObjv\fR) instead of compiling it and executing the
 bytecodes.  In situations where it is known that the script will never be
@@ -132,7 +129,7 @@ executed again, \fBTcl_Eval\fR may be faster than \fBTcl_EvalObjEx\fR.
 Tcl 8.0, \fBTcl_Eval\fR copies the object result in \fIinterp\fR to
 \fIinterp->result\fR (use is deprecated) where it can be accessed directly.
 This makes \fBTcl_Eval\fR somewhat slower than \fBTcl_EvalEx\fR, which
-does not do the copy.
+doesn't do the copy.
 .PP
 \fBTcl_EvalEx\fR is an extended version of \fBTcl_Eval\fR that takes
 additional arguments \fInumBytes\fR and \fIflags\fR.  For the
@@ -169,8 +166,8 @@ compiled to bytecodes; instead it is executed directly
 as is done by \fBTcl_EvalEx\fR.  The
 \fBTCL_EVAL_DIRECT\fR flag is useful in situations where the
 contents of an object are going to change immediately, so the
-bytecodes will not be reused in a future execution.  In this case,
-it is faster to execute the script directly.
+bytecodes won't be reused in a future execution.  In this case,
+it's faster to execute the script directly.
 .TP 23
 \fBTCL_EVAL_GLOBAL\fR
 If this flag is set, the script is processed at global level.  This
@@ -203,6 +200,7 @@ the \fBreturn\fR, \fBbreak\fR, or \fBcontinue\fR command was
 invoked in an inappropriate place.
 This means that top-level applications should never see a return code
 from \fBTcl_EvalObjEx\fR other then \fBTCL_OK\fR or \fBTCL_ERROR\fR.
+.VE

 .SH KEYWORDS
 execute, file, global, object, result, script
@@ -4,11 +4,13 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Exit.3,v 1.4 2000/07/24 00:03:02 jenglish Exp $
+'\" 
 .so man.macros
-.TH Tcl_Exit 3 8.5 Tcl "Tcl Library Procedures"
+.TH Tcl_Exit 3 8.1 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_Exit, Tcl_Finalize, Tcl_CreateExitHandler, Tcl_DeleteExitHandler, Tcl_ExitThread, Tcl_FinalizeThread, Tcl_CreateThreadExitHandler, Tcl_DeleteThreadExitHandler, Tcl_SetExitProc \- end the application or thread (and invoke exit handlers)
+Tcl_Exit, Tcl_Finalize, Tcl_CreateExitHandler, Tcl_DeleteExitHandler, Tcl_ExitThread, Tcl_FinalizeThread, Tcl_CreateThreadExitHandler, Tcl_DeleteThreadExitHandler \- end the application or thread (and invoke exit handlers)
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -28,11 +30,6 @@ Tcl_Exit, Tcl_Finalize, Tcl_CreateExitHandler, Tcl_DeleteExitHandler, Tcl_ExitTh
 \fBTcl_CreateThreadExitHandler\fR(\fIproc, clientData\fR)
 .sp
 \fBTcl_DeleteThreadExitHandler\fR(\fIproc, clientData\fR)
-.sp
-.VS 8.5
-Tcl_ExitProc *
-\fBTcl_SetExitProc\fR(\fIproc\fR)
-.VE 8.5
 .SH ARGUMENTS
 .AS Tcl_ExitProc clientData
 .AP int status  in
@@ -41,9 +38,7 @@ Exact meaning may
 be platform-specific.  0 usually means a normal exit, any nonzero value
 usually means that an error occurred.
 .AP Tcl_ExitProc *proc in
-Procedure to invoke before exiting application, or (for
-\fBTcl_SetExitProc\fR) NULL to uninstall the current application exit
-procedure.
+Procedure to invoke before exiting application.
 .AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .BE
@@ -64,12 +59,6 @@ otherwise causes the application to terminate without calling
 \fBTcl_Exit\fR, the exit handlers will not be run.
 \fBTcl_Exit\fR internally invokes the \fBexit\fR system call, thus it never
 returns control to its caller.
-.VS 8.5
-If an application exit handler has been installed (see
-\fBTcl_SetExitProc\fR), that handler is invoked with an argument
-consisting of the exit status (cast to ClientData); the application
-exit handler should not return control to Tcl.
-.VE 8.5
 .PP
 \fBTcl_Finalize\fR is similar to \fBTcl_Exit\fR except that it does not
 exit from the current process.
@@ -84,12 +73,14 @@ However, to ensure portability, your code should always invoke
 code will work on all platforms. \fBTcl_Finalize\fR can be safely called
 more than once.
 .PP
+.VS
 \fBTcl_ExitThread\fR is used to terminate the current thread and invoke
 per-thread exit handlers.  This finalization is done by
 \fBTcl_FinalizeThread\fR, which you can call if you just want to clean
 up per-thread state and invoke the thread exit handlers.
 \fBTcl_Finalize\fR calls \fBTcl_FinalizeThread\fR for the current
 thread automatically.
+.VE
 .PP
 \fBTcl_CreateExitHandler\fR arranges for \fIproc\fR to be invoked
 by \fBTcl_Finalize\fR and \fBTcl_Exit\fR.
@@ -116,6 +107,7 @@ indicated by \fIproc\fR and \fIclientData\fR so that no call
 to \fIproc\fR will be made.  If no such handler exists then
 \fBTcl_DeleteExitHandler\fR or \fBTcl_DeleteThreadExitHandler\fR does nothing.
 .PP
+.VS
 .PP
 \fBTcl_Finalize\fR and \fBTcl_Exit\fR execute all registered exit handlers,
 in reverse order from the order in which they were registered.
@@ -125,23 +117,15 @@ unloads \fBB\fR before it itself is unloaded.
 If extension \fBA\fR registers its exit handlers before loading extension
 \fBB\fR, this ensures that any exit handlers for \fBB\fR will be executed
 before the exit handlers for \fBA\fR.
+.VE
+.VS
 .PP
 \fBTcl_Finalize\fR and \fBTcl_Exit\fR call \fBTcl_FinalizeThread\fR 
 and the thread exit handlers \fIafter\fR
 the process-wide exit handlers.  This is because thread finalization shuts
 down the I/O channel system, so any attempt at I/O by the global exit
 handlers will vanish into the bitbucket.
-.PP
-.VS 8.5
-\fBTcl_SetExitProc\fR installs an application exit handler, returning
-the previously-installed application exit handler or NULL if no
-application handler was installed.  If an application exit handler is
-installed, that exit handler takes over complete responsibility for
-finalization of Tcl's subsystems via \fBTcl_Finalize\fR at an
-appropriate time.  The argument passed to \fIproc\fR when it is
-invoked will be the exit status code (as passed to \fBTcl_Exit\fR)
-cast to a ClientData value.
-.VE 8.5
+.VE

 .SH KEYWORDS
 callback, cleanup, dynamic loading, end application, exit, unloading, thread
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: ExprLong.3,v 1.5 2001/12/10 15:50:46 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_ExprLong 3 7.0 Tcl "Tcl Library Procedures"
 .BS
@@ -15,22 +17,26 @@ Tcl_ExprLong, Tcl_ExprDouble, Tcl_ExprBoolean, Tcl_ExprString \- evaluate an exp
 \fB#include <tcl.h>\fR
 .sp
 int
-\fBTcl_ExprLong\fR(\fIinterp, expr, longPtr\fR)
+\fBTcl_ExprLong\fR(\fIinterp, string, longPtr\fR)
 .sp
 int
-\fBTcl_ExprDouble\fR(\fIinterp, expr, doublePtr\fR)
+\fBTcl_ExprDouble\fR(\fIinterp, string, doublePtr\fR)
 .sp
 int
-\fBTcl_ExprBoolean\fR(\fIinterp, expr, booleanPtr\fR)
+\fBTcl_ExprBoolean\fR(\fIinterp, string, booleanPtr\fR)
 .sp
 int
-\fBTcl_ExprString\fR(\fIinterp, expr\fR)
+\fBTcl_ExprString\fR(\fIinterp, string\fR)
 .SH ARGUMENTS
-.AS Tcl_Interp *booleanPtr out
+.AS Tcl_Interp *booleanPtr
 .AP Tcl_Interp *interp in
-Interpreter in whose context to evaluate \fIexpr\fR.
-.AP "const char" *expr in
-Expression to be evaluated.  
+Interpreter in whose context to evaluate \fIstring\fR or \fIobjPtr\fR.
+.VS 8.4
+.AP "CONST char" *string in
+.VE
+Expression to be evaluated.  Must be in writable memory (the expression
+parser makes temporary modifications to the string during parsing, which
+it undoes before returning).
 .AP long *longPtr out
 Pointer to location in which to store the integer value of the
 expression.
@@ -45,7 +51,7 @@ expression.
 .SH DESCRIPTION
 .PP
 These four procedures all evaluate the expression
-given by the \fIexpr\fR argument
+given by the \fIstring\fR argument
 and return the result in one of four different forms.
 The expression can have any of the forms accepted by the \fBexpr\fR command.
 Note that these procedures have been largely replaced by the
@@ -90,14 +96,16 @@ number, then they store 0 at \fI*booleanPtr\fR if
 the value was zero and 1 otherwise.
 If the expression's actual value is a non-numeric string then
 it must be one of the values accepted by \fBTcl_GetBoolean\fR
-such as
-.QW yes
-or
-.QW no ,
-or else an error occurs.
+such as ``yes'' or ``no'', or else an error occurs.
 .PP
 \fBTcl_ExprString\fR returns the value of the expression as a
 string stored in the interpreter's result.
+If the expression's actual value is an integer
+then \fBTcl_ExprString\fR converts it to a string using \fBsprintf\fR
+with a ``%d'' converter.
+If the expression's actual value is a floating-point
+number, then \fBTcl_ExprString\fR calls \fBTcl_PrintDouble\fR
+to convert it to a string.

 .SH "SEE ALSO"
 Tcl_ExprLongObj, Tcl_ExprDoubleObj, Tcl_ExprBooleanObj, Tcl_ExprObj
@@ -4,6 +4,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: ExprLongObj.3,v 1.3 2001/09/03 09:38:50 dkf Exp $
+'\" 
 .so man.macros
 .TH Tcl_ExprLongObj 3 8.0 Tcl "Tcl Library Procedures"
 .BS
@@ -27,7 +29,7 @@ int
 .SH ARGUMENTS
 .AS Tcl_Interp **resultPtrPtr out
 .AP Tcl_Interp *interp in
-Interpreter in whose context to evaluate \fIobjPtr\fR.
+Interpreter in whose context to evaluate \fIstring\fR or \fIobjPtr\fR.
 .AP Tcl_Obj *objPtr in
 Pointer to an object containing the expression to evaluate.
 .AP long *longPtr out
@@ -86,11 +88,7 @@ number, then they store 0 at \fI*booleanPtr\fR if
 the value was zero and 1 otherwise.
 If the expression's actual value is a non-numeric string then
 it must be one of the values accepted by \fBTcl_GetBoolean\fR
-such as
-.QW yes
-or
-.QW no ,
-or else an error occurs.
+such as ``yes'' or ``no'', or else an error occurs.
 .PP
 If \fBTcl_ExprObj\fR successfully evaluates the expression,
 it stores a pointer to the Tcl object
@@ -4,6 +4,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: FindExec.3,v 1.5 2001/09/28 17:07:54 msofer Exp $
+'\" 
 .so man.macros
 .TH Tcl_FindExecutable 3 8.1 Tcl "Tcl Library Procedures"
 .BS
@@ -16,10 +18,10 @@ Tcl_FindExecutable, Tcl_GetNameOfExecutable \- identify or return the name of th
 void
 \fBTcl_FindExecutable\fR(\fIargv0\fR)
 .sp
-const char *
+CONST char *
 \fBTcl_GetNameOfExecutable\fR()
 .SH ARGUMENTS
-.AS char *argv0
+.AS char *argv0 in
 .AP char *argv0 in
 The first command-line argument to the program, which gives the
 application's name.
@@ -1,9 +1,11 @@
 '\"
-'\" Copyright (c) 1998-1999 Scriptics Corporation
+'\" Copyright (c) 1998-1999 Scriptics Corportation
 '\"
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: GetCwd.3,v 1.3 2002/01/17 04:37:32 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_GetCwd 3 8.1 Tcl "Tcl Library Procedures"
 .BS
@@ -13,13 +15,13 @@ Tcl_GetCwd, Tcl_Chdir \- manipulate the current working directory
 .nf
 \fB#include <tcl.h>\fR
 .sp
-char *
+CONST char *
 \fBTcl_GetCwd\fR(\fIinterp\fR, \fIbufferPtr\fR)
 .sp
 int
 \fBTcl_Chdir\fR(\fIpath\fR)
 .SH ARGUMENTS
-.AS Tcl_DString *bufferPtr in/out
+.AS Tcl_DString *bufferPtr
 .AP Tcl_Interp *interp in
 Interpreter in which to report an error, if any.
 .AP Tcl_DString *bufferPtr in/out
@@ -39,7 +41,7 @@ the same functionality as the Tcl \fBpwd\fR command.
 .PP
 \fBTcl_GetCwd\fR returns a pointer to a string specifying the current
 directory, or NULL if the current directory could not be determined.
-If NULL is returned, an error message is left in the \fIinterp\fR's result.
+If NULL is returned, an error message is left in the interp's result.
 Storage for the result string is allocated in bufferPtr; the caller
 must call \fBTcl_DStringFree()\fR when the result is no longer needed.
 The format of the path is UTF\-8.
@@ -2,6 +2,8 @@
 '\" Copyright (c) 1998-2000 by Scriptics Corporation.
 '\" All rights reserved.
 '\" 
+'\" RCS: @(#) $Id: GetHostName.3,v 1.2 2002/01/23 20:46:01 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_GetHostName 3 8.3 Tcl "Tcl Library Procedures"
 .BS
@@ -11,9 +13,8 @@ Tcl_GetHostName \- get the name of the local host
 .nf
 \fB#include <tcl.h>\fR
 .sp
-const char *
+CONST char *
 \fBTcl_GetHostName\fR()
-.BE

 .SH DESCRIPTION
 .PP
@@ -4,6 +4,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: GetIndex.3,v 1.8 2002/01/17 04:37:32 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_GetIndexFromObj 3 8.1 Tcl "Tcl Library Procedures"
 .BS
@@ -16,12 +18,14 @@ Tcl_GetIndexFromObj, Tcl_GetIndexFromObjStruct \- lookup string in table of keyw
 int
 \fBTcl_GetIndexFromObj\fR(\fIinterp, objPtr, tablePtr, msg, flags,
 indexPtr\fR)
+.VS
 .sp
 int
-\fBTcl_GetIndexFromObjStruct\fR(\fIinterp, objPtr, structTablePtr, offset,
-                          msg, flags, indexPtr\fR)
+\fBTcl_GetIndexFromObjStruct\fR(\fIinterp, objPtr, tablePtr, offset,
+msg, flags, indexPtr\fR)
+.VE
 .SH ARGUMENTS
-.AS "const char" *structTablePtr in/out
+.AS "CONST char" **tablePtr
 .AP Tcl_Interp *interp in
 Interpreter to use for error reporting; if NULL, then no message is
 provided on errors.
@@ -29,23 +33,15 @@ provided on errors.
 The string value of this object is used to search through \fItablePtr\fR.
 The internal representation is modified to hold the index of the matching
 table entry.
-.AP "const char" **tablePtr in
+.AP "CONST char" **tablePtr in
 An array of null-terminated strings.  The end of the array is marked
 by a NULL string pointer.
-Note that references to the \fItablePtr\fR may be retained in the
-internal representation of \fIobjPtr\fR, so this should represent the
-address of a statically-allocated array.
-.AP "const void" *structTablePtr in
-An array of arbitrary type, typically some \fBstruct\fR type.
-The first member of the structure must be a null-terminated string.
-The size of the structure is given by \fIoffset\fR.
-Note that references to the \fIstructTablePtr\fR may be retained in the
-internal representation of \fIobjPtr\fR, so this should represent the
-address of a statically-allocated array of structures.
+.VS
 .AP int offset in
-The offset to add to structTablePtr to get to the next entry.
-The end of the array is marked by a NULL string pointer.
-.AP "const char" *msg in
+The offset to add to tablePtr to get to the next string in the
+list. The end of the array is marked by a NULL string pointer.
+.VE
+.AP "CONST char" *msg in
 Null-terminated string describing what is being looked up, such as
 \fBoption\fR.  This string is included in error messages.
 .AP int flags in
@@ -58,24 +54,24 @@ The index of the string in \fItablePtr\fR that matches the value of

 .SH DESCRIPTION
 .PP
-These procedures provide an efficient way for looking up keywords,
+This procedure provides an efficient way for looking up keywords,
 switch names, option names, and similar things where the value of
 an object must be one of a predefined set of values.
-\fBTcl_GetIndexFromObj\fR compares \fIobjPtr\fR against each of
+\fIObjPtr\fR is compared against each of
 the strings in \fItablePtr\fR to find a match.  A match occurs if
 \fIobjPtr\fR's string value is identical to one of the strings in
-\fItablePtr\fR, or if it is a non-empty unique abbreviation
+\fItablePtr\fR, or if it is a unique abbreviation
 for exactly one of the strings in \fItablePtr\fR and the
 \fBTCL_EXACT\fR flag was not specified; in either case
 the index of the matching entry is stored at \fI*indexPtr\fR
-and \fBTCL_OK\fR is returned.
+and TCL_OK is returned.
 .PP
 If there is no matching entry,
-\fBTCL_ERROR\fR is returned and an error message is left in \fIinterp\fR's
-result if \fIinterp\fR is not NULL.  \fIMsg\fR is included in the
+TCL_ERROR is returned and an error message is left in \fIinterp\fR's
+result if \fIinterp\fR isn't NULL.  \fIMsg\fR is included in the
 error message to indicate what was being looked up.  For example,
 if \fImsg\fR is \fBoption\fR the error message will have a form like
-.QW "\fBbad option \N'34'firt\N'34': must be first, second, or third\fR" .
+\fBbad option "firt": must be first, second, or third\fR.
 .PP
 If \fBTcl_GetIndexFromObj\fR completes successfully it modifies the
 internal representation of \fIobjPtr\fR to hold the address of
@@ -87,18 +83,17 @@ operation.  Note: \fBTcl_GetIndexFromObj\fR assumes that the entries
 in \fItablePtr\fR are static: they must not change between
 invocations.  If the value of \fIobjPtr\fR is the empty string,
 \fBTcl_GetIndexFromObj\fR will treat it as a non-matching value
-and return \fBTCL_ERROR\fR.
+and return TCL_ERROR.
+.VS
 .PP
 \fBTcl_GetIndexFromObjStruct\fR works just like
 \fBTcl_GetIndexFromObj\fR, except that instead of treating
-\fItablePtr\fR as an array of string pointers, it treats it as a
-pointer to the first string in a series of strings that have
-\fIoffset\fR bytes between them (i.e. that there is a pointer to the
-first array of characters at \fItablePtr\fR, a pointer to the second
-array of characters at \fItablePtr\fR+\fIoffset\fR bytes, etc.)
-This is particularly useful when processing things like
+\fItablePtr\fR as an array of string pointers, it treats it as the
+first in a series of string ptrs that are spaced apart by \fIoffset\fR
+bytes. This is particularly useful when processing things like
 \fBTk_ConfigurationSpec\fR, whose string keys are in the same place in
 each of several array elements.
+.VE

 .SH "SEE ALSO"
 Tcl_WrongNumArgs
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: GetInt.3,v 1.4 2001/09/25 16:23:55 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_GetInt 3 "" Tcl "Tcl Library Procedures"
 .BS
@@ -15,69 +17,62 @@ Tcl_GetInt, Tcl_GetDouble, Tcl_GetBoolean \- convert from string to integer, dou
 \fB#include <tcl.h>\fR
 .sp
 int
-\fBTcl_GetInt\fR(\fIinterp, src, intPtr\fR)
+\fBTcl_GetInt\fR(\fIinterp, string, intPtr\fR)
 .sp
 int
-\fBTcl_GetDouble\fR(\fIinterp, src, doublePtr\fR)
+\fBTcl_GetDouble\fR(\fIinterp, string, doublePtr\fR)
 .sp
 int
-\fBTcl_GetBoolean\fR(\fIinterp, src, boolPtr\fR)
+\fBTcl_GetBoolean\fR(\fIinterp, string, boolPtr\fR)
 .SH ARGUMENTS
-.AS Tcl_Interp *doublePtr out
+.AS Tcl_Interp *doublePtr
 .AP Tcl_Interp *interp in
 Interpreter to use for error reporting.
-.AP "const char" *src in
+.AP "CONST char" *string in
 Textual value to be converted.
 .AP int *intPtr out
-Points to place to store integer value converted from \fIsrc\fR.
+Points to place to store integer value converted from \fIstring\fR.
 .AP double *doublePtr out
 Points to place to store double-precision floating-point
-value converted from \fIsrc\fR.
+value converted from \fIstring\fR.
 .AP int *boolPtr out
-Points to place to store boolean value (0 or 1) converted from \fIsrc\fR.
+Points to place to store boolean value (0 or 1) converted from \fIstring\fR.
 .BE

 .SH DESCRIPTION
 .PP
 These procedures convert from strings to integers or double-precision
 floating-point values or booleans (represented as 0- or 1-valued
-integers).  Each of the procedures takes a \fIsrc\fR argument,
+integers).  Each of the procedures takes a \fIstring\fR argument,
 converts it to an internal form of a particular type, and stores
 the converted value at the location indicated by the procedure's
 third argument.  If all goes well, each of the procedures returns
-\fBTCL_OK\fR.  If \fIsrc\fR does not have the proper syntax for the
-desired type then \fBTCL_ERROR\fR is returned, an error message is left
+TCL_OK.  If \fIstring\fR doesn't have the proper syntax for the
+desired type then TCL_ERROR is returned, an error message is left
 in the interpreter's result, and nothing is stored at *\fIintPtr\fR
 or *\fIdoublePtr\fR or *\fIboolPtr\fR.
 .PP
-\fBTcl_GetInt\fR expects \fIsrc\fR to consist of a collection
+\fBTcl_GetInt\fR expects \fIstring\fR to consist of a collection
 of integer digits, optionally signed and optionally preceded by
-white space.  If the first two characters of \fIsrc\fR
-after the optional white space and sign are
-.QW 0x
-then \fIsrc\fR is expected to be in hexadecimal form;  otherwise,
-if the first such character is
-.QW 0
-then \fIsrc\fR
-is expected to be in octal form;  otherwise, \fIsrc\fR is
+white space.  If the first two characters of \fIstring\fR are ``0x''
+then \fIstring\fR is expected to be in hexadecimal form;  otherwise,
+if the first character of \fIstring\fR is ``0'' then \fIstring\fR
+is expected to be in octal form;  otherwise, \fIstring\fR is
 expected to be in decimal form.
 .PP
-\fBTcl_GetDouble\fR expects \fIsrc\fR to consist of a floating-point
+\fBTcl_GetDouble\fR expects \fIstring\fR to consist of a floating-point
 number, which is:  white space;  a sign; a sequence of digits;  a
-decimal point;  a sequence of digits;  the letter
-.QW e ;
-a signed decimal exponent;  and more white space.
-Any of the fields may be omitted, except that
+decimal point;  a sequence of digits;  the letter ``e'';  and a
+signed decimal exponent.  Any of the fields may be omitted, except that
 the digits either before or after the decimal point must be present
-and if the
-.QW e
-is present then it must be followed by the exponent number.
+and if the ``e'' is present then it must be followed by the
+exponent number.
 .PP
-\fBTcl_GetBoolean\fR expects \fIsrc\fR to specify a boolean
-value.  If \fIsrc\fR is any of \fB0\fR, \fBfalse\fR,
+\fBTcl_GetBoolean\fR expects \fIstring\fR to specify a boolean
+value.  If \fIstring\fR is any of \fB0\fR, \fBfalse\fR,
 \fBno\fR, or \fBoff\fR, then \fBTcl_GetBoolean\fR stores a zero
 value at \fI*boolPtr\fR.
-If \fIsrc\fR is any of \fB1\fR, \fBtrue\fR, \fByes\fR, or \fBon\fR,
+If \fIstring\fR is any of \fB1\fR, \fBtrue\fR, \fByes\fR, or \fBon\fR,
 then 1 is stored at \fI*boolPtr\fR.
 Any of these values may be abbreviated, and upper-case spellings
 are also acceptable.
@@ -4,33 +4,34 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: GetOpnFl.3,v 1.4 2002/01/23 20:46:01 dgp Exp $
 .so man.macros
 .TH Tcl_GetOpenFile 3 8.0 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_GetOpenFile \- Return a FILE* for a channel registered in the given interpreter (Unix only)
+Tcl_GetOpenFile \- Get a standard IO File * handle from a channel. (Unix only)
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 int
-\fBTcl_GetOpenFile\fR(\fIinterp, chanID, write, checkUsage, filePtr\fR)
+\fBTcl_GetOpenFile\fR(\fIinterp, string, write, checkUsage, filePtr\fR)
 .sp
 .SH ARGUMENTS
-.AS Tcl_Interp checkUsage out
+.AS Tcl_Interp checkUsage
 .AP Tcl_Interp *interp in
 Tcl interpreter from which file handle is to be obtained.
-.AP "const char" *chanID in
+.AP "CONST char" *string in
 String identifying channel, such as \fBstdin\fR or \fBfile4\fR.
 .AP int write in
 Non-zero means the file will be used for writing, zero means it will
 be used for reading.
 .AP int checkUsage in
-If non-zero, then an error will be generated if the file was not opened
+If non-zero, then an error will be generated if the file wasn't opened
 for the access indicated by \fIwrite\fR.
 .AP ClientData *filePtr out
 Points to word in which to store pointer to FILE structure for
-the file given by \fIchanID\fR.
+the file given by \fIstring\fR.
 .BE

 .SH DESCRIPTION
@@ -44,15 +45,17 @@ be used for reading or writing.
 In some cases, such as a channel that connects to a pipeline of
 subprocesses, different FILE pointers will be returned for reading
 and writing.
-\fBTcl_GetOpenFile\fR normally returns \fBTCL_OK\fR.
-If an error occurs in \fBTcl_GetOpenFile\fR (e.g. \fIchanID\fR did not
-make any sense or \fIcheckUsage\fR was set and the file was not opened
-for the access specified by \fIwrite\fR) then \fBTCL_ERROR\fR is returned
+\fBTcl_GetOpenFile\fR normally returns TCL_OK.
+If an error occurs in \fBTcl_GetOpenFile\fR (e.g. \fIstring\fR didn't
+make any sense or \fIcheckUsage\fR was set and the file wasn't opened
+for the access specified by \fIwrite\fR) then TCL_ERROR is returned
 and the interpreter's result will contain an error message.
 In the current implementation \fIcheckUsage\fR is ignored and consistency
 checks are always performed.
+.VS
 .PP
 Note that this interface is only supported on the Unix platform.
+.VE

 .SH KEYWORDS
 channel, file handle, permissions, pipeline, read, write
@@ -4,6 +4,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: GetStdChan.3,v 1.4 2001/12/10 15:50:46 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_GetStdChannel 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -20,7 +22,7 @@ Tcl_Channel
 \fBTcl_SetStdChannel\fR(\fIchannel, type\fR)
 .sp
 .SH ARGUMENTS
-.AS Tcl_Channel channel
+.AS Tcl_Channel channel in
 .AP int type in
 The identifier for the standard channel to retrieve or modify.  Must be one of
 \fBTCL_STDIN\fR, \fBTCL_STDOUT\fR, or \fBTCL_STDERR\fR.
@@ -51,16 +53,6 @@ by calling \fBTcl_SetStdChannel\fR with a new channel or NULL in the
 \fBTcl_Close\fR, then the corresponding standard channel will automatically be
 set to NULL.
 .PP
-If a non-NULL value for \fIchannel\fR is passed to \fBTcl_SetStdChannel\fR,
-then that same value should be passed to \fBTcl_RegisterChannel\fR, like so:
-.CS
-Tcl_RegisterChannel(NULL, channel);
-.CE
-This is a workaround for a misfeature in \fBTcl_SetStdChannel\fR that it
-fails to do some reference counting housekeeping.  This misfeature cannot
-be corrected without contradicting the assumptions of some existing
-code that calls \fBTcl_SetStdChannel\fR.
-.PP
 If \fBTcl_GetStdChannel\fR is called before \fBTcl_SetStdChannel\fR, Tcl will
 construct a new channel to wrap the appropriate platform-specific standard 
 file handle.  If \fBTcl_SetStdChannel\fR is called before
@@ -76,6 +68,7 @@ standard error being last.
 .PP
 See \fBTcl_StandardChannels\fR for a general treatise about standard
 channels and the behaviour of the Tcl library with regard to them.
+.PP

 .SH "SEE ALSO"
 Tcl_Close(3), Tcl_CreateChannel(3), Tcl_Main(3), tclsh(1)
@@ -1,46 +1,25 @@
 '\"
-'\" Copyright (c) 2001 by Kevin B. Kenny <kennykb@acm.org>.
+'\" Copyright (c) 2001 by Kevin B. Kenny.
 '\"
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id$
+'\" 
 .so man.macros
 .TH Tcl_GetTime 3 8.4 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_GetTime, Tcl_SetTimeProc, Tcl_QueryTimeProc \- get date and time
+Tcl_GetTime \- get date and time
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
-\fBTcl_GetTime\fR(\fItimePtr\fR)
-.sp
-\fBTcl_SetTimeProc\fR(\fIgetProc, scaleProc, clientData\fR)
-.sp
-\fBTcl_QueryTimeProc\fR(\fIgetProcPtr, scaleProcPtr, clientDataPtr\fR)
+\fBTcl_GetTime\fR(\fI timePtr \fR)
 .SH ARGUMENTS
-.AS "Tcl_Time *" timePtr out
+.AS "Tcl_Time *" timePtr
 .AP "Tcl_Time *" timePtr out
 Points to memory in which to store the date and time information.
-.AS "Tcl_GetTimeProc *" getProc in
-.AP "Tcl_GetTimeProc *" getProc in
-Pointer to handler function replacing \fBTcl_GetTime\fR's access to the OS.
-.AS "Tcl_ScaleTimeProc *" scaleProc in
-.AP "Tcl_ScaleTimeProc *" scaleProc in
-Pointer to handler function for the conversion of time delays in the
-virtual domain to real-time.
-.AS "ClientData *" clientData in
-.AP "ClientData *" clientData in
-Value passed through to the two handler functions.
-.AS "Tcl_GetTimeProc **" getProcPtr inout
-.AP "Tcl_GetTimeProc **" getProcPtr inout
-Pointer to place the currently registered get handler function into.
-.AS "Tcl_ScaleTimeProc **" scaleProcPtr inout
-.AP "Tcl_ScaleTimeProc **" scaleProcPtr inout
-Pointer to place the currently registered scale handler function into.
-.AS "ClientData **" clientDataPtr inout
-.AP "ClientData **" clientDataPtr inout
-Pointer to place the currently registered pass-through value into.
 .BE
 .SH DESCRIPTION
 .PP
@@ -68,32 +47,6 @@ computer system.  On multiprocessor variants of Windows, this number
 may be limited to the 10- or 20-ms granularity of the system clock.
 (On single-processor Windows systems, the \fIusec\fR field is derived
 from a performance counter and is highly precise.)
-.PP
-The \fBTcl_SetTime\fR function registers two related handler functions
-with the core. The first handler function is a replacement for
-\fBTcl_GetTime\fR, or rather the OS access made by
-\fBTcl_GetTime\fR. The other handler function is used by the Tcl
-notifier to convert wait/block times from the virtual domain into real
-time.
-.PP
-The \fBTcl_QueryTime\fR function returns the currently registered
-handler functions. If no external handlers were set then this will
-return the standard handlers accessing and processing the native time
-of the OS. The arguments to the function are allowed to be NULL; and
-any argument which is NULL is ignored and not set.
-.PP
-Any handler pair specified has to return data which is consistent
-between them. In other words, setting one handler of the pair to
-something assuming a 10-times slowdown, and the other handler of the
-pair to something assuming a two-times slowdown is wrong and not
-allowed.
-.PP
-The set handler functions are allowed to run the delivered time
-backwards, however this should be avoided. We have to allow it as the
-native time can run backwards as the user can fiddle with the system
-time one way or other. Note that the insertion of the hooks will not
-change the behaviour of the Tcl core with regard to this situation,
-i.e. the existing behaviour is retained.
 .SH "SEE ALSO"
 clock
 .SH KEYWORDS
@@ -4,6 +4,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: GetVersion.3,v 1.3 2001/12/14 06:04:42 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_GetVersion 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -15,7 +17,6 @@ Tcl_GetVersion \- get the version of the library at runtime
 .sp
 \fBTcl_GetVersion\fR(\fImajor, minor, patchLevel, type\fR)
 .SH ARGUMENTS
-.AS Tcl_ReleaseType *patchLevel out
 .AP int *major out
 Major version number of the Tcl library.
 .AP int *minor out
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Hash.3,v 1.8 2001/01/18 19:09:55 andreas_kupries Exp $
+'\" 
 .so man.macros
 .TH Tcl_Hash 3 "" Tcl "Tcl Library Procedures"
 .BS
@@ -47,18 +49,18 @@ Tcl_HashEntry *
 char *
 \fBTcl_HashStats\fR(\fItablePtr\fR)
 .SH ARGUMENTS
-.AS Tcl_HashKeyType *searchPtr out
+.AS Tcl_HashSearch *searchPtr
 .AP Tcl_HashTable *tablePtr in
 Address of hash table structure (for all procedures but
 \fBTcl_InitHashTable\fR, this must have been initialized by
 previous call to \fBTcl_InitHashTable\fR).
 .AP int keyType in
 Kind of keys to use for new hash table.  Must be either
-\fBTCL_STRING_KEYS\fR, \fBTCL_ONE_WORD_KEYS\fR, \fBTCL_CUSTOM_TYPE_KEYS\fR,
-\fBTCL_CUSTOM_PTR_KEYS\fR, or an integer value greater than 1.
+TCL_STRING_KEYS, TCL_ONE_WORD_KEYS, TCL_CUSTOM_TYPE_KEYS,
+TCL_CUSTOM_PTR_KEYS, or an integer value greater than 1.
 .AP Tcl_HashKeyType *typePtr in
 Address of structure which defines the behaviour of the hash table.
-.AP "const char" *key in
+.AP char *key in
 Key to use for probe into table.  Exact form depends on
 \fIkeyType\fR used to create table.
 .AP int *newPtr out
@@ -86,9 +88,7 @@ STRUCTURE\fR below). All of the keys in a given table have the same
 form, which is specified when the table is initialized.
 .PP
 The value of a hash table entry can be anything that fits in the same
-space as a
-.QW "char *"
-pointer.  Values for hash table entries are
+space as a ``char *'' pointer.  Values for hash table entries are
 managed entirely by clients, not by the hash module itself.  Typically
 each entry's value is a pointer to a data structure managed by client
 code.
@@ -119,15 +119,13 @@ caller, not by the hash module.  The value of \fIkeyType\fR indicates
 what kinds of keys will be used for all entries in the table.
 \fIKeyType\fR must have one of the following values:
 .IP \fBTCL_STRING_KEYS\fR 25
-Keys are null-terminated strings.
+Keys are null-terminated ASCII strings.
 They are passed to hashing routines using the address of the
 first character of the string.
 .IP \fBTCL_ONE_WORD_KEYS\fR 25
 Keys are single-word values;  they are passed to hashing routines
-and stored in hash table entries as
-.QW "char *"
-values.
-The pointer value is the key;  it need not (and usually does not)
+and stored in hash table entries as ``char *'' values.
+The pointer value is the key;  it need not (and usually doesn't)
 actually point to a string.
 .IP \fBTCL_CUSTOM_TYPE_KEYS\fR 25
 Keys are of arbitrary type, and are stored in the entry. Hashing
@@ -142,9 +140,7 @@ structure is described in the section
 .IP \fIother\fR 25
 If \fIkeyType\fR is not one of the above,
 then it must be an integer value greater than 1.
-In this case the keys will be arrays of
-.QW int
-values, where
+In this case the keys will be arrays of ``int'' values, where
 \fIkeyType\fR gives the number of ints in each key.
 This allows structures to be used as keys.
 All keys must have the same size.
@@ -165,7 +161,7 @@ before deleting the table.
 .PP
 \fBTcl_CreateHashEntry\fR locates the entry corresponding to a
 particular key, creating a new entry in the table if there
-was not already one with the given key.
+wasn't already one with the given key.
 If an entry already existed with the given key then \fI*newPtr\fR
 is set to zero.
 If a new entry was created, then \fI*newPtr\fR is set to a non-zero
@@ -181,34 +177,28 @@ the client is responsible for any cleanup associated with the
 entry's value, such as freeing a structure that it points to.
 .PP
 \fBTcl_FindHashEntry\fR is similar to \fBTcl_CreateHashEntry\fR
-except that it does not create a new entry if the key doesn't exist;
+except that it doesn't create a new entry if the key doesn't exist;
 instead, it returns NULL as result.
 .PP
 \fBTcl_GetHashValue\fR and \fBTcl_SetHashValue\fR are used to
 read and write an entry's value, respectively.
-Values are stored and retrieved as type
-.QW ClientData ,
-which is
+Values are stored and retrieved as type ``ClientData'', which is
 large enough to hold a pointer value.  On almost all machines this is
 large enough to hold an integer value too.
 .PP
 \fBTcl_GetHashKey\fR returns the key for a given hash table entry,
-either as a pointer to a string, a one-word
-.PQ "char *"
-key, or
+either as a pointer to a string, a one-word (``char *'') key, or
 as a pointer to the first word of an array of integers, depending
 on the \fIkeyType\fR used to create a hash table.
 In all cases \fBTcl_GetHashKey\fR returns a result with type
-.QW "char *" .
+``char *''.
 When the key is a string or array, the result of \fBTcl_GetHashKey\fR
 points to information in the table entry;  this information will
 remain valid until the entry is deleted or its table is deleted.
 .PP
 \fBTcl_FirstHashEntry\fR and \fBTcl_NextHashEntry\fR may be used
 to scan all of the entries in a hash table.
-A structure of type
-.QW Tcl_HashSearch ,
-provided by the client,
+A structure of type ``Tcl_HashSearch'', provided by the client,
 is used to keep track of progress through the table.
 \fBTcl_FirstHashEntry\fR initializes the search record and
 returns the first entry in the table (or NULL if the table is
@@ -219,10 +209,9 @@ NULL if the end of the table has been reached.
 A call to \fBTcl_FirstHashEntry\fR followed by calls to
 \fBTcl_NextHashEntry\fR will return each of the entries in
 the table exactly once, in an arbitrary order.
-It is inadvisable to modify the structure of the table, e.g.
-by creating or deleting entries, while the search is in progress,
-with the exception of deleting the entry returned by
-\fBTcl_FirstHashEntry\fR or \fBTcl_NextHashEntry\fR.
+It is unadvisable to modify the structure of the table, e.g.
+by creating or deleting entries, while the search is in
+progress.
 .PP
 \fBTcl_HashStats\fR returns a dynamically-allocated string with
 overall information about a hash table, such as the number of
@@ -241,10 +230,10 @@ to any of the fields of any of the hash-related data structures;
 use the procedures and macros defined here.
 .SH "THE TCL_HASHKEYTYPE STRUCTURE"
 .PP
-Extension writers can define new hash key types by defining four procedures,
-initializing a \fBTcl_HashKeyType\fR structure to describe the type, and
-calling \fBTcl_InitCustomHashTable\fR. The \fBTcl_HashKeyType\fR structure is
-defined as follows:
+Extension writers can define new hash key types by defining four
+procedures, initializing a Tcl_HashKeyType structure to describe
+the type, and calling \fBTcl_InitCustomHashTable\fR.
+The \fBTcl_HashKeyType\fR structure is defined as follows:
 .CS
 typedef struct Tcl_HashKeyType {
    int \fIversion\fR;
@@ -256,71 +245,61 @@ typedef struct Tcl_HashKeyType {
 } Tcl_HashKeyType;
 .CE
 .PP
-The \fIversion\fR member is the version of the table. If this structure is
-extended in future then the version can be used to distinguish between
-different structures. It should be set to \fBTCL_HASH_KEY_TYPE_VERSION\fR.
+The \fIversion\fR member is the version of the table. If this
+structure is extended in future then the version can be used
+to distinguish between different structures. It should be set
+to \fBTCL_HASH_KEY_TYPE_VERSION\fR.
 .PP
-The \fIflags\fR member is 0 or one or more of the following values OR'ed
-together:
+The \fIflags\fR member is one or more of the following values OR'ed together:
 .IP \fBTCL_HASH_KEY_RANDOMIZE_HASH\fR 25
-There are some things, pointers for example which do not hash well because
-they do not use the lower bits. If this flag is set then the hash table will
-attempt to rectify this by randomizing the bits and then using the upper N
-bits as the index into the table.
-.IP \fBTCL_HASH_KEY_SYSTEM_HASH\fR 25
-.VS 8.5
-This flag forces Tcl to use the memory allocation procedures provided by the
-operating system when allocating and freeing memory used to store the hash
-table data structures, and not any of Tcl's own customized memory allocation
-routines. This is important if the hash table is to be used in the
-implementation of a custom set of allocation routines, or something that a
-custom set of allocation routines might depend on, in order to avoid any
-circular dependency.
-.VE 8.5
+There are some things, pointers for example which don't hash well 
+because they do not use the lower bits. If this flag is set then the
+hash table will attempt to rectify this by randomising the bits and 
+then using the upper N bits as the index into the table.
 .PP
-The \fIhashKeyProc\fR member contains the address of a function called to
-calculate a hash value for the key.
+The \fIhashKeyProc\fR member contains the address of a function 
+called to calculate a hash value for the key.
 .CS
 typedef unsigned int (Tcl_HashKeyProc) (
-        Tcl_HashTable *\fItablePtr\fR,
-        void *\fIkeyPtr\fR);
+    Tcl_HashTable *\fItablePtr\fR,
+    VOID *\fIkeyPtr\fR);
 .CE
-If this is NULL then \fIkeyPtr\fR is used and
+If this is NULL then \fIkeyPtr\fR is used and 
 \fBTCL_HASH_KEY_RANDOMIZE_HASH\fR is assumed.
 .PP
-The \fIcompareKeysProc\fR member contains the address of a function called to
-compare two keys.
+The \fIcompareKeysProc\fR member contains the address of a function 
+called to compare two keys.
 .CS
-typedef int (Tcl_CompareHashKeysProc) (
-        void *\fIkeyPtr\fR,
-        Tcl_HashEntry *\fIhPtr\fR);
+typedef int (Tcl_CompareHashKeysProc) (VOID *\fIkeyPtr\fR,
+    Tcl_HashEntry *\fIhPtr\fR);
 .CE
-If this is NULL then the \fIkeyPtr\fR pointers are compared. If the keys do
-not match then the function returns 0, otherwise it returns 1.
+If this is NULL then the \fIkeyPtr\fR pointers are compared.
+If the keys don't match then the function returns 0, otherwise
+it returns 1.
 .PP
-The \fIallocEntryProc\fR member contains the address of a function called to
-allocate space for an entry and initialize the key and clientData.
+The \fIallocEntryProc\fR member contains the address of a function 
+called to allocate space for an entry and initialise the key.
 .CS
 typedef Tcl_HashEntry *(Tcl_AllocHashEntryProc) (
-        Tcl_HashTable *\fItablePtr\fR,
-        void *\fIkeyPtr\fR);
+    Tcl_HashTable *\fItablePtr\fR, VOID *\fIkeyPtr\fR);
 .CE
 If this is NULL then Tcl_Alloc is used to allocate enough space for a
-Tcl_HashEntry, the key pointer is assigned to key.oneWordValue and the
-clientData is set to NULL. String keys and array keys use this function to
-allocate enough space for the entry and the key in one block, rather than
-doing it in two blocks. This saves space for a pointer to the key from the
-entry and another memory allocation. Tcl_Obj* keys use this function to
-allocate enough space for an entry and increment the reference count on the
-object.
+Tcl_HashEntry and the key pointer is assigned to key.oneWordValue.
+String keys and array keys use this function to allocate enough 
+space for the entry and the key in one block, rather than doing
+it in two blocks. This saves space for a pointer to the key from
+the entry and another memory allocation. Tcl_Obj * keys use this 
+function to allocate enough space for an entry and increment the 
+reference count on the object.
+If 
 .PP
-The \fIfreeEntryProc\fR member contains the address of a function called to
-free space for an entry.
+The \fIfreeEntryProc\fR member contains the address of a function 
+called to free space for an entry.
 .CS
 typedef void (Tcl_FreeHashEntryProc) (Tcl_HashEntry *\fIhPtr\fR);
 .CE
-If this is NULL then Tcl_Free is used to free the space for the entry.
-Tcl_Obj* keys use this function to decrement the reference count on the
-object.
+If this is NULL then Tcl_Free is used to free the space for the 
+entry. Tcl_Obj * keys use this function to decrement the
+reference count on the object.
 .SH KEYWORDS
 hash table, key, lookup, search, value
@@ -2,6 +2,8 @@
 '\" Copyright (c) 1998-2000 by Scriptics Corporation.
 '\" All rights reserved.
 '\" 
+'\" RCS: @(#) $Id: Init.3,v 1.1 2000/04/28 00:47:48 ericm Exp $
+'\" 
 .so man.macros
 .TH Tcl_Init 3 8.0 Tcl "Tcl Library Procedures"
 .BS
@@ -14,16 +16,17 @@ Tcl_Init \- find and source initialization script
 int
 \fBTcl_Init\fR(\fIinterp\fR)
 .SH ARGUMENTS
-.AS Tcl_Interp *interp
 .AP Tcl_Interp *interp in
 Interpreter to initialize.
 .BE

 .SH DESCRIPTION
 .PP
-\fBTcl_Init\fR is a helper procedure that finds and \fBsource\fRs the
+\fBTcl_Init\fR is a helper procedure that finds and \fBsource\fR's the
 \fBinit.tcl\fR script, which should exist somewhere on the Tcl library
-path.
+path.  On Macintosh systems, it additionally checks for an \fBInit\fR
+resource and sources the contents of that resource if \fBinit.tcl\fR
+cannot be found.
 .PP
 \fBTcl_Init\fR is typically called from \fBTcl_AppInit\fR procedures.

@@ -1,9 +1,11 @@
 '\"
-'\" Copyright (c) 1998-1999 Scriptics Corporation
+'\" Copyright (c) 1999 Scriptics Corportation
 '\"
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: InitStubs.3,v 1.6 2001/09/24 06:19:36 dgp Exp $
+'\" 
 .so man.macros
 .TH Tcl_InitStubs 3 8.1 Tcl "Tcl Library Procedures"
 .BS
@@ -13,13 +15,13 @@ Tcl_InitStubs \- initialize the Tcl stubs mechanism
 .nf
 \fB#include <tcl.h>\fR
 .sp
-const char *
+CONST char *
 \fBTcl_InitStubs\fR(\fIinterp, version, exact\fR)
 .SH ARGUMENTS
-.AS Tcl_Interp *interp
+.AS Tcl_Interp *interp in
 .AP Tcl_Interp *interp in
 Tcl interpreter handle.
-.AP "const char" *version in
+.AP "CONST char" *version in
 A version string consisting of one or more decimal numbers
 separated by dots.
 .AP int exact in
@@ -59,13 +61,13 @@ steps:
 Call \fBTcl_InitStubs\fR in the extension before calling any other
 Tcl functions.
 .IP 2) 5
-Define the \fBUSE_TCL_STUBS\fR symbol.  Typically, you would include the
-\fB\-DUSE_TCL_STUBS\fR flag when compiling the extension.
+Define the USE_TCL_STUBS symbol.  Typically, you would include the
+-DUSE_TCL_STUBS flag when compiling the extension.
 .IP 3) 5
 Link the extension with the Tcl stubs library instead of the standard
 Tcl library.  On Unix platforms, the library name is
-\fIlibtclstub8.5.a\fR; on Windows platforms, the library name is
-\fItclstub85.lib\fR.
+\fIlibtclstub8.1.a\fR; on Windows platforms, the library name is
+\fItclstub81.lib\fR.
 .PP
 If the extension also requires the Tk API, it must also call
 \fBTk_InitStubs\fR to initialize the Tk stubs interface and link
@@ -84,6 +86,6 @@ non-zero means that only the specified \fIversion\fR is acceptable.
 of Tcl satisfying the request, or NULL if the Tcl version is not
 acceptable, does not support stubs, or any other error condition occurred.
 .SH "SEE ALSO"
-Tk_InitStubs
+\fBTk_InitStubs\fR
 .SH KEYWORDS
 stubs
@@ -4,11 +4,13 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: IntObj.3,v 1.2 1998/09/14 18:39:49 stanton Exp $
+'\" 
 .so man.macros
-.TH Tcl_IntObj 3 8.5 Tcl "Tcl Library Procedures"
+.TH Tcl_IntObj 3 8.0 Tcl "Tcl Library Procedures"
 .BS
 .SH NAME
-Tcl_NewIntObj, Tcl_NewLongObj, Tcl_NewWideIntObj, Tcl_SetIntObj, Tcl_SetLongObj, Tcl_SetWideIntObj, Tcl_GetIntFromObj, Tcl_GetLongFromObj, Tcl_GetWideIntFromObj, Tcl_NewBignumObj, Tcl_SetBignumObj, Tcl_GetBignumFromObj, Tcl_TakeBignumFromObj \- manipulate Tcl objects as integer values
+Tcl_NewIntObj, Tcl_NewLongObj, Tcl_SetIntObj, Tcl_SetLongObj, Tcl_GetIntFromObj, Tcl_GetLongFromObj \- manipulate Tcl objects as integers
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -19,142 +21,84 @@ Tcl_Obj *
 Tcl_Obj *
 \fBTcl_NewLongObj\fR(\fIlongValue\fR)
 .sp
-Tcl_Obj *
-\fBTcl_NewWideIntObj\fR(\fIwideValue\fR)
-.sp
 \fBTcl_SetIntObj\fR(\fIobjPtr, intValue\fR)
 .sp
 \fBTcl_SetLongObj\fR(\fIobjPtr, longValue\fR)
 .sp
-\fBTcl_SetWideIntObj\fR(\fIobjPtr, wideValue\fR)
-.sp
 int
 \fBTcl_GetIntFromObj\fR(\fIinterp, objPtr, intPtr\fR)
 .sp
 int
 \fBTcl_GetLongFromObj\fR(\fIinterp, objPtr, longPtr\fR)
-.sp
-int
-\fBTcl_GetWideIntFromObj\fR(\fIinterp, objPtr, widePtr\fR)
-.sp
-.sp
-.VS 8.5
-\fB#include <tclTomMath.h>\fR
-.sp
-Tcl_Obj *
-\fBTcl_NewBignumObj\fR(\fIbigValue\fR)
-.sp
-\fBTcl_SetBignumObj\fR(\fIobjPtr, bigValue\fR)
-.sp
-int
-\fBTcl_GetBignumFromObj\fR(\fIinterp, objPtr, bigValue\fR)
-.sp
-int
-\fBTcl_TakeBignumFromObj\fR(\fIinterp, objPtr, bigValue\fR)
-.sp
-int
-\fBTcl_InitBignumFromDouble\fR(\fIinterp, doubleValue, bigValue\fR)
-.VE 8.5
 .SH ARGUMENTS
-.AS Tcl_WideInt doubleValue in/out
+.AS Tcl_Interp *interp
 .AP int intValue in
-Integer value used to initialize or set a Tcl object.
+Integer value used to initialize or set an integer object.
 .AP long longValue in
-Long integer value used to initialize or set a Tcl object.
-.AP Tcl_WideInt wideValue in
-Wide integer value used to initialize or set a Tcl object.
+Long integer value used to initialize or set an integer object.
 .AP Tcl_Obj *objPtr in/out
-For \fBTcl_SetIntObj\fR, \fBTcl_SetLongObj\fR, \fBTcl_SetWideIntObj\fR,
-and \fBTcl_SetBignumObj\fR, this points to the object in which to store an
-integral value.  For \fBTcl_GetIntFromObj\fR, \fBTcl_GetLongFromObj\fR,
-\fBTcl_GetWideIntFromObj\fR, \fBTcl_GetBignumFromObj\fR, and
-\fBTcl_TakeBignumFromObj\fR, this refers to the object from which
-to retrieve an integral value.
+For \fBTcl_SetIntObj\fR and \fBTcl_SetLongObj\fR,
+this points to the object to be converted to integer type.
+For \fBTcl_GetIntFromObj\fR and \fBTcl_GetLongFromObj\fR,
+this refers to the object
+from which to get an integer or long integer value; 
+if \fIobjPtr\fR does not already point to an integer object,
+an attempt will be made to convert it to one.
 .AP Tcl_Interp *interp in/out
-When non-NULL, an error message is left here when integral value
-retrieval fails.
+If an error occurs during conversion,
+an error message is left in the interpreter's result object
+unless \fIinterp\fR is NULL.
 .AP int *intPtr out
-Points to place to store the integer value retrieved from \fIobjPtr\fR.
+Points to place to store the integer value
+obtained by \fBTcl_GetIntFromObj\fR from \fIobjPtr\fR.
 .AP long *longPtr out
-Points to place to store the long integer value retrieved from \fIobjPtr\fR.
-.AP Tcl_WideInt *widePtr out
-Points to place to store the wide integer value retrieved from \fIobjPtr\fR.
-.AP mp_int *bigValue in/out
-.VS 8.5
-Points to a multi-precision integer structure declared by the LibTomMath
-library.
-.VE 8.5
-.AP double doubleValue in
-.VS 8.5
-Double value from which the integer part is determined and
-used to initialize a multi-precision integer value.
-.VE 8.5
+Points to place to store the long integer value
+obtained by \fBTcl_GetLongFromObj\fR from \fIobjPtr\fR.
 .BE

 .SH DESCRIPTION
 .PP
-.VS 8.5
-These procedures are used to create, modify, and read Tcl objects
-that hold integral values.  
+These procedures are used to create, modify, and read
+integer Tcl objects from C code.
+\fBTcl_NewIntObj\fR, \fBTcl_NewLongObj\fR,
+\fBTcl_SetIntObj\fR, and \fBTcl_SetLongObj\fR
+create a new object of integer type
+or modify an existing object to have integer type. 
+\fBTcl_NewIntObj\fR and \fBTcl_SetIntObj\fR set the object to have the
+integer value given by \fIintValue\fR,
+while \fBTcl_NewLongObj\fR and \fBTcl_SetLongObj\fR
+set the object to have the
+long integer value given by \fIlongValue\fR.
+\fBTcl_NewIntObj\fR and \fBTcl_NewLongObj\fR
+return a pointer to a newly created object with reference count zero.
+These procedures set the object's type to be integer
+and assign the integer value to the object's internal representation
+\fIlongValue\fR member.
+\fBTcl_SetIntObj\fR and \fBTcl_SetLongObj\fR
+invalidate any old string representation and,
+if the object is not already an integer object,
+free any old internal representation.
 .PP
-The different routines exist to accommodate different integral types in C
-with which values might be exchanged.  The C integral types for which Tcl
-provides value exchange routines are \fBint\fR, \fBlong int\fR,
-\fBTcl_WideInt\fR, and \fBmp_int\fR.  The \fBint\fR and \fBlong int\fR types
-are provided by the C language standard.  The \fBTcl_WideInt\fR type is a
-typedef defined to be whatever signed integral type covers at least the
-64-bit integer range (-9223372036854775808 to 9223372036854775807).  Depending
-on the platform and the C compiler, the actual type might be
-\fBlong int\fR, \fBlong long int\fR, \fBint64\fR, or something else.
-The \fBmp_int\fR type is a multiple-precision integer type defined
-by the LibTomMath multiple-precision integer library.  
-.PP
-The \fBTcl_NewIntObj\fR, \fBTcl_NewLongObj\fR, \fBTcl_NewWideIntObj\fR,
-and \fBTcl_NewBignumObj\fR routines each create and return a new
-Tcl object initialized to the integral value of the argument.  The
-returned Tcl object is unshared.
-.PP
-The \fBTcl_SetIntObj\fR, \fBTcl_SetLongObj\fR, \fBTcl_SetWideIntObj\fR,
-and \fBTcl_SetBignumObj\fR routines each set the value of an existing
-Tcl object pointed to by \fIobjPtr\fR to the integral value provided
-by the other argument.  The \fIobjPtr\fR argument must point to an
-unshared Tcl object.  Any attempt to set the value of a shared Tcl object
-violates Tcl's copy-on-write policy.  Any existing string representation
-or internal representation in the unshared Tcl object will be freed
-as a consequence of setting the new value.
-.PP
-The \fBTcl_GetIntFromObj\fR, \fBTcl_GetLongFromObj\fR,
-\fBTcl_GetWideIntFromObj\fR, \fBTcl_GetBignumFromObj\fR, and
-\fBTcl_TakeBignumFromObj\fR routines attempt to retrieve an integral
-value of the appropriate type from the Tcl object \fIobjPtr\fR.  If the
-attempt succeeds, then \fBTCL_OK\fR is returned, and the value is
-written to the storage provided by the caller.  The attempt might
-fail if \fIobjPtr\fR does not hold an integral value, or if the
-value exceeds the range of the target type.  If the attempt fails,
-then \fBTCL_ERROR\fR is returned, and if \fIinterp\fR is non-NULL,
-an error message is left in \fIinterp\fR.  The \fBTcl_ObjType\fR
-of \fIobjPtr\fR may be changed to make subsequent calls to the
-same routine more efficient. Unlike the other functions,
-\fBTcl_TakeBignumFromObj\fR may set the content of the Tcl object
-\fIobjPtr\fR to an empty string in the process of retrieving the
-multiple-precision integer value.
-.PP
-The choice between \fBTcl_GetBignumFromObj\fR and
-\fBTcl_TakeBignumFromObj\fR is governed by how the caller will
-continue to use \fIobjPtr\fR.  If after the \fBmp_int\fR value
-is retrieved from \fIobjPtr\fR, the caller will make no more
-use of \fIobjPtr\fR, then using \fBTcl_TakeBignumFromObj\fR
-permits Tcl to detect when an unshared \fIobjPtr\fR permits the
-value to be moved instead of copied, which should be more efficient.
-If anything later in the caller requires
-\fIobjPtr\fR to continue to hold the same value, then
-\fBTcl_GetBignumFromObj\fR must be chosen.
-.PP
-The \fBTcl_InitBignumFromDouble\fR routine is a utility procedure
-that extracts the integer part of \fIdoubleValue\fR and stores that
-integer value in the \fBmp_int\fR value \fIbigValue\fR.
-.VE 8.5
+\fBTcl_GetIntFromObj\fR and \fBTcl_GetLongFromObj\fR
+attempt to return an integer value from the Tcl object \fIobjPtr\fR.
+If the object is not already an integer object,
+they will attempt to convert it to one.
+If an error occurs during conversion, they return \fBTCL_ERROR\fR
+and leave an error message in the interpreter's result object
+unless \fIinterp\fR is NULL.
+Also, if the long integer held in the object's internal representation
+\fIlongValue\fR member can not be represented in a (non-long) integer,
+\fBTcl_GetIntFromObj\fR returns \fBTCL_ERROR\fR
+and leaves an error message in the interpreter's result object
+unless \fIinterp\fR is NULL.
+Otherwise, both procedures return \fBTCL_OK\fR and
+store the integer or the long integer value
+in the address given by \fIintPtr\fR and \fIlongPtr\fR respectively.
+If the object is not already an integer object,
+the conversion will free any old internal representation.
+
 .SH "SEE ALSO"
 Tcl_NewObj, Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_GetObjResult
+
 .SH KEYWORDS
 integer, integer object, integer type, internal representation, object, object type, string representation
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: Interp.3,v 1.3 2000/04/14 23:01:51 hobbs Exp $
+'\" 
 .so man.macros
 .TH Tcl_Interp 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -15,9 +17,9 @@ Tcl_Interp \- client-visible fields of interpreter structures
 \fB#include <tcl.h>\fR
 .sp
 typedef struct {
-        char *\fIresult\fR;
-        Tcl_FreeProc *\fIfreeProc\fR;
-        int \fIerrorLine\fR;
+	char *\fIresult\fR;
+	Tcl_FreeProc *\fIfreeProc\fR;
+	int \fIerrorLine\fR;
 } Tcl_Interp;

 typedef void Tcl_FreeProc(char *\fIblockPtr\fR);
@@ -28,23 +30,17 @@ typedef void Tcl_FreeProc(char *\fIblockPtr\fR);
 The \fBTcl_CreateInterp\fR procedure returns a pointer to a Tcl_Interp
 structure.  This pointer is then passed into other Tcl procedures
 to process commands in the interpreter and perform other operations
-on the interpreter.  Interpreter structures contain many fields
+on the interpreter.  Interpreter structures contain many many fields
 that are used by Tcl, but only three that may be accessed by
 clients:  \fIresult\fR, \fIfreeProc\fR, and \fIerrorLine\fR.
 .PP
-.VS 8.5
-\fBNote that access to all three fields, \fIresult\fB, \fIfreeProc\fB and
-\fIerrorLine\fB is deprecated.\fR  Use \fBTcl_SetResult\fR,
-\fBTcl_GetResult\fR, and \fBTcl_GetReturnOptions\fR instead.
-.VE 8.5
-.PP
 The \fIresult\fR and \fIfreeProc\fR fields are used to return
 results or error messages from commands.
 This information is returned by command procedures back to \fBTcl_Eval\fR,
 and by \fBTcl_Eval\fR back to its callers.
 The \fIresult\fR field points to the string that represents the
 result or error message, and the \fIfreeProc\fR field tells how
-to dispose of the storage for the string when it is not needed anymore.
+to dispose of the storage for the string when it isn't needed anymore.
 The easiest way for command procedures to manipulate these
 fields is to call procedures like \fBTcl_SetResult\fR
 or \fBTcl_AppendResult\fR;  they
@@ -61,6 +57,7 @@ should point to an empty string.
 Normally, results are assumed to be statically allocated,
 which means that the contents will not change before the next time
 \fBTcl_Eval\fR is called or some other command procedure is invoked.
+.VS
 In this case, the \fIfreeProc\fR field must be zero.
 Alternatively, a command procedure may dynamically
 allocate its return value (e.g. using \fBTcl_Alloc\fR)
@@ -69,6 +66,7 @@ In this case, the command procedure must also set \fIinterp->freeProc\fR
 to the address of a procedure that can free the value, or \fBTCL_DYNAMIC\fR
 if the storage was allocated directly by Tcl or by a call to
 \fBTcl_Alloc\fR. 
+.VE
 If \fIinterp->freeProc\fR is non-zero, then Tcl will call \fIfreeProc\fR
 to free the space pointed to by \fIinterp->result\fR before it
 invokes the next command.
@@ -80,8 +78,10 @@ macro should be used for this purpose).
 \fIFreeProc\fR should have arguments and result that match the
 \fBTcl_FreeProc\fR declaration above:  it receives a single
 argument which is a pointer to the result value to free.
+.VS
 In most applications \fBTCL_DYNAMIC\fR is the only non-zero value ever
 used for \fIfreeProc\fR.
+.VE
 However, an application may store a different procedure address
 in \fIfreeProc\fR in order to use an alternate memory allocator
 or in order to do other cleanup when the result memory is freed.
@@ -1,194 +0,0 @@
-'\"
-'\" Copyright (c) 2004 Donal K. Fellows
-'\"
-'\" See the file "license.terms" for information on usage and redistribution
-'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-'\" 
-.so man.macros
-.TH Tcl_LimitCheck 3 8.5 Tcl "Tcl Library Procedures"
-.BS
-.SH NAME
-Tcl_LimitAddHandler, Tcl_LimitCheck, Tcl_LimitExceeded, Tcl_LimitGetCommands, Tcl_LimitGetGranularity, Tcl_LimitGetTime, Tcl_LimitReady, Tcl_LimitRemoveHandler, Tcl_LimitSetCommands, Tcl_LimitSetGranularity, Tcl_LimitSetTime, Tcl_LimitTypeEnabled, Tcl_LimitTypeExceeded, Tcl_LimitTypeReset, Tcl_LimitTypeSet \- manage and check resource limits on interpreters
-.SH SYNOPSIS
-.nf
-\fB#include <tcl.h>\fR
-.sp
-int
-\fBTcl_LimitCheck\fR(\fIinterp\fR)
-.sp
-int
-\fBTcl_LimitReady\fR(\fIinterp\fR)
-.sp
-int
-\fBTcl_LimitExceeded\fR(\fIinterp\fR)
-.sp
-int
-\fBTcl_LimitTypeExceeded\fR(\fIinterp, type\fR)
-.sp
-int
-\fBTcl_LimitTypeEnabled\fR(\fIinterp, type\fR)
-.sp
-void
-\fBTcl_LimitTypeSet\fR(\fIinterp, type\fR)
-.sp
-void
-\fBTcl_LimitTypeReset\fR(\fIinterp, type\fR)
-.sp
-int
-\fBTcl_LimitGetCommands\fR(\fIinterp\fR)
-.sp
-void
-\fBTcl_LimitSetCommands\fR(\fIinterp, commandLimit\fR)
-.sp
-void
-\fBTcl_LimitGetTime\fR(\fIinterp, timeLimitPtr\fR)
-.sp
-void
-\fBTcl_LimitSetTime\fR(\fIinterp, timeLimitPtr\fR)
-.sp
-int
-\fBTcl_LimitGetGranularity\fR(\fIinterp, type\fR)
-.sp
-void
-\fBTcl_LimitSetGranularity\fR(\fIinterp, type, granularity\fR)
-.sp
-void
-\fBTcl_LimitAddHandler\fR(\fIinterp, type, handlerProc, clientData, deleteProc\fR)
-.sp
-void
-\fBTcl_LimitRemoveHandler\fR(\fIinterp, type, handlerProc, clientData\fR)
-.SH ARGUMENTS
-.AS Tcl_LimitHandlerDeleteProc commandLimit in/out
-.AP Tcl_Interp *interp in
-Interpreter that the limit being managed applies to or that will have
-its limits checked.
-.AP int type in
-The type of limit that the operation refers to.  This must be either
-\fBTCL_LIMIT_COMMANDS\fR or \fBTCL_LIMIT_TIME\fR.
-.AP int commandLimit in
-The maximum number of commands (as reported by \fBinfo cmdcount\fR)
-that may be executed in the interpreter.
-.AP Tcl_Time *timeLimitPtr in/out
-A pointer to a structure that will either have the new time limit read
-from (\fBTcl_LimitSetTime\fR) or the current time limit written to
-(\fBTcl_LimitGetTime\fR).
-.AP int granularity in
-Divisor that indicates how often a particular limit should really be
-checked.  Must be at least 1.
-.AP Tcl_LimitHandlerProc *handlerProc in
-Function to call when a particular limit is exceeded.  If the
-\fIhandlerProc\fR removes or raises the limit during its processing,
-the limited interpreter will be permitted to continue to process after
-the handler returns.  Many handlers may be attached to the same
-interpreter limit; their order of execution is not defined, and they
-must be identified by \fIhandlerProc\fR and \fIclientData\fR when they
-are deleted.
-.AP ClientData clientData in
-Arbitrary pointer-sized word used to pass some context to the
-\fIhandlerProc\fR function.
-.AP Tcl_LimitHandlerDeleteProc *deleteProc in
-Function to call whenever a handler is deleted.  May be NULL if the
-\fIclientData\fR requires no deletion.
-.BE
-
-.SH DESCRIPTION
-.PP
-Tcl's interpreter resource limit subsystem allows for close control
-over how much computation time a script may use, and is useful for
-cases where a program is divided into multiple pieces where some parts
-are more trusted than others (e.g. web application servers).
-.PP
-Every interpreter may have a limit on the wall-time for execution, and
-a limit on the number of commands that the interpreter may execute.
-Since checking of these limits is potentially expensive (especially
-the time limit), each limit also has a checking granularity, which is
-a divisor for an internal count of the number of points in the core
-where a check may be performed (which is immediately before executing
-a command and at an unspecified frequency between running commands,
-which can happen in empty-bodied \fBwhile\fR loops).
-.PP
-The final component of the limit engine is a callback scheme which
-allows for notifications of when a limit has been exceeded.  These
-callbacks can just provide logging, or may allocate more resources to
-the interpreter to permit it to continue processing longer.
-.PP
-When a limit is exceeded (and the callbacks have run; the order of
-execution of the callbacks is unspecified) execution in the limited
-interpreter is stopped by raising an error and setting a flag that
-prevents the \fBcatch\fR command in that interpreter from trapping
-that error.  It is up to the context that started execution in that
-interpreter (typically a master interpreter) to handle the error.
-.SH "LIMIT CHECKING API"
-.PP
-To check the resource limits for an interpreter, call
-\fBTcl_LimitCheck\fR, which returns \fBTCL_OK\fR if the limit was not
-exceeded (after processing callbacks) and \fBTCL_ERROR\fR if the limit was
-exceeded (in which case an error message is also placed in the
-interpreter result).  That function should only be called when
-\fBTcl_LimitReady\fR returns non-zero so that granularity policy is
-enforced.  This API is designed to be similar in usage to
-\fBTcl_AsyncReady\fR and \fBTcl_AsyncInvoke\fR.
-.PP
-When writing code that may behave like \fBcatch\fR in respect of
-errors, you should only trap an error if \fBTcl_LimitExceeded\fR
-returns zero.  If it returns non-zero, the interpreter is in a
-limit-exceeded state and errors should be allowed to propagate to the
-calling context.  You can also check whether a particular type of
-limit has been exceeded using \fBTcl_LimitTypeExceeded\fR.
-.SH "LIMIT CONFIGURATION"
-.PP
-To check whether a limit has been set (but not whether it has actually
-been exceeded) on an interpreter, call \fBTcl_LimitTypeEnabled\fR with
-the type of limit you want to check.  To enable a particular limit
-call \fBTcl_LimitTypeSet\fR, and to disable a limit call
-\fBTcl_LimitTypeReset\fR.
-.PP
-The level of a command limit may be set using
-\fBTcl_LimitSetCommands\fR, and retrieved using
-\fBTcl_LimitGetCommands\fR.  Similarly for a time limit with
-\fBTcl_LimitSetTime\fR and \fBTcl_LimitGetTime\fR respectively, but
-with that API the time limit is copied from and to the Tcl_Time
-structure that the \fItimeLimitPtr\fR argument points to.
-.PP
-The checking granularity for a particular limit may be set using
-\fBTcl_LimitSetGranularity\fR and retrieved using
-\fBTcl_LimitGetGranularity\fR.  Note that granularities must always be
-positive.
-.SS "LIMIT CALLBACKS"
-.PP
-To add a handler callback to be invoked when a limit is exceeded, call
-\fBTcl_LimitAddHandler\fR.  The \fIhandlerProc\fR argument describes
-the function that will actually be called; it should have the
-following prototype:
-.PP
-.CS
-typedef void Tcl_LimitHandlerProc(
-        ClientData \fIclientData\fR,
-        Tcl_Interp *\fIinterp\fR);
-.CE
-.PP
-The \fIclientData\fR argument to the handler will be whatever is
-passed to the \fIclientData\fR argument to \fBTcl_LimitAddHandler\fR,
-and the \fIinterp\fR is the interpreter that had its limit exceeded.
-.PP
-The \fIdeleteProc\fR argument to \fBTcl_LimitAddHandler\fR is a
-function to call to delete the \fIclientData\fR value.  It may be
-\fBTCL_STATIC\fR or NULL if no deletion action is necessary, or
-\fBTCL_DYNAMIC\fR if all that is necessary is to free the structure with
-\fBTcl_Free\fR.  Otherwise, it should refer to a function with the
-following prototype:
-.PP
-.CS
-typedef void Tcl_LimitHandlerDeleteProc(
-        ClientData \fIclientData\fR);
-.CE
-.PP
-A limit handler may be deleted using \fBTcl_LimitRemoveHandler\fR; the
-handler removed will be the first one found (out of the handlers added
-with \fBTcl_LimitAddHandler\fR) with exactly matching \fItype\fR,
-\fIhandlerProc\fR and \fIclientData\fR arguments.  This function
-always invokes the \fIdeleteProc\fR on the \fIclientData\fR (unless
-the \fIdeleteProc\fR was NULL or \fBTCL_STATIC\fR).
-
-.SH KEYWORDS
-interpreter, resource, limit, commands, time, callback
@@ -5,6 +5,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: LinkVar.3,v 1.3 2000/04/14 23:01:51 hobbs Exp $
+'\" 
 .so man.macros
 .TH Tcl_LinkVar 3 7.5 Tcl "Tcl Library Procedures"
 .BS
@@ -25,24 +27,15 @@ int
 .AP Tcl_Interp *interp in
 Interpreter that contains \fIvarName\fR.
 Also used by \fBTcl_LinkVar\fR to return error messages.
-.AP "const char" *varName in
-Name of global variable.
+.AP char *varName in
+Name of global variable.  Must be in writable memory: Tcl may make
+temporary modifications to it while parsing the variable name.
 .AP char *addr in
 Address of C variable that is to be linked to \fIvarName\fR.
 .AP int type in
-Type of C variable.  Must be one of \fBTCL_LINK_INT\fR,
-.VS 8.5
-\fBTCL_LINK_UINT\fR, \fBTCL_LINK_CHAR\fR, \fBTCL_LINK_UCHAR\fR,
-\fBTCL_LINK_SHORT\fR, \fBTCL_LINK_USHORT\fR, \fBTCL_LINK_LONG\fR,
-\fBTCL_LINK_ULONG\fR,
-.VE 8.5
-\fBTCL_LINK_WIDE_INT\fR,
-.VS 8.5
-\fBTCL_LINK_WIDE_UINT\fR, \fBTCL_LINK_FLOAT\fR,
-.VE 8.5
-\fBTCL_LINK_DOUBLE\fR, \fBTCL_LINK_BOOLEAN\fR, or
-\fBTCL_LINK_STRING\fR, optionally OR'ed with \fBTCL_LINK_READ_ONLY\fR
-to make Tcl variable read-only.
+Type of C variable.  Must be one of TCL_LINK_INT, TCL_LINK_DOUBLE,
+TCL_LINK_BOOLEAN, or TCL_LINK_STRING, optionally OR'ed with
+TCL_LINK_READ_ONLY to make Tcl variable read-only.
 .BE

 .SH DESCRIPTION
@@ -53,140 +46,53 @@ given by \fIaddr\fR.
 Whenever the Tcl variable is read the value of the C variable will
 be returned, and whenever the Tcl variable is written the C
 variable will be updated to have the same value.
-\fBTcl_LinkVar\fR normally returns \fBTCL_OK\fR;  if an error occurs
+\fBTcl_LinkVar\fR normally returns TCL_OK;  if an error occurs
 while setting up the link (e.g. because \fIvarName\fR is the
-name of array) then \fBTCL_ERROR\fR is returned and the interpreter's result
+name of array) then TCL_ERROR is returned and the interpreter's result
 contains an error message.
 .PP
 The \fItype\fR argument specifies the type of the C variable,
 and must have one of the following values, optionally OR'ed with
-\fBTCL_LINK_READ_ONLY\fR:
+TCL_LINK_READ_ONLY:
 .TP
 \fBTCL_LINK_INT\fR
 The C variable is of type \fBint\fR.
 Any value written into the Tcl variable must have a proper integer
-form acceptable to \fBTcl_GetIntFromObj\fR;  attempts to write
+form acceptable to \fBTcl_GetInt\fR;  attempts to write
 non-integer values into \fIvarName\fR will be rejected with
 Tcl errors.
-.VS 8.5
-.TP
-\fBTCL_LINK_UINT\fR
-The C variable is of type \fBunsigned int\fR.
-Any value written into the Tcl variable must have a proper unsigned
-integer form acceptable to \fBTcl_GetWideIntFromObj\fR and in the
-platform's defined range for the \fBunsigned int\fR type; attempts to
-write non-integer values (or values outside the range) into
-\fIvarName\fR will be rejected with Tcl errors.
-.TP
-\fBTCL_LINK_CHAR\fR
-The C variable is of type \fBchar\fR.
-Any value written into the Tcl variable must have a proper integer
-form acceptable to \fBTcl_GetIntFromObj\fR and be in the range of the
-\fBchar\fR datatype; attempts to write non-integer or out-of-range
-values into \fIvarName\fR will be rejected with Tcl errors.
-.TP
-\fBTCL_LINK_UCHAR\fR
-The C variable is of type \fBunsigned char\fR.
-Any value written into the Tcl variable must have a proper unsigned
-integer form acceptable to \fBTcl_GetIntFromObj\fR and in the
-platform's defined range for the \fBunsigned char\fR type; attempts to
-write non-integer values (or values outside the range) into
-\fIvarName\fR will be rejected with Tcl errors.
-.TP
-\fBTCL_LINK_SHORT\fR
-The C variable is of type \fBshort\fR.
-Any value written into the Tcl variable must have a proper integer
-form acceptable to \fBTcl_GetIntFromObj\fR and be in the range of the
-\fBshort\fR datatype; attempts to write non-integer or out-of-range
-values into \fIvarName\fR will be rejected with Tcl errors.
-.TP
-\fBTCL_LINK_USHORT\fR
-The C variable is of type \fBunsigned short\fR.
-Any value written into the Tcl variable must have a proper unsigned
-integer form acceptable to \fBTcl_GetIntFromObj\fR and in the
-platform's defined range for the \fBunsigned short\fR type; attempts to
-write non-integer values (or values outside the range) into
-\fIvarName\fR will be rejected with Tcl errors.
-.TP
-\fBTCL_LINK_LONG\fR
-The C variable is of type \fBlong\fR.
-Any value written into the Tcl variable must have a proper integer
-form acceptable to \fBTcl_GetLongFromObj\fR; attempts to write
-non-integer or out-of-range
-values into \fIvarName\fR will be rejected with Tcl errors.
-.TP
-\fBTCL_LINK_ULONG\fR
-The C variable is of type \fBunsigned long\fR.
-Any value written into the Tcl variable must have a proper unsigned
-integer form acceptable to \fBTcl_GetWideIntFromObj\fR and in the
-platform's defined range for the \fBunsigned long\fR type; attempts to
-write non-integer values (or values outside the range) into
-\fIvarName\fR will be rejected with Tcl errors.
-.VE 8.5
 .TP
 \fBTCL_LINK_DOUBLE\fR
 The C variable is of type \fBdouble\fR.
 Any value written into the Tcl variable must have a proper real
-form acceptable to \fBTcl_GetDoubleFromObj\fR;  attempts to write
+form acceptable to \fBTcl_GetDouble\fR;  attempts to write
 non-real values into \fIvarName\fR will be rejected with
 Tcl errors.
-.VS 8.5
-.TP
-\fBTCL_LINK_FLOAT\fR
-The C variable is of type \fBfloat\fR.
-Any value written into the Tcl variable must have a proper real
-form acceptable to \fBTcl_GetDoubleFromObj\fR and must be within the
-range acceptable for a \fBfloat\fR; attempts to
-write non-real values (or values outside the range) into
-\fIvarName\fR will be rejected with Tcl errors.
-.VE 8.5
-.TP
-\fBTCL_LINK_WIDE_INT\fR
-The C variable is of type \fBTcl_WideInt\fR (which is an integer type
-at least 64-bits wide on all platforms that can support it.)
-Any value written into the Tcl variable must have a proper integer
-form acceptable to \fBTcl_GetWideIntFromObj\fR;  attempts to write
-non-integer values into \fIvarName\fR will be rejected with
-Tcl errors.
-.VS 8.5
-.TP
-\fBTCL_LINK_WIDE_UINT\fR
-The C variable is of type \fBTcl_WideUInt\fR (which is an unsigned
-integer type at least 64-bits wide on all platforms that can support
-it.)
-Any value written into the Tcl variable must have a proper unsigned
-integer form acceptable to \fBTcl_GetWideIntFromObj\fR (it will be
-cast to unsigned);
-.\" FIXME! Use bignums instead.
-attempts to write non-integer values into \fIvarName\fR will be
-rejected with Tcl errors.
-.VE 8.5
 .TP
 \fBTCL_LINK_BOOLEAN\fR
 The C variable is of type \fBint\fR.
-If its value is zero then it will read from Tcl as
-.QW 0 ;
-otherwise it will read from Tcl as
-.QW 1 .
+If its value is zero then it will read from Tcl as ``0'';
+otherwise it will read from Tcl as ``1''.
 Whenever \fIvarName\fR is
 modified, the C variable will be set to a 0 or 1 value.
 Any value written into the Tcl variable must have a proper boolean
-form acceptable to \fBTcl_GetBooleanFromObj\fR;  attempts to write
+form acceptable to \fBTcl_GetBoolean\fR;  attempts to write
 non-boolean values into \fIvarName\fR will be rejected with
 Tcl errors.
 .TP
 \fBTCL_LINK_STRING\fR
 The C variable is of type \fBchar *\fR.
-If its value is not NULL then it must be a pointer to a string
-allocated with \fBTcl_Alloc\fR or \fBckalloc\fR.
+.VS
+If its value is not null then it must be a pointer to a string
+allocated with \fBTcl_Alloc\fR.
+.VE
 Whenever the Tcl variable is modified the current C string will be
 freed and new memory will be allocated to hold a copy of the variable's
 new value.
-If the C variable contains a NULL pointer then the Tcl variable
-will read as
-.QW NULL .
+If the C variable contains a null pointer then the Tcl variable
+will read as ``NULL''.
 .PP
-If the \fBTCL_LINK_READ_ONLY\fR flag is present in \fItype\fR then the
+If the TCL_LINK_READ_ONLY flag is present in \fItype\fR then the
 variable will be read-only from Tcl, so that its value can only be
 changed by modifying the C variable.
 Attempts to write the variable from Tcl will be rejected with errors.
@@ -4,6 +4,8 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\" 
+'\" RCS: @(#) $Id: ListObj.3,v 1.4 2000/01/26 03:37:30 hobbs Exp $
+'\" 
 .so man.macros
 .TH Tcl_ListObj 3 8.0 Tcl "Tcl Library Procedures"
 .BS
@@ -36,7 +38,7 @@ int
 int
 \fBTcl_ListObjReplace\fR(\fIinterp, listPtr, first, count, objc, objv\fR)
 .SH ARGUMENTS
-.AS "Tcl_Obj *const" *elemListPtr in/out
+.AS Tcl_Interp "*CONST objv[]" out
 .AP Tcl_Interp *interp in
 If an error occurs while converting an object to be a list object,
 an error message is left in the interpreter's result object
@@ -71,11 +73,13 @@ will insert into a new list object,
 and \fBTcl_ListObjReplace\fR will insert into \fIlistPtr\fR.
 For \fBTcl_SetListObj\fR,
 the number of Tcl objects to insert into \fIobjPtr\fR.
-.AP "Tcl_Obj *const" objv[] in
+.VS
+.AP Tcl_Obj	"*CONST\ objv[]" in
 An array of pointers to objects.
 \fBTcl_NewListObj\fR will insert these objects into a new list object
 and \fBTcl_ListObjReplace\fR will insert them into an existing \fIlistPtr\fR.
 Each object will become a separate list element.  
+.VE
 .AP int *intPtr out
 Points to location where \fBTcl_ListObjLength\fR
 stores the length of the list.
@@ -149,9 +153,8 @@ has reference count zero.
 the elements in a list object.  It returns the count by storing it in the
 address \fIobjcPtr\fR.  Similarly, it returns the array pointer by storing
 it in the address \fIobjvPtr\fR.
-The memory pointed to is managed by Tcl and should not be freed or written
-to by the caller. If the list is empty, 0 is stored at \fIobjcPtr\fR
-and NULL at \fIobjvPtr\fR.
+The memory pointed to is managed by Tcl and should not be freed by the
+caller.
 If \fIlistPtr\fR is not already a list object, \fBTcl_ListObjGetElements\fR
 will attempt to convert it to one; if the conversion fails, it returns
 \fBTCL_ERROR\fR and leaves an error message in the interpreter's result
@@ -218,33 +221,27 @@ it can be used to implement a number of list operations.
 For example, the following code inserts the \fIobjc\fR objects
 referenced by the array of object pointers \fIobjv\fR
 just before the element \fIindex\fR of the list referenced by \fIlistPtr\fR:
-.PP
 .CS
-result = Tcl_ListObjReplace(interp, listPtr, index, 0,
-        objc, objv);
+result = Tcl_ListObjReplace(interp, listPtr, index, 0, objc, objv);
 .CE
-.PP
 Similarly, the following code appends the \fIobjc\fR objects
 referenced by the array \fIobjv\fR
 to the end of the list \fIlistPtr\fR:
-.PP
 .CS
 result = Tcl_ListObjLength(interp, listPtr, &length);
 if (result == TCL_OK) {
-    result = Tcl_ListObjReplace(interp, listPtr, length, 0,
-            objc, objv);
+	result = Tcl_ListObjReplace(interp, listPtr, length, 0, objc, objv);
 }
 .CE
-.PP
 The \fIcount\fR list elements starting at \fIfirst\fR can be deleted
 by simply calling \fBTcl_ListObjReplace\fR
 with a NULL \fIobjvPtr\fR:
-.PP
 .CS
-result = Tcl_ListObjReplace(interp, listPtr, first, count,
-        0, NULL);
+result = Tcl_ListObjReplace(interp, listPtr, first, count, 0, NULL);
 .CE
+
 .SH "SEE ALSO"
 Tcl_NewObj, Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_GetObjResult
+
 .SH KEYWORDS
 append, index, insert, internal representation, length, list, list object, list type, object, object type, replace, string representation
@@ -0,0 +1,111 @@
+'\"
+'\" Copyright (c) 1997-1998 Sun Microsystems, Inc.
+'\"
+'\" See the file "license.terms" for information on usage and redistribution
+'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+'\" 
+'\" RCS: @(#) $Id: Macintosh.3,v 1.3 2001/05/03 23:57:10 hobbs Exp $
+'\" 
+.so man.macros
+.TH Tcl_MacSetEventProc 3 "8.1" Tcl "Tcl Library Procedures"
+.BS
+.SH NAME
+Tcl_MacSetEventProc, Tcl_MacConvertTextResource, Tcl_MacEvalResource, Tcl_MacFindResource, Tcl_GetOSTypeFromObj, Tcl_SetOSTypeObj, Tcl_NewOSTypeObj \- procedures to handle Macintosh resources and other Macintosh specifics
+.SH SYNOPSIS
+.nf
+\fB#include <tcl.h>\fR
+.sp
+int
+\fBTcl_MacEvalResource\fR(\fIinterp, resourceName, resourceNumber, fileName\fR)
+.sp
+char*
+\fBTcl_MacConvertTextResource\fR(\fIresource\fR)
+.sp
+Handle
+\fBTcl_MacFindResource\fR(\fIinterp, resourceType, resourceName, resourceNumber, resFileRef, releaseIt\fR)
+.sp
+Tcl_Obj*
+\fBTcl_NewOSTypeObj\fR(\fInewOSType\fR)
+.sp
+void
+\fBTcl_SetOSTypeObj\fR(\fIobjPtr, newOSType\fR)
+.sp
+int
+\fBTcl_GetOSTypeFromObj\fR(\fIinterp, objPtr, osTypePtr\fR)
+.sp
+void
+\fBTcl_MacSetEventProc\fR(\fIprocPtr\fR)
+.SH ARGUMENTS
+.AP Tcl_Interp *interp in
+Interpreter to use for error reporting, or NULL if no error reporting is
+desired.
+.AP char *resourceName in
+Name of TEXT resource to source, NULL if number should be used.
+.AP int resourceNumber in
+Resource id of source.
+.AP char *fileName in
+Name of file to process. NULL if application resource.
+.AP Handle resource in
+Handle to TEXT resource.
+.AP long resourceType in
+Type of resource to load.
+.AP char *resFileRef in
+Registered resource file reference, NULL if searching all open resource files.
+.AP int *releaseIt out
+Should we release this resource when done.
+.AP int newOSType in
+Int used to initialize the new object or set the object's value.
+.AP Tcl_Obj *objPtr in
+Object whose internal representation is to be set or retrieved.
+.AP osTypePtr out
+Place to store the resulting integer.
+.AP Tcl_MacConvertEventPtr procPtr in
+Reference to the new function to handle all incoming Mac events.
+
+.BE
+.SH INTRODUCTION
+.PP
+The described routines are used to implement the Macintosh specific
+\fBresource\fR command and the Mac specific notifier.. They manipulate
+or use Macintosh resources and provide administration for open
+resource file references.
+
+.SH DESCRIPTION
+.PP
+\fBTcl_MacEvalResource\fR extends the \fBsource\fR command to
+Macintosh resources.  It sources Tcl code from a Text resource.
+Currently only sources the resource by name, file IDs may be supported
+at a later date.
+.PP
+\fBTcl_MacConvertTextResource\fR converts a TEXT resource into a Tcl
+suitable string. It mallocs the returned memory, converts ``\\r'' to
+``\\n'', and appends a NULL. The caller has the responsibility for
+freeing the memory.
+.PP
+\fBTcl_MacFindResource\fR provides a higher level interface for
+loading resources. It is used by \fBresource read\fR.
+.PP
+\fBTcl_NewOSTypeObj\fR is used to create a new resource name type
+object. The object type is "ostype".
+.PP
+\fBTcl_SetOSTypeObj\fR modifies an object to be a resource type and to
+have the specified long value.
+.PP
+\fBTcl_GetOSTypeFromObj\fR attempts to return an int from the Tcl
+object "objPtr". If the object is not already an int, an attempt will
+be made to convert it to one.
+.PP
+\fBTcl_MacSetEventProc\fR sets the event handling procedure for the
+application. This function will be passed all incoming Mac events.
+This function usually controls the console or some other entity like
+Tk.
+
+.SH RESOURCE TYPES
+.PP
+Resource types are 4-byte values used by the macintosh resource
+facility to tag parts of the resource fork in a file so that the OS
+knows how to handle them. As all 4 bytes are restricted to printable
+characters such a type can be interpreted as a 4 character string too.
+
+.SH KEYWORDS
+macintosh, mac, resource, notifier
@@ -1,165 +0,0 @@
-'\"
-'\" Copyright (c) 2003 Donal K. Fellows
-'\"
-'\" See the file "license.terms" for information on usage and redistribution
-'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-'\" 
-'\" Note that some of these functions do not seem to belong, but they
-'\" were all introduced with the same TIP (#139)
-'\" 
-.so man.macros
-.TH Tcl_Namespace 3 8.5 Tcl "Tcl Library Procedures"
-.BS
-.SH NAME
-Tcl_AppendExportList, Tcl_CreateNamespace, Tcl_DeleteNamespace, Tcl_Export, Tcl_FindCommand, Tcl_FindNamespace, Tcl_ForgetImport, Tcl_GetCurrentNamespace, Tcl_GetGlobalNamespace, Tcl_GetNamespaceUnknownHandler, Tcl_Import, Tcl_SetNamespaceUnknownHandler \- manipulate namespaces
-.SH SYNOPSIS
-.nf
-\fB#include <tcl.h>\fR
-.sp
-Tcl_Namespace *
-\fBTcl_CreateNamespace\fR(\fIinterp, name, clientData, deleteProc\fR)
-.sp
-\fBTcl_DeleteNamespace\fR(\fInsPtr\fR)
-.sp
-int
-\fBTcl_AppendExportList\fR(\fIinterp, nsPtr, objPtr\fR)
-.sp
-int
-\fBTcl_Export\fR(\fIinterp, nsPtr, pattern, resetListFirst\fR)
-.sp
-int
-\fBTcl_Import\fR(\fIinterp, nsPtr, pattern, allowOverwrite\fR)
-.sp
-int
-\fBTcl_ForgetImport\fR(\fIinterp, nsPtr, pattern\fR)
-.sp
-Tcl_Namespace *
-\fBTcl_GetCurrentNamespace\fR(\fIinterp\fR)
-.sp
-Tcl_Namespace *
-\fBTcl_GetGlobalNamespace\fR(\fIinterp\fR)
-.sp
-Tcl_Namespace *
-\fBTcl_FindNamespace\fR(\fIinterp, name, contextNsPtr, flags\fR)
-.sp
-Tcl_Command
-\fBTcl_FindCommand\fR(\fIinterp, name, contextNsPtr, flags\fR)
-.sp
-Tcl_Obj *
-\fBTcl_GetNamespaceUnknownHandler(\fIinterp, nsPtr\fR)
-.sp
-int
-\fBTcl_SetNamespaceUnknownHandler(\fIinterp, nsPtr, handlerPtr\fR)
-.SH ARGUMENTS
-.AS Tcl_NamespaceDeleteProc allowOverwrite in/out
-.AP Tcl_Interp *interp in/out
-The interpreter in which the namespace exists and where name lookups
-are performed. Also where error result messages are written.
-.AP "const char" *name in
-The name of the namespace or command to be created or accessed.
-.AP ClientData clientData in
-A context pointer by the creator of the namespace.  Not interpreted by
-Tcl at all.
-.AP Tcl_NamespaceDeleteProc *deleteProc in
-A pointer to function to call when the namespace is deleted, or NULL
-if no such callback is to be performed.
-.AP Tcl_Namespace *nsPtr in
-The namespace to be manipulated, or NULL (for other than
-\fBTcl_DeleteNamespace\fR) to manipulate the current namespace.
-.AP Tcl_Obj *objPtr out
-A reference to an unshared object to which the function output will be
-written.
-.AP "const char" *pattern in
-The glob-style pattern (see \fBTcl_StringMatch\fR) that describes the
-commands to be imported or exported.
-.AP int resetListFirst in
-Whether the list of export patterns should be reset before adding the
-current pattern to it.
-.AP int allowOverwrite in
-Whether new commands created by this import action can overwrite
-existing commands.
-.AP Tcl_Namespace *contextNsPtr in
-The location in the namespace hierarchy where the search for a
-namespace or command should be conducted relative to when the search
-term is not rooted at the global namespace.  NULL indicates the
-current namespace.
-.AP int flags in
-OR-ed combination of bits controlling how the search is to be
-performed.  The following flags are supported: \fBTCL_GLOBAL_ONLY\fR
-(indicates that the search is always to be conducted relative to the
-global namespace), \fBTCL_NAMESPACE_ONLY\fR (just for \fBTcl_FindCommand\fR;
-indicates that the search is always to be conducted relative to the
-context namespace), and \fBTCL_LEAVE_ERR_MSG\fR (indicates that an error
-message should be left in the interpreter if the search fails.)
-.AP Tcl_Obj *handlerPtr in
-A script fragment to be installed as the unknown command handler for the
-namespace, or NULL to reset the handler to its default.
-.BE
-
-.SH DESCRIPTION
-.PP
-Namespaces are hierarchic naming contexts that can contain commands
-and variables.  They also maintain a list of patterns that describes
-what commands are exported, and can import commands that have been
-exported by other namespaces.  Namespaces can also be manipulated
-through the Tcl command \fBnamespace\fR.
-.PP
-The \fITcl_Namespace\fR structure encapsulates a namespace, and is
-guaranteed to have the following fields in it: \fIname\fR (the local
-name of the namespace, with no namespace separator characters in it,
-with empty denoting the global namespace), \fIfullName\fR (the fully
-specified name of the namespace), \fIclientData\fR, \fIdeleteProc\fR
-(the values specified in the call to \fBTcl_CreateNamespace\fR), and
-\fIparentPtr\fR (a pointer to the containing namespace, or NULL for
-the global namespace.)
-.PP
-\fBTcl_CreateNamespace\fR creates a new namespace.  The
-\fIdeleteProc\fR will have the following type signature:
-.CS
-typedef void (Tcl_NamespaceDeleteProc) (ClientData clientData);
-.CE
-.PP
-\fBTcl_DeleteNamespace\fR deletes a namespace.
-.PP
-\fBTcl_AppendExportList\fR retrieves the export patterns for a
-namespace given namespace and appends them (as list items) to
-\fIobjPtr\fR.
-.PP
-\fBTcl_Export\fR sets and appends to the export patterns for a
-namespace.  Patterns are appended unless the \fIresetListFirst\fR flag
-is true.
-.PP
-\fBTcl_Import\fR imports commands matching a pattern into a
-namespace.  Note that the pattern must include the name of the
-namespace to import from.  This function returns an error if
-an attempt to import a command over an existing command is made,
-unless the \fIallowOverwrite\fR flag has been set.
-.PP
-\fBTcl_ForgetImport\fR removes imports matching a pattern.
-.PP
-\fBTcl_GetCurrentNamespace\fR returns the current namespace for an
-interpreter.
-.PP
-\fBTcl_GetGlobalNamespace\fR returns the global namespace for an
-interpreter.
-.PP
-\fBTcl_FindNamespace\fR searches for a namespace named \fIname\fR
-within the context of the namespace \fIcontextNsPtr\fR.  If the
-namespace cannot be found, NULL is returned.
-.PP
-\fBTcl_FindCommand\fR searches for a command named \fIname\fR within
-the context of the namespace \fIcontextNsPtr\fR.  If the command
-cannot be found, NULL is returned.
-.PP
-\fBTcl_GetNamespaceUnknownHandler\fR returns the unknown command handler
-for the namespace, or NULL if none is set.
-.PP
-\fBTcl_SetNamespaceUnknownHandler\fR sets the unknown command handler for
-the namespace. If \fIhandlerPtr\fR is NULL, then the handler is reset to
-its default.
-
-.SH "SEE ALSO"
-Tcl_CreateCommand, Tcl_ListObjAppendElements, Tcl_SetVar
-
-.SH KEYWORDS
-namespace, command
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
das	405d6b342f	2002-04-05 Daniel Steffen <das@users.sourceforge.net> * mac/tclMacPkgConfig.c: Added Mac implementation of pkgconfig. * tests/config.test: fixed failing tests.	2002-04-05 13:49:45 +00:00
andreas_kupries	f1cf71eddc	Changed paths from prefix_exec_prefix to the individual locations for binaries, libraries, scripts, documentation, include files, for both install and runtime.	2002-02-19 22:01:17 +00:00
davygrvy	2d8b722d23	A small issue with already existing namespaces caused a panic instead of an ignore.	2002-02-06 12:21:43 +00:00
davygrvy	751eb00371	One large bug fixed with neglecting to disable otimizations for a symbols build.	2002-02-06 12:20:26 +00:00
andreas_kupries	cb4c129e3d	* tests/config.test: Added a testsuite for pkgconfig.	2002-02-05 23:58:02 +00:00
davygrvy	635fc6d90c	minor changes to support TIP#59	2002-02-05 23:05:17 +00:00
andreas_kupries	57cc1e85b2	* unix/mkLinks: Regenerated. * doc/RegConfig.3: Added documentation for the new public API function.	2002-02-05 22:15:22 +00:00
andreas_kupries	f1630f8668	* This commit addresses the following topics from the comments at SF item 507083: @ Reformatted to 72 columns per line (mostly). Some character strings (Panic messages) are still longer. @ Better panic messages. @ Allocation of wrapper uses sizeof(Tcl_Obj) instead of sizeof (char). @ Terminate array with either "" or NULL. @ Changed to use ckalloc/ckfree instead of Tcl_Alloc/Tcl_Free.	2002-02-05 20:45:51 +00:00
andreas_kupries	a3ed3589e6	First implementation of TIP #59 for Unix and Windows platforms. Made into a branch to allow me and platform specific maintainers to work on this in a coordinated way.	2002-01-25 01:47:01 +00:00