(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.
.PP
If \fIpath\fR exists, \fBTcl_Stat\fR returns 0 and the stat structure is
filled with data. Otherwise, -1 is returned, and no stat info is given.
.SH KEYWORDS
stat, access
.SH CATEGORY
Operating System Interface
.SH "SEE ALSO"
Tcl_FSAccess(3), Tcl_FSStat(3)

so they continue to hold a record of information about the
most recent error seen in an interpreter.
.SH "SEE ALSO"
Tcl_DecrRefCount(3), Tcl_IncrRefCount(3), Tcl_Interp(3), Tcl_ResetResult(3),
Tcl_SetErrno(3), tclvars(n)
.SH KEYWORDS
error, value, value result, stack, trace, variable

.SH CATEGORY
Commands

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.

.SH KEYWORDS
alloc, allocation, free, malloc, memory, realloc, TCL_MEM_DEBUG

.SH CATEGORY
Utilities

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.

.SH KEYWORDS
continue, break, exception, interpreter

.SH CATEGORY
Invoking the Interpreter

\fBTcl_AppInit\fR that you can modify for your application.

.SH "SEE ALSO"
Tcl_Main(3)

.SH KEYWORDS
application, argument, command, initialization, interpreter

.SH CATEGORY
Initialization

specified key exists in the given interpreter \fBTcl_GetAssocData\fR
returns \fBNULL\fR.
.PP
\fBTcl_DeleteAssocData\fR deletes an association with a specified key in
the given interpreter.  Then it calls the deletion procedure.
.SH KEYWORDS
association, data, deletion procedure, interpreter, key

.SH CATEGORY
Utilities

\fBTcl_SaveInterpState\fR, passing in the \fIcode\fR argument.
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.

.SH KEYWORDS
asynchronous event, handler, signal, Tcl_SaveInterpState, thread

.SH CATEGORY
The Event Loop

.PP
.CS
Tcl_BackgroundException(interp, TCL_ERROR);
.CE

.SH KEYWORDS
background, bgerror, error, interp

.SH CATEGORY
Commands

All of the sequences described in the Tcl manual entry are supported by
\fBTcl_Backslash\fR.
.SH "SEE ALSO"
Tcl(n), Tcl_UtfBackslash(3)

.SH KEYWORDS
backslash, parse

.SH CATEGORY
Invoking the Interpreter

a \fBTCL_ERROR\fR return.

.SH "SEE ALSO"
Tcl_NewObj, Tcl_IsShared, Tcl_GetBoolean

.SH KEYWORDS
boolean, value

.SH CATEGORY
Objects

pointer to the value's new array of bytes.  

.SH "SEE ALSO"
Tcl_GetStringFromObj, Tcl_NewObj, Tcl_IncrRefCount, Tcl_DecrRefCount

.SH KEYWORDS
value, binary data, byte array, utf, unicode, internationalization

.SH CATEGORY
Objects

Note that if the callback is being used to delete a resource that \fImust\fR
be released on exit, \fBTcl_CreateExitHandler\fR should be used to ensure that
a callback is received even if the application terminates without deleting the interpreter.
.SH "SEE ALSO"
Tcl_CreateExitHandler(3), Tcl_CreateThreadExitHandler(3)
.SH KEYWORDS
callback, cleanup, delete, interpreter

.SH CATEGORY
Initialization

result, where it can be retrieved with \fBTcl_GetObjResult\fR or
\fBTcl_GetStringResult\fR.  If this flag bit is not set then no error
message is left and the interpreter's result will not be modified.
.SH "SEE ALSO"
TIP 285
.SH KEYWORDS
cancel, unwind

.SH CATEGORY
The Event Loop

channels which is just below the supplied channel.

.SH "SEE ALSO"
Notifier(3), Tcl_CreateChannel(3), Tcl_OpenFileChannel(3), vwait(n).

.SH KEYWORDS
channel, compression

.SH CATEGORY
Input/Output

NULL); this variable may be updated by the callback. The \fImethodNameObj\fR
parameter gives an unshared object containing the name of the method being
invoked, as provided by the user; this object may be updated by the callback.
.SH "SEE ALSO"
Method(3), oo::class(n), oo::copy(n), oo::define(n), oo::object(n)
.SH KEYWORDS
class, constructor, object
.SH CATEGORY
Object Orientation
.\" Local variables:
.\" mode: nroff
.\" fill-column: 78
.\" End:

as argument and determines whether it contains one or more
complete commands (i.e. there are no unclosed quotes, braces,
brackets, or variable references).
If the command string is complete then it returns 1; otherwise it returns 0.

.SH KEYWORDS
complete command, partial command

.SH CATEGORY
Invoking the Interpreter

The result string is dynamically allocated
using \fBTcl_Alloc\fR;  the caller must eventually release the space
by calling \fBTcl_Free\fR.
.SH "SEE ALSO"
Tcl_ConcatObj
.SH KEYWORDS
concatenate, strings

.SH CATEGORY
Utilities

.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)
.SH KEYWORDS
blocking, channel driver, channel registration, channel type, nonblocking

.SH CATEGORY
Input/Output

is invoked.
For this reason it may be useful to use nonblocking I/O on channels
for which there are event handlers.
.SH "SEE ALSO"
Notifier(3), Tcl_CreateChannel(3), Tcl_OpenFileChannel(3), vwait(n).
.SH KEYWORDS
blocking, callback, channel, events, handler, nonblocking.

.SH CATEGORY
Input/Output

remove; \fBTcl_DeleteCloseHandler\fR does nothing if its \fIproc\fR and
\fIclientData\fR arguments do not match the \fIproc\fR and \fIclientData\fR
for a  close handler for \fIchannel\fR.
.SH "SEE ALSO"
close(n), Tcl_Close(3), Tcl_UnregisterChannel(3)
.SH KEYWORDS
callback, channel closing

.SH CATEGORY
Input/Output

The \fIclientData\fR argument will be the same as the \fIclientData\fR
argument passed to \fBTcl_CreateCommand\fR.
.SH "SEE ALSO"
Tcl_CreateObjCommand, Tcl_DeleteCommand, Tcl_GetCommandInfo,
Tcl_SetCommandInfo, Tcl_GetCommandName, Tcl_SetObjResult
.SH KEYWORDS
bind, command, create, delete, interpreter, namespace

.SH CATEGORY
Commands

.PP
Note that these interfaces are only supported by the Unix
implementation of the Tcl notifier.
.SH "SEE ALSO"
fileevent(n), Tcl_CreateTimerHandler(3), Tcl_DoWhenIdle(3)
.SH KEYWORDS
callback, file, handler

.SH CATEGORY
Input/Output

should be used to determine when an interpreter is a candidate for deletion
due to inactivity.
.VE 8.6
.SH "SEE ALSO"
Tcl_Preserve(3), Tcl_Release(3), tclvars(n)
.SH KEYWORDS
command, create, delete, interpreter

.SH CATEGORY
Initialization

\fBTcl_ListMathFuncs\fR returns a Tcl value containing a list of all
the math functions defined in the interpreter whose name matches
\fIpattern\fR.  The returned value has a reference count of zero.
.SH "SEE ALSO"
expr(n), info(n), Tcl_CreateObjCommand(3), Tcl_Free(3), Tcl_NewListObj(3)
.SH KEYWORDS
expression, mathematical function

.SH CATEGORY
Commands

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(3), Tcl_ResetResult(3), Tcl_SetObjResult(3)
.SH KEYWORDS
bind, command, create, delete, namespace, value

.SH CATEGORY
Commands

\fIinterp(n)\fR.
.SH "SEE ALSO"
interp

.SH KEYWORDS
alias, command, exposed commands, hidden commands, interpreter, invoke,
master, slave

.SH CATEGORY
Initialization

The tokens returned by \fBTcl_CreateTimerHandler\fR never have
a value of NULL, so if NULL is passed to \fBTcl_DeleteTimerHandler\fR
then the procedure does nothing.
.SH "SEE ALSO"
after(n), Tcl_CreateFileHandler(3), Tcl_DoWhenIdle(3)
.SH KEYWORDS
callback, clock, handler, timer

.SH CATEGORY
The Event Loop

\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

.SH CATEGORY
Variables

It sets the value of \fIdsPtr\fR to the result of \fIinterp\fR and
it clears \fIinterp\fR's result.
If possible it does this by moving a pointer rather than by copying
the string.

.SH KEYWORDS
append, dynamic string, free, result

.SH CATEGORY
Utilities

the operating system to wait on the end of a spawned process and to
check a whether spawned process is still running. It is used by
\fBTcl_ReapDetachedProcs\fR and the channel system to portably access
the operating system.

.SH KEYWORDS
background, child, detach, process, wait

.SH CATEGORY
Operating System Interface

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 value, dictionary, dictionary value, hash table, iteration, value

.SH CATEGORY
Objects

as when a
notification dialog has been popped up and an application wishes to
wait for the user to click a button in the dialog before
doing anything else.

.SH KEYWORDS
callback, event, handler, idle, timer

.SH CATEGORY
The Event Loop

that attempt to wait for all idle callbacks to complete.  If you would
like for an idle callback to reschedule itself continuously, it is
better to use a timer handler with a zero timeout period.
.SH "SEE ALSO"
after(n), Tcl_CreateFileHandler(3), Tcl_CreateTimerHandler(3)
.SH KEYWORDS
callback, defer, idle callback

.SH CATEGORY
The Event Loop

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
.SH "SEE ALSO"
Tcl_NewObj, Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_GetObjResult
.SH KEYWORDS
double, double value, double type, internal representation, value, value type, string representation

.SH CATEGORY
Objects

.SH "SEE ALSO"
TCL_MEM_DEBUG, memory

.SH KEYWORDS
memory, debug



.SH CATEGORY
Utilities

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
malformed, an error message will be left in \fIinterp\fR.
.SH KEYWORDS
utf, encoding, convert

.SH CATEGORY
Utilities

dictionary and the subcommand list properties are NULL. May be read
using \fBTcl_GetEnsembleNamespace\fR which returns a Tcl result code
(\fBTCL_OK\fR, or \fBTCL_ERROR\fR if the token does not refer to an ensemble).
.SH "SEE ALSO"
namespace(n), Tcl_DeleteCommandFromToken(3)
.SH KEYWORDS
command, ensemble

.SH CATEGORY
Commands

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

.SH CATEGORY
Operating System Interface

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.

.SH KEYWORDS
execute, file, global, result, script, value

.SH CATEGORY
Invoking the Interpreter

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.
.SH "SEE ALSO"
exit(n)
.SH KEYWORDS
abort, callback, cleanup, dynamic loading, end application, exit, unloading, thread

.SH CATEGORY
Initialization

string stored in the interpreter's result.

.SH "SEE ALSO"
Tcl_ExprLongObj, Tcl_ExprDoubleObj, Tcl_ExprBooleanObj, Tcl_ExprObj

.SH KEYWORDS
boolean, double, evaluate, expression, integer, value, string

.SH CATEGORY
Invoking the Interpreter

when it is finished with the value.

.SH "SEE ALSO"
Tcl_ExprLong, Tcl_ExprDouble, Tcl_ExprBoolean, Tcl_ExprString, Tcl_GetObjResult

.SH KEYWORDS
boolean, double, evaluate, expression, integer, value, string

.SH CATEGORY
Invoking the Interpreter

The \fBTcl_FSChdirProc\fR changes the applications current working
directory to the value specified in \fIpathPtr\fR. The function returns
-1 on error or 0 on success.
.SH "SEE ALSO"
cd(n), file(n), filename(n), load(n), open(n), pwd(n), source(n), unload(n)
.SH KEYWORDS
stat, access, filesystem, vfs, virtual filesystem

.SH CATEGORY
Operating System Interface

\fBTcl_FindExecutable\fR.  This procedure call is the C API
equivalent to the \fBinfo nameofexecutable\fR command.  NULL
is returned if the internal full path name has not been
computed or unknown.

.SH KEYWORDS
binary, executable file

.SH CATEGORY
Initialization

.PP
\fBTcl_Chdir\fR changes the applications current working directory to
the value specified in \fIpath\fR.  The format of the passed in string
must be UTF\-8.  The function returns -1 on error or 0 on success.

.SH KEYWORDS
pwd

.SH CATEGORY
Operating System Interface

Tcl commands.  It returns a pointer to a string containing the name 
for the current machine, or an empty string if the name cannot be
determined.  The string is statically allocated, and the caller must
not modify of free it.
.PP
.SH KEYWORDS
hostname

.SH CATEGORY
Operating System Interface

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.
.SH "SEE ALSO"
prefix(n), Tcl_WrongNumArgs(3)
.SH KEYWORDS
index, option, value, table lookup

.SH CATEGORY
Utilities

If \fIsrc\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.

.SH KEYWORDS
boolean, conversion, double, floating-point, integer

.SH CATEGORY
Utilities

In the current implementation \fIcheckUsage\fR is ignored and consistency
checks are always performed.
.PP
Note that this interface is only supported on the Unix platform.

.SH KEYWORDS
channel, file handle, permissions, pipeline, read, write

.SH CATEGORY
Input/Output

channels and the behavior of the Tcl library with regard to them.

.SH "SEE ALSO"
Tcl_Close(3), Tcl_CreateChannel(3), Tcl_Main(3), tclsh(1)

.SH KEYWORDS
standard channel, standard input, standard output, standard error

.SH CATEGORY
Input/Output

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 behavior of the Tcl core
with regard to this situation, i.e. the existing behavior is retained.
.SH "SEE ALSO"
clock(n)
.SH KEYWORDS
date, time

.SH CATEGORY
Operating System Interface

\fBTcl_GetVersion\fR accepts NULL for any of the arguments. For instance if 
you do not care about the \fIpatchLevel\fR of the library, pass
a NULL for the \fIpatchLevel\fR argument.

.SH KEYWORDS
version, patchlevel, major, minor, alpha, beta, release


.SH CATEGORY
Initialization

.CE
.PP
If this is NULL then \fBTcl_Free\fR is used to free the space for the entry.
Tcl_Obj* keys use this function to decrement the reference count on the
value.
.SH KEYWORDS
hash table, key, lookup, search, value

.SH CATEGORY
Utilities

\fBTcl_Init\fR is typically called from \fBTcl_AppInit\fR procedures.

.SH "SEE ALSO"
Tcl_AppInit, Tcl_Main

.SH KEYWORDS
application, initialization, interpreter

.SH CATEGORY
Initialization

\fBTcl_InitStubs\fR returns a string containing the actual version
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
.SH KEYWORDS
stubs

.SH CATEGORY
Initialization

that extracts the integer part of \fIdoubleValue\fR and stores that
integer value in the \fBmp_int\fR value \fIbigValue\fR.
.SH "SEE ALSO"
Tcl_NewObj, Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_GetObjResult
.SH KEYWORDS
integer, integer value, integer type, internal representation, value,
value type, string representation

.SH CATEGORY
Objects

The \fIerrorLine\fR field is typically used in conjunction with
\fBTcl_AddErrorInfo\fR to report information about where an error
occurred.
\fIErrorLine\fR should not normally be modified except by \fBTcl_Eval\fR.

.SH KEYWORDS
free, initialized, interpreter, malloc, result

.SH CATEGORY
Initialization

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

.SH CATEGORY
Invoking the Interpreter

variable in a separate thread, it is advised that \fBTcl_AsyncMark\fR be used
to indicate to the thread hosting the interpreter that it is ready to run
\fBTcl_UpdateLinkedVar\fR.
.SH "SEE ALSO"
Tcl_TraceVar(3)
.SH KEYWORDS
boolean, integer, link, read-only, real, string, trace, variable

.SH CATEGORY
Variables

        0, NULL);
.CE
.SH "SEE ALSO"
Tcl_NewObj(3), Tcl_DecrRefCount(3), Tcl_IncrRefCount(3), Tcl_GetObjResult(3)
.SH KEYWORDS
append, index, insert, internal representation, length, list, list value,
list type, value, value type, replace, string representation

.SH CATEGORY
Objects

the symbol cannot be found, it returns NULL and sets an error message in the
given \fIinterp\fR (if that is non-NULL). Note that it is unsafe to use this
operation on a handle that has been passed to \fBTcl_FSUnloadFile\fR.
.SH "SEE ALSO"
Tcl_FSLoadFile(3), Tcl_FSUnloadFile(3), load(n), unload(n)
.SH KEYWORDS
binary code, loading, shared library
.SH CATEGORY
Operating System Interface
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

method being copied from, and the \fInewClientDataPtr\fR field will point to
a variable in which to write the value for the method being copied to.
.SH "SEE ALSO"
Class(3), oo::class(n), oo::define(n), oo::object(n)
.SH KEYWORDS
constructor, method, object

.SH CATEGORY
Object Orientation
.\" Local variables:
.\" mode: nroff
.\" fill-column: 78
.\" End:

        \fITheCmdObjProc\fR, \fITheCmdNRObjProc\fR, clientData,
        TheCmdDeleteProc);
.CE
.SH "SEE ALSO"
Tcl_CreateCommand(3), Tcl_CreateObjCommand(3), Tcl_EvalObjEx(3), Tcl_GetCommandFromObj(3), Tcl_ExprObj(3)
.SH KEYWORDS
stackless, nonrecursive, execute, command, global, value, result, script
.SH CATEGORY
Invoking the Interpreter
.SH COPYRIGHT
Copyright (c) 2008 by Kevin B. Kenny

\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(3), Tcl_ListObjAppendList(3), Tcl_SetVar(3)
.SH KEYWORDS
namespace, command

.SH CATEGORY
Variables

\fBTcl_GetServiceMode\fR returns the current value of the service
mode.
.SH "SEE ALSO"
Tcl_CreateFileHandler(3), Tcl_DeleteFileHandler(3), Tcl_Sleep(3),
Tcl_DoOneEvent(3), Thread(3)
.SH KEYWORDS
event, notifier, event queue, event sources, file events, timer, idle, service mode, threads

.SH CATEGORY
The Event Loop

If it is shared, it needs to duplicate the value
in order to avoid accidentally changing values in other data structures.
.SH "SEE ALSO"
Tcl_ConvertToType(3), Tcl_GetIntFromObj(3), Tcl_ListObjAppendElement(3), Tcl_ListObjIndex(3), Tcl_ListObjReplace(3), Tcl_RegisterObjType(3)
.SH KEYWORDS
internal representation, value, value creation, value type,
reference counting, string representation, type conversion

.SH CATEGORY
Objects

uses of that field during value deletion.  The defined tasks for
the \fIfreeIntRepProc\fR have no need to consult the \fIbytes\fR
member.
.SH "SEE ALSO"
Tcl_NewObj(3), Tcl_DecrRefCount(3), Tcl_IncrRefCount(3)
.SH KEYWORDS
internal representation, value, value type, string representation, type conversion

.SH CATEGORY
Objects

channel types may return a different type of handle on Windows
platforms.
.SH "SEE ALSO"
DString(3), fconfigure(n), filename(n), fopen(3), Tcl_CreateChannel(3)
.SH KEYWORDS
access point, blocking, buffered I/O, channel, channel driver, end of file,
flush, input, nonblocking, output, read, seek, write

.SH CATEGORY
Input/Output

On Unix platforms, the socket handle is a Unix file descriptor as
returned by the \fBsocket\fR system call.  On the Windows platform, the
socket handle is a \fBSOCKET\fR as defined in the WinSock API.
.SH "SEE ALSO"
Tcl_OpenFileChannel(3), Tcl_RegisterChannel(3), vwait(n)
.SH KEYWORDS
channel, client, server, socket, TCP

.SH CATEGORY
Input/Output

.PP
\fBTcl_PanicVA\fR is the same as \fBTcl_Panic\fR except that instead of
taking a variable number of arguments it takes an argument list.
.SH "SEE ALSO"
abort(3), printf(3), exec(n), format(n)
.SH KEYWORDS
abort, fatal, error

.SH CATEGORY
Commands

to the lifetime of the string representation of the argument value that it
came from, and so should be copied if it needs to be retained. The
\fIsrcPtr\fR and \fIclientData\fR fields are ignored.
.SH "SEE ALSO"
Tcl_GetIndexFromObj(3), Tcl_Main(3), Tcl_CreateObjCommand(3)
.SH KEYWORDS
argument, parse
.SH CATEGORY
Utilities
'\" Local Variables:
'\" fill-column: 78
'\" End:

There are additional fields in the Tcl_Parse structure after the
\fInumTokens\fR field, but these are for the private use of
\fBTcl_ParseCommand\fR, \fBTcl_ParseExpr\fR, \fBTcl_ParseBraces\fR,
\fBTcl_ParseQuotedString\fR, and \fBTcl_ParseVarName\fR; they should not be
referenced by code outside of these procedures.
.SH KEYWORDS
backslash substitution, braces, command, expression, parse, token, variable substitution

.SH CATEGORY
Invoking the Interpreter

functions.
.PP
\fBTcl_PkgRequireProc\fR is the form of \fBpackage require\fR handling
multiple requirements. The other forms are present for backward
compatibility and translate their invocations to this form.
.SH KEYWORDS
package, present, provide, require, version
.SH CATEGORY
Initialization
.SH "SEE ALSO"
package(n), Tcl_StaticPackage(3)

The implementation does not depend in any way on the internal
structure of the objects being freed;  it keeps the reference
counts in a separate structure.
.SH "SEE ALSO"
Tcl_Interp, Tcl_Alloc
.SH KEYWORDS
free, reference count, storage

.SH CATEGORY
Utilities

precisely that many digits of significance.  If the value is zero
(the default), the result will have the fewest digits needed to
represent the number in such a way that \fBTcl_NewDoubleObj\fR
will generate the same number when presented with the given string.
IEEE semantics of rounding to even apply to the conversion.
.SH KEYWORDS
conversion, double-precision, floating-point, string

.SH CATEGORY
Utilities

the command is recorded without being evaluated.

.SH "SEE ALSO"
Tcl_EvalObjEx, Tcl_GetObjResult

.SH KEYWORDS
command, event, execute, history, interpreter, value, record

.SH CATEGORY
Invoking the Interpreter

a command held in a Tcl value instead of a string.

.SH "SEE ALSO"
Tcl_RecordAndEvalObj

.SH KEYWORDS
command, event, execute, history, interpreter, record

.SH CATEGORY
Invoking the Interpreter

    const char *\fIvalue\fR;
} \fBTcl_Config\fR;
.CE
.\" No cross references yet.
.\" .SH "SEE ALSO"
.SH KEYWORDS
embedding, configuration, binary library

.SH CATEGORY
Initialization

match might occur if additional text is appended to the string.  If it
is no match is possible even with further text, this field will be set 
to \-1.
.SH "SEE ALSO"
re_syntax(n)
.SH KEYWORDS
match, pattern, regular expression, string, subexpression, Tcl_RegExpIndices, Tcl_RegExpInfo

.SH CATEGORY
Utilities

.PP
Once \fBTcl_SaveResult\fR is called to save the interpreter
result, either \fBTcl_RestoreResult\fR or
\fBTcl_DiscardResult\fR must be called to properly clean up the
memory associated with the saved state.  
.SH KEYWORDS
result, state, interp

.SH CATEGORY
Commands

.ta 1.9i 4i
\fBTcl_Close\fR	\fBTcl_UnstackChannel\fR	\fBTcl_UnregisterChannel\fR
.DE
.SH "SEE ALSO"
Tcl_Close(3), Tcl_OpenFileChannel(3), Tcl_SetErrno(3)
.SH KEYWORDS
channel driver, error messages, channel type

.SH CATEGORY
Input/Output

\fIerrorCode\fR argument.  The \fIerrorCode\fR argument is
typically the value returned by \fBTcl_GetErrno\fR.
The strings returned by these functions are
statically allocated and the caller must not free or modify them.

.SH KEYWORDS
errno, error code, global variables

.SH CATEGORY
Commands

limit on the size of the C stack, you may get stack overflows
before reaching the limit set by \fBTcl_SetRecursionLimit\fR.
If this happens, see if there is a mechanism in your system for
increasing the maximum size of the C stack.

.SH KEYWORDS
nesting depth, recursion

.SH CATEGORY
Invoking the Interpreter

.PP
When \fIfreeProc\fR is called, its \fIblockPtr\fR will be set to
the value of \fIresult\fR passed to \fBTcl_SetResult\fR.
.SH "SEE ALSO"
Tcl_AddErrorInfo, Tcl_CreateObjCommand, Tcl_SetErrorCode, Tcl_Interp
.SH KEYWORDS
append, command, element, list, value, result, return value, interpreter

.SH CATEGORY
Commands

array is removed.

.SH "SEE ALSO"
Tcl_GetObjResult, Tcl_GetStringResult, Tcl_TraceVar

.SH KEYWORDS
array, get variable, interpreter, scalar, set, unset, value, variable

.SH CATEGORY
Variables

\fBTcl_SignalMsg\fR returns a human-readable string such as
.QW "bus error" .
The strings returned by these functions are
statically allocated and the caller must not free or modify them.

.SH KEYWORDS
signals, signal numbers

.SH CATEGORY
Operating System Interface

like flashing a button, where the delay is short and the
application need not do anything while it waits.  For longer
delays where the application needs to respond to other events
during the delay, the procedure \fBTcl_CreateTimerHandler\fR
should be used instead of \fBTcl_Sleep\fR.
.SH KEYWORDS
sleep, time, wait

.SH CATEGORY
The Event Loop

sourced is obtained from the global variable \fBtcl_rcFileName\fR in
the interpreter given by \fIinterp\fR.  If this variable is not
defined, or if the file it indicates cannot be found, no action is
taken.

.SH KEYWORDS
application-specific initialization, main program, rc file

.SH CATEGORY
Initialization

the same as \fBTcl_ScanElement\fR and \fBTcl_ConvertElement\fR, except
the length of string \fIsrc\fR is specified by the \fIlength\fR
argument, and the string may contain embedded nulls.
.SH "SEE ALSO"
Tcl_ListObjGetElements(3)
.SH KEYWORDS
backslash, convert, element, list, merge, split, strings

.SH CATEGORY
Utilities

where \fBTcl_PathType\fR is one of \fBTCL_PATH_ABSOLUTE\fR,
\fBTCL_PATH_RELATIVE\fR, or \fBTCL_PATH_VOLUME_RELATIVE\fR.  See the
\fBfilename\fR manual entry for a description of the path types for
each platform.

.SH KEYWORDS
file, filename, join, path, split, type

.SH CATEGORY
Utilities

\fBTCL_ERROR\fR to indicate whether or not it completed successfully; in
the event of an error it should set the interpreter's result to point to an
error message.  The result or error from the initialization procedure will
be returned as the result of the \fBload\fR command that caused the
initialization procedure to be invoked.
.SH KEYWORDS
initialization procedure, package, static linking
.SH CATEGORY
Initialization
.SH "SEE ALSO"
load(n), package(n), Tcl_PkgRequire(3)

initialize the standard channels (See \fBTk_InitConsoleChannels\fR)
on non-Unix platforms.  On Unix platforms, \fBTk_MainEx\fR implicitly
uses method 2 to initialize the standard channels.
.SH "SEE ALSO"
Tcl_CreateChannel(3), Tcl_RegisterChannel(3), Tcl_GetChannel(3), Tcl_GetStdChannel(3), Tcl_SetStdChannel(3), Tk_InitConsoleChannels(3), tclsh(1), wish(1), Tcl_Main(3), Tk_MainEx(3)
.SH KEYWORDS
standard channels

.SH CATEGORY
Input/Output

In \fBTcl_StringCaseMatch\fR, the algorithm is
the same, but you have the option to make the matching case-insensitive.
If you choose this (by passing \fBTCL_MATCH_NOCASE\fR), then the string and
pattern are essentially matched in the lower case.

.SH KEYWORDS
match, pattern, string

.SH CATEGORY
Utilities

cleaner-looking. \fBTcl_ConcatObj\fR returns a pointer to a
newly-created value whose ref count is zero.
.SH "SEE ALSO"
Tcl_NewObj(3), Tcl_IncrRefCount(3), Tcl_DecrRefCount(3), format(n), sprintf(3)
.SH KEYWORDS
append, internal representation, value, value type, string value,
string type, string representation, concat, concatenate, unicode

.SH CATEGORY
Objects

the point immediately before the start of the command substitution,
and no characters will be added to the result or substitutions
performed after that point.
.SH "SEE ALSO"
subst(n)
.SH KEYWORDS
backslash substitution, command substitution, variable substitution

.SH CATEGORY
Invoking the Interpreter

*\fR and an \fIint\fR which are normally the filename and line number
of the caller, but they can actually be anything you want.  Remember
to remove the calls after you find the problem.
.SH "SEE ALSO"
ckalloc, memory, Tcl_ValidateAllMemory, Tcl_DumpActiveMemory
.SH KEYWORDS
memory, debug

.SH CATEGORY
Utilities

Substitutions do not affect the word boundaries of a command,
except for argument expansion as specified in rule [5].
For example, during variable substitution the entire value of
the variable becomes part of a single word, even if the variable's
value contains spaces.
.SH KEYWORDS
backslash, command, comment, script, substitution, variable
.SH CATEGORY
General
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

These functions will fail gracefully if Tcl is not linked with the zlib
library.
.SH "SEE ALSO"
Tcl_NewByteArrayObj(3), zlib(n)
'\"Tcl_StackChannel(3)
.SH "KEYWORDS"
compress, decompress, deflate, gzip, inflate
.SH CATEGORY
Input/Output
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

procedure (if any) returns, \fBTcl_Main\fR will also evaluate
the \fBexit\fR command.
.SH "SEE ALSO"
tclsh(1), Tcl_GetStdChannel(3), Tcl_StandardChannels(3), Tcl_AppInit(3),
exit(n), encoding(n)
.SH KEYWORDS
application-specific initialization, command-line arguments, main program

.SH CATEGORY
Initialization

.CE
.SH "SEE ALSO"
Tcl_GetCurrentThread(3), Tcl_ThreadQueueEvent(3), Tcl_ThreadAlert(3),
Tcl_ExitThread(3), Tcl_FinalizeThread(3), Tcl_CreateThreadExitHandler(3),
Tcl_DeleteThreadExitHandler(3), Thread
.SH KEYWORDS
thread, mutex, condition variable, thread local storage

.SH CATEGORY
The Event Loop

.PP
At this time, the case conversions are only defined for the ISO8859-1
characters.  Unicode characters above 0x00ff are not modified by these
routines.

.SH KEYWORDS
utf, unicode, toupper, tolower, totitle, case

.SH CATEGORY
Utilities

.SH BUGS
.PP
Tcl does not do any error checking to prevent trace procedures
from misusing the interpreter during traces with \fBTCL_INTERP_DESTROYED\fR
set.
.SH KEYWORDS
clientData, trace, command

.SH CATEGORY
Variables

.PP
Array traces are not yet integrated with the Tcl \fBinfo exists\fR command,
nor is there Tcl-level access to array traces.
.SH "SEE ALSO"
trace(n)
.SH KEYWORDS
clientData, trace, variable

.SH CATEGORY
Variables

.PP
The caller is responsible for making sure that the interpreter's result
has its default empty value when \fBTcl_TranslateFileName\fR is invoked.
.SH "SEE ALSO"
filename(n)
.SH KEYWORDS
file name, home directory, tilde, translate, user

.SH CATEGORY
Operating System Interface

\fBTcl_UniCharIsUpper\fR tests if the character is an uppercase Unicode character.
.PP
\fBTcl_UniCharIsWordChar\fR tests if the character is alphanumeric or
a connector punctuation mark.

.SH KEYWORDS
unicode, classification

.SH CATEGORY
Utilities

As with the \fBupvar\fR command, the source variable need not exist;
if it does exist, unsetting it later does not destroy the link.  The
destination variable may exist at the time of the call, but if so
it must exist as a linked variable.

.SH KEYWORDS
linked variable, upvar, variable

.SH CATEGORY
Variables

.PP
See the \fBTcl\fR manual entry for information on the valid backslash
sequences.  All of the sequences described in the Tcl manual entry are
supported by \fBTcl_UtfBackslash\fR.

.SH KEYWORDS
utf, unicode, backslash

.SH CATEGORY
Utilities

.CS
wrong # args: should be "foo barfly fileName count"
.CE
.SH "SEE ALSO"
Tcl_GetIndexFromObj(3)
.SH KEYWORDS
command, error message, wrong number of arguments

.SH CATEGORY
Utilities

}
doOneStep
.CE
.SH "SEE ALSO"
concat(n), interp(n), update(n), vwait(n)
.SH KEYWORDS
cancel, delay, idle callback, sleep, time
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

puts $var
# Prints 0,1,2,3,4,5,6,7,8,9,10
.CE
.SH "SEE ALSO"
concat(n), lappend(n)
.SH KEYWORDS
append, variable
.SH CATEGORY
Tcl String Handling
'\" Local Variables:
'\" mode: nroff
'\" End:
'\" End:

set vbl 123
set vbl abc
.CE
.SH "SEE ALSO"
proc(n), uplevel(n)
.SH KEYWORDS
anonymous function, argument, lambda, procedure, 
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

    number of buckets with 10 or more entries: 0
    average search distance for entry: 1.2
.CE
.SH "SEE ALSO"
list(n), string(n), variable(n), trace(n), foreach(n)
.SH KEYWORDS
array, element names, search

.SH CATEGORY
Tcl Variables and Procedures

    close $fl
}
.CE
.SH "SEE ALSO"
after(n), interp(n), tclvars(n)
.SH KEYWORDS
background error, reporting

.SH CATEGORY
Tcl Interpreter Routines

close $f
puts [\fBbinary encode\fR base64 \-maxlen 64 $data]
.CE
.SH "SEE ALSO"
format(n), scan(n), tclvars(n)
.SH KEYWORDS
binary, format, scan
.SH CATEGORY
Tcl String Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

    puts "x is $x"
}
.CE
.SH "SEE ALSO"
catch(n), continue(n), for(n), foreach(n), return(n), while(n)
.SH KEYWORDS
abort, break, loop
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

cases.

.SH "SEE ALSO"
switch(n)

.SH KEYWORDS
case, match, regular expression

.SH CATEGORY
Tcl Control Constructs

.PP
There are more complex examples of \fBcatch\fR usage in the
documentation for the \fBreturn\fR command.
.SH "SEE ALSO" 
break(n), continue(n), dict(n), error(n), info(n), return(n), tclvars(n)
.SH KEYWORDS
catch, error, exception
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

.CS
\fBcd\fR ../lib
.CE
.SH "SEE ALSO"
filename(n), glob(n), pwd(n)
.SH KEYWORDS
working directory

.SH CATEGORY
Tcl System Related

.CE
.SH "SEE ALSO"
close(n), eof(n), fblocked(n), fconfigure(n), fcopy(n), file(n),
fileevent(n), flush(n), gets(n), open(n), puts(n), read(n), seek(n),
socket(n), tell(n), refchan(n), transchan(n)
.SH KEYWORDS
channel, input, output, events, offset
.SH CATEGORY
Tcl Input/Output
'\" Local Variables:
'\" mode: nroff
'\" End:

fruit destroy
$b eat               \fI\(-> error "unknown command"\fR
.CE
.SH "SEE ALSO"
oo::define(n), oo::object(n)
.SH KEYWORDS
class, metaclass, object
.SH CATEGORY
Tcl Object Orientation
.\" Local variables:
.\" mode: nroff
.\" fill-column: 78
.\" End:

the day is produced after allowing for daylight savings time
differences and the correct date is given when going from the end
of a long month to a short month.
.SH "SEE ALSO"
msgcat(n)
.SH KEYWORDS
clock, date, time
.SH CATEGORY
Tcl System Related
.SH "COPYRIGHT"
Copyright (c) 2004 Kevin B. Kenny <kennykb@acm.org>. All rights reserved.
'\" Local Variables:
'\" mode: nroff
'\" End:

    return -options $options $result
}
.CE
.SH "SEE ALSO"
file(n), open(n), socket(n), eof(n), Tcl_StandardChannels(3)
.SH KEYWORDS
blocking, channel, close, nonblocking, half-close
.SH CATEGORY
Tcl Input/Output
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

.PP
(i.e., there are three spaces between each of the \fBa\fR, the \fBb\fR and the
\fBc\fR).
.SH "SEE ALSO"
append(n), eval(n), join(n)
.SH KEYWORDS
concatenate, join, list
.SH CATEGORY
Tcl List Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

    puts "x is $x"
}
.CE
.SH "SEE ALSO"
break(n), for(n), foreach(n), return(n), while(n)
.SH KEYWORDS
continue, iteration, loop
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

src msg              \fI\(-> prints "bar"\fR
dst msg              \fI\(-> prints "foo"\fR
.CE
.SH "SEE ALSO"
oo::class(n), oo::define(n), oo::object(n)
.SH KEYWORDS
clone, copy, duplication, object
.SH CATEGORY
Tcl Object Orientation
.\" Local variables:
.\" mode: nroff
.\" fill-column: 78
.\" End:

making from 2
made inner 1 context=:: name=::demo::coroEg
.CE
.SH "SEE ALSO"
apply(n), info(n), proc(n), return(n)
.SH KEYWORDS
coroutine, generator
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

package require dde
\fBdde execute\fR -async iexplore WWW_OpenURL http://www.tcl.tk/
.CE
.SH "SEE ALSO"
tk(n), winfo(n), send(n)
.SH KEYWORDS
application, dde, name, remote execution
.SH CATEGORY
Tcl Platform-specific
'\"Local Variables:
'\"mode: nroff
'\"End:

inst m1              \fI\(-> prints "red brick"\fR
inst m2              \fI\(-> prints "blue brick"\fR
.CE
.SH "SEE ALSO"
next(n), oo::class(n), oo::object(n)
.SH KEYWORDS
class, definition, method, object, slot
.SH CATEGORY
Tcl Object Orientation
.\" Local variables:
.\" mode: nroff
.\" fill-column: 78
.\" End:

puts $foo
#    prints: \fIa b foo {a b} bar 2 baz 3\fR
.CE
.SH "SEE ALSO"
append(n), array(n), foreach(n), mapeach(n), incr(n), list(n), lappend(n), set(n)
.SH KEYWORDS
dictionary, create, update, lookup, iterate, filter, map
.SH CATEGORY
Tcl List Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

would return the Unicode string
.QW "\eu306F" ,
which is the Hiragana letter HA.
.SH "SEE ALSO"
Tcl_GetEncoding(3)
.SH KEYWORDS
encoding, unicode

.SH CATEGORY
Tcl Library Procedures

    puts "Read record: $record"
}
.CE
.SH "SEE ALSO"
file(n), open(n), close(n), fblocked(n), Tcl_StandardChannels(3)
.SH KEYWORDS
channel, end of file

.SH CATEGORY
Tcl Input/Output

    \fBerror\fR "something is very wrong with addition"
}
.CE
.SH "SEE ALSO"
catch(n), return(n)
.SH KEYWORDS
error, exception
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

.CS
set var [linsert $var 0 {*}$args]
.CE
.SH "SEE ALSO"
catch(n), concat(n), error(n), interp(n), list(n), namespace(n), subst(n), tclvars(n), uplevel(n)
.SH KEYWORDS
concatenate, evaluate, script
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

file mkdir $secureDir
\fBexec\fR CIPHER /e /s:[file nativename $secureDir]
.CE
.SH "SEE ALSO"
error(n), file(n), open(n)
.SH KEYWORDS
execute, pipeline, redirection, subprocess
.SH CATEGORY
Tcl System Related
'\" Local Variables:
'\" mode: nroff
'\" End:

    \fBexit\fR 2
}
.CE
.SH "SEE ALSO"
exec(n)
.SH KEYWORDS
abort, exit, process

.SH CATEGORY
Tcl System Related

set randNum [\fBexpr\fR { int(100 * rand()) }]
.CE
.SH "SEE ALSO"
array(n), for(n), if(n), mathfunc(n), mathop(n), namespace(n), proc(n),
string(n), Tcl(n), while(n)
.SH KEYWORDS
arithmetic, boolean, compare, expression, fuzzy comparison
.SH CATEGORY
General
.SH COPYRIGHT
.nf
Copyright (c) 1993 The Regents of the University of California.
Copyright (c) 1994-2000 Sun Microsystems Incorporated.
Copyright (c) 2005 by Kevin B. Kenny <kennykb@acm.org>. All rights reserved.
.fi
'\" Local Variables:

socket -server connect 12345
vwait forever
.CE
.SH "SEE ALSO"
gets(n), open(n), read(n), socket(n), Tcl_StandardChannels(3)
.SH KEYWORDS
blocking, nonblocking

.SH CATEGORY
Tcl Input/Output

.SH "SEE ALSO"
close(n), flush(n), gets(n), open(n), puts(n), read(n), socket(n),
Tcl_StandardChannels(3)
.SH KEYWORDS
blocking, buffering, carriage return, end of line, flushing, linemode,
newline, nonblocking, platform, translation, encoding, filter, byte array,
binary
.SH CATEGORY
Tcl Input/Output
'\" Local Variables:
'\" mode: nroff
'\" End:

        -command [list CopyMore $in $out $chunk]
vwait done
.CE
.SH "SEE ALSO"
eof(n), fblocked(n), fconfigure(n), file(n)
.SH KEYWORDS
blocking, channel, end of line, end of file, nonblocking, read, translation

.SH CATEGORY
Tcl Input/Output

.CE
.SH "SEE ALSO"
filename(n), open(n), close(n), eof(n), gets(n), tell(n), seek(n),
fblocked(n), flush(n)
.SH KEYWORDS
attributes, copy files, delete files, directory, file, move files, name,
rename files, stat, user
.SH CATEGORY
Tcl Input/Output
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

\fBfileevent\fR is based on the \fBaddinput\fR command created
by Mark Diekhans.
.SH "SEE ALSO"
fconfigure(n), gets(n), interp(n), puts(n), read(n), Tcl_StandardChannels(3)
.SH KEYWORDS
asynchronous I/O, blocking, channel, event handler, nonblocking, readable,
script, writable.

.SH CATEGORY
Tcl Input/Output

.QW .....abc
is illegal.
.SH "SEE ALSO"
file(n), glob(n)
.SH KEYWORDS
current directory, absolute file name, relative file name,
volume-relative file name, portability

.SH CATEGORY
General

gets stdin name
puts "Hello there, $name!"
.CE
.SH "SEE ALSO"
file(n), open(n), socket(n), Tcl_StandardChannels(3)
.SH KEYWORDS
blocking, buffer, channel, flush, nonblocking, output

.SH CATEGORY
Tcl Input/Output

    puts "x is $x"
}
.CE
.SH "SEE ALSO"
break(n), continue(n), foreach(n), while(n)
.SH KEYWORDS
boolean, for, iteration, loop
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

.CE

.SH "SEE ALSO"
for(n), while(n), break(n), continue(n)

.SH KEYWORDS
foreach, iteration, list, loop

.SH CATEGORY
Tcl Control Constructs

# Finish off by printing the separator again
puts $sep
.CE
.SH "SEE ALSO"
scan(n), sprintf(3), string(n)
.SH KEYWORDS
conversion specifier, format, sprintf, string, substitution
.SH CATEGORY
Tcl String Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

.CE

.SH "SEE ALSO"
file(n), eof(n), fblocked(n), Tcl_StandardChannels(3)

.SH KEYWORDS
blocking, channel, end of file, end of line, line, non-blocking, read
.SH CATEGORY
Tcl Input/Output
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

.CS
\fBglob\fR \-type f *{a,b,cde}*
.CE
.SH "SEE ALSO"
file(n)
.SH KEYWORDS
exist, file, glob, pattern
.SH CATEGORY
Tcl System Related
'\" Local Variables:
'\" mode: nroff
'\" End:

    append accumulator $string \en
}
.CE
.SH "SEE ALSO"
namespace(n), upvar(n), variable(n)
.SH KEYWORDS
global, namespace, procedure, variable

.SH CATEGORY
Tcl Variables and Procedures

is modified to eliminate the history command and replace it with
the result of the history command.
If you want to redo an event without modifying history, then use
the \fBevent\fR operation to retrieve some event,
and the \fBadd\fR operation to add it to history and execute it.
.SH KEYWORDS
event, history, record

.SH CATEGORY
Tcl Interpreter Routines

    flush stderr
}
.CE
.SH "SEE ALSO"
safe(n), socket(n), safesock(n)
.SH KEYWORDS
internet, security policy, socket, www
.SH CATEGORY
Tcl Library Procedures
'\" Local Variables:
'\" mode: nroff
'\" End:

    puts "vbl is one, two or three"
}
.CE
.SH "SEE ALSO"
expr(n), for(n), foreach(n)
.SH KEYWORDS
boolean, conditional, else, false, if, true
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

.CS
\fBincr\fR x 0
.CE
.SH "SEE ALSO"
expr(n), set(n)
.SH KEYWORDS
add, increment, variable, value

.SH CATEGORY
Tcl Variables and Procedures

.VE 8.6
.SH KEYWORDS
command, information, interpreter, introspection, level, namespace,
.VS 8.6
object,
.VE 8.6
procedure, variable
.SH CATEGORY
Tcl Interpreter Routines
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

    }
}
.CE
.SH "SEE ALSO"
bgerror(n), load(n), safe(n), Tcl_CreateSlave(3), Tcl_Eval(3), Tcl_BackgroundException(3)
.SH KEYWORDS
alias, master interpreter, safe interpreter, slave interpreter
.SH CATEGORY
Tcl Interpreter Routines
'\"Local Variables:
'\"mode: nroff
'\"End:

\fBjoin\fR $data
     \fB\(-> 1 2 3 4 5 {6 7} 8\fR
.CE
.SH "SEE ALSO"
list(n), lappend(n), split(n)
.SH KEYWORDS
element, join, list, separator

.SH CATEGORY
Tcl List Handling

1 2 3 4 5
.CE
.SH "SEE ALSO"
list(n), lindex(n), linsert(n), llength(n), lset(n),
lsort(n), lrange(n)
.SH KEYWORDS
append, element, list, variable

.SH CATEGORY
Tcl List Handling Procedures

.CS
set ::argv [\fBlassign\fR $::argv argumentToReadOff]
.CE
.SH "SEE ALSO"
lindex(n), list(n), lrange(n), lset(n), set(n)
.SH KEYWORDS
assign, element, list, multiple, set, variable
.SH CATEGORY
Tcl List Handling
'\"Local Variables:
'\"mode: nroff
'\"End:
ff
'\"End:

considered to be a word character.  On Windows platforms, words are
comprised of any character that is not a space, tab, or newline.  Under
Unix, words are comprised of numbers, letters or underscores.
.SH "SEE ALSO"
info(n), re_syntax(n), tclvars(n)
.SH KEYWORDS
auto-exec, auto-load, library, unknown, word, whitespace 
.SH CATEGORY
Tcl Packages and Source files
'\"Local Variables:
'\"mode: nroff
'\"End:

.CE
.SH "SEE ALSO"
list(n), lappend(n), linsert(n), llength(n), lsearch(n), 
lset(n), lsort(n), lrange(n), lreplace(n),
string(n)
.SH KEYWORDS
element, index, list
.SH CATEGORY
Tcl List Handling
'\"Local Variables:
'\"mode: nroff
'\"End:

.CE
.SH "SEE ALSO"
list(n), lappend(n), lindex(n), llength(n), lsearch(n), 
lset(n), lsort(n), lrange(n), lreplace(n),
string(n)
.SH KEYWORDS
element, insert, list
.SH CATEGORY
Tcl List Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

.CE
.SH "SEE ALSO"
lappend(n), lindex(n), linsert(n), llength(n), lrange(n),
lrepeat(n),
lreplace(n), lsearch(n), lset(n), lsort(n)
.SH KEYWORDS
element, list, quoting
.SH CATEGORY
Tcl List Handling
'\"Local Variables:
'\"mode: nroff
'\"End:

1,0
.CE
.SH "SEE ALSO"
list(n), lappend(n), lindex(n), linsert(n), lsearch(n), 
lset(n), lsort(n), lrange(n), lreplace(n)
.SH KEYWORDS
element, list, length

.SH CATEGORY
Tcl List Handling

}}]
# The value of prefix is "8 7 6 5 4"
.CE
.SH "SEE ALSO"
break(n), continue(n), for(n), foreach(n), while(n)
.SH KEYWORDS
foreach, iteration, list, loop, map
.SH CATEGORY
Tcl List Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

# Now execute the command defined by the extension
foo
.CE
.SH "SEE ALSO"
info sharedlibextension, package(n), Tcl_StaticPackage(3), safe(n)
.SH KEYWORDS
binary code, dynamic library, load, safe interpreter, shared library
.SH CATEGORY
Tcl Packages and Source files
'\"Local Variables:
'\"mode: nroff
'\"End:

.CE
.SH "SEE ALSO"
list(n), lappend(n), lindex(n), linsert(n), llength(n), lsearch(n), 
lset(n), lreplace(n), lsort(n),
string(n)
.SH KEYWORDS
element, list, range, sublist

.SH CATEGORY
Tcl List Handling

      \fI\(-> {a a} b c {a a} b c {a a} b c\fR
.CE
.SH "SEE ALSO"
list(n), lappend(n), linsert(n), llength(n), lset(n)

.SH KEYWORDS
element, index, list

.SH CATEGORY
Tcl List Handling

.CE
.SH "SEE ALSO"
list(n), lappend(n), lindex(n), linsert(n), llength(n), lsearch(n),
lset(n), lrange(n), lsort(n),
string(n)
.SH KEYWORDS
element, list, replace

.SH CATEGORY
Tcl List Handling

      \fI\(-> f e {c d} b a\fR
.CE
.SH "SEE ALSO"
list(n), lsearch(n), lsort(n)

.SH KEYWORDS
element, list, reverse
.SH CATEGORY
Tcl List Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

.SH "SEE ALSO"
foreach(n), list(n), lappend(n), lindex(n), linsert(n), llength(n), 
lset(n), lsort(n), lrange(n), lreplace(n),
string(n)
.SH KEYWORDS
binary search, linear search,
list, match, pattern, regular expression, search, string
.SH CATEGORY
Tcl List Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

.CE
.SH "SEE ALSO"
list(n), lappend(n), lindex(n), linsert(n), llength(n), lsearch(n), 
lsort(n), lrange(n), lreplace(n),
string(n)
.SH KEYWORDS
element, index, list, replace, set
.SH CATEGORY
Tcl List Handling
'\"Local Variables:
'\"mode: nroff
'\"End:
ff
'\"End:

{1 dingo} {2 banana} {0x2 carrot} {3 apple}
.CE
.SH "SEE ALSO"
list(n), lappend(n), lindex(n), linsert(n), llength(n), lsearch(n), 
lset(n), lrange(n), lreplace(n)
.SH KEYWORDS
element, list, order, sort
.SH CATEGORY
Tcl List Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

\fBwide \fIarg\fR
.
The argument may be any numeric value.  The integer part of \fIarg\fR
is determined, and then the low order 64 bits of that integer value
are returned as an integer value.  
.SH "SEE ALSO"
expr(n), mathop(n), namespace(n)
.SH "CATEGORY"
General
.SH "COPYRIGHT"
.nf
Copyright (c) 1993 The Regents of the University of California.
Copyright (c) 1994-2000 Sun Microsystems Incorporated.
Copyright (c) 2005, 2006 by Kevin B. Kenny <kennykb@acm.org>.
.fi
'\" Local Variables:

\fI# Test to see if a list is sorted\fR
set sorted [\fB<=\fR {*}$list]
.CE
.SH "SEE ALSO"
expr(n), mathfunc(n), namespace(n)
.SH KEYWORDS
command, expression, operator
.SH CATEGORY
General
'\" Local Variables:
'\" mode: nroff
'\" End:

\fBckfree\fR after the overwrite occurred, rather than when the
specific memory with the overwritten guard zone(s) is freed, which may
occur long after the overwrite occurred.
.SH "SEE ALSO"
ckalloc, ckfree, Tcl_ValidateAllMemory, Tcl_DumpActiveMemory, TCL_MEM_DEBUG
.SH KEYWORDS
memory, debug
.SH CATEGORY
Tcl Interpreter Routines
'\"Local Variables:
'\"mode: nroff
'\"End:

.SH CREDITS
.PP
The message catalog code was developed by Mark Harrison.
.SH "SEE ALSO"
format(n), scan(n), namespace(n), package(n)
.SH KEYWORDS
internationalization, i18n, localization, l10n, message, text, translation
.SH CATEGORY
Tcl Library Procedures
.\" Local Variables:
.\" mode: nroff
.\" End:

o count              \fI\(-> prints "3"\fR
.CE
.SH "SEE ALSO"
next(n), oo::object(n), self(n)
.SH KEYWORDS
method, method visibility, object, private method, public method

.SH CATEGORY
Tcl Object Orientation
.\" Local variables:
.\" mode: nroff
.\" fill-column: 78
.\" End:

puts [do 1 plus [do 9 minus 7]]
.CE
.VE 8.6
.SH "SEE ALSO"
interp(n), upvar(n), variable(n)
.SH KEYWORDS
command, ensemble, exported, internal, variable
.SH CATEGORY
Tcl Variables and Procedures
'\" Local Variables:
'\" mode: nroff
'\" End:

demo flushCache
puts [demo compute  1 2 3]      \fI\(-> prints "7" after delay\fR
.CE
.SH "SEE ALSO"
oo::class(n), oo::define(n), oo::object(n), self(n)
.SH KEYWORDS
call, method, method chain
.SH CATEGORY
Tcl Object Orientation
.\" Local variables:
.\" mode: nroff
.\" fill-column: 78
.\" End:

$obj \fBdestroy\fR
$obj foo             \fI\(-> error "unknown command obj"\fR
.CE
.SH "SEE ALSO"
my(n), oo::class(n)
.SH KEYWORDS
base class, class, object, root class
.SH CATEGORY
Tcl Object Orientation
.\" Local variables:
.\" mode: nroff
.\" fill-column: 78
.\" End:

.CE
.SH "SEE ALSO"
file(n), close(n), filename(n), fconfigure(n), gets(n), read(n),
puts(n), exec(n), pid(n), fopen(3)
.SH KEYWORDS
access mode, append, create, file, non-blocking, open, permissions,
pipeline, process, serial
.SH CATEGORY
Tcl Input/Output
'\"Local Variables:
'\"mode: nroff
'\"End:

    # We have the package, configure the app to use it
}
.CE
.SH "SEE ALSO"
msgcat(n), packagens(n), pkgMkIndex(n)
.SH KEYWORDS
package, version
.SH CATEGORY
Tcl Packages and Source files
'\" Local Variables:
'\" mode: nroff
'\" End:

specified.
.PP
At least one \fB\-load\fR or \fB\-source\fR parameter must be given.
.SH "SEE ALSO"
package(n)
.SH KEYWORDS
auto-load, index, package, version

.SH CATEGORY
Tcl Packages and Source files

.CE

.SH "SEE ALSO"
exec(n), open(n)

.SH KEYWORDS
file, pipeline, process identifier

.SH CATEGORY
Tcl System Related

If you must use \fB\-load\fR,
then you must specify the scripts first; otherwise the package loaded from
the binary file may mask the package defined by the scripts.
.SH "SEE ALSO"
package(n)
.SH KEYWORDS
auto-load, index, package, version
.SH CATEGORY
Tcl Packages and Source files
'\"Local Variables:
'\"mode: nroff
'\"End:

set binDir [file dirname [file normalize [info script]]]
set libDir [file join $binDir .. lib]
set platLibDir [file join $libDir [\fBplatform::identify\fR]]
load [file join $platLibDir support[info sharedlibextension]]
.CE
.SH KEYWORDS
operating system, cpu architecture, platform, architecture
.SH CATEGORY
Tcl System Related
'\" Local Variables:
'\" mode: nroff
'\" End:

for the specified Tcl shell, in contrast to the running shell.
.TP
\fBplatform::shell::platform \fIshell\fR
This command returns the contents of \fBtcl_platform(platform)\fR for
the specified Tcl shell.
.SH KEYWORDS
operating system, cpu architecture, platform, architecture

.SH CATEGORY
Tcl System Related

    cepa { }
}
.CE
.SH "SEE ALSO"
lsearch(n), namespace(n), string(n), Tcl_GetIndexFromObj(3)
.SH "KEYWORDS"
prefix, table lookup
.SH CATEGORY
Tcl String Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

    set var [expr {$var * $multiplier}]
}
.CE
.SH "SEE ALSO"
info(n), unknown(n)
.SH KEYWORDS
argument, procedure
.SH CATEGORY
Tcl Variables and Procedures
'\" Local Variables:
'\" mode: nroff
'\" End:

\fBputs\fR $chan "$timestamp - Hello, World!"
close $chan
.CE
.SH "SEE ALSO"
file(n), fileevent(n), Tcl_StandardChannels(3)
.SH KEYWORDS
channel, newline, output, write

.SH CATEGORY
Tcl Input/Output

exec tar -xf $tarFile
cd $savedDir
.CE
.SH "SEE ALSO"
file(n), cd(n), glob(n), filename(n)
.SH KEYWORDS
working directory

.SH CATEGORY
Tcl System Related

and
.QW \fB[[:>:]]\fR
respectively; no other escapes are available.
.SH "SEE ALSO"
RegExp(3), regexp(n), regsub(n), lsearch(n), switch(n), text(n)
.SH KEYWORDS
match, regular expression, string
.SH CATEGORY
Tcl String Handling
.\" Local Variables:
.\" mode: nroff
.\" End:

close $fl
set lines [split $data \en]
.CE
.SH "SEE ALSO"
file(n), eof(n), fblocked(n), fconfigure(n), Tcl_StandardChannels(3)
.SH KEYWORDS
blocking, channel, end of line, end of file, nonblocking, read, translation, encoding
.SH CATEGORY
Tcl Input/Output
'\"Local Variables:
'\"mode: nroff
'\"End:

seek $ch -5 end;
puts [read $ch];   # Prints just the last word
.CE
.SH "SEE ALSO"
chan(n), transchan(n)
.SH KEYWORDS
API, channel, ensemble, prefix, reflection
.SH CATEGORY
Tcl Input/Output
'\" Local Variables:
'\" mode: nroff
'\" End:

.CS
\fBregexp\fR \-all \-inline {\eS+} $string
.CE
.SH "SEE ALSO"
re_syntax(n), regsub(n), string(n)
.SH KEYWORDS
match, parsing, pattern, regular expression, splitting, string
.SH CATEGORY
Tcl String Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

# Read the command!
set command [\fBregistry get\fR $path {}]

puts "$ext opens with $command"
.CE
.SH KEYWORDS
registry
.SH CATEGORY
Tcl Platform-specific
'\" Local Variables:
'\" mode: nroff
'\" End:

set quoted [subst [string map {\en {\e\eu000a}} \e
        [\fBregsub\fR -all $RE $string $substitution]]]
.CE
.SH "SEE ALSO"
regexp(n), re_syntax(n), subst(n), string(n)
.SH KEYWORDS
match, pattern, quoting, regular expression, substitution
.SH CATEGORY
Tcl String Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

    uplevel 1 ::theRealSource $args
}
.CE
.SH "SEE ALSO"
namespace(n), proc(n)
.SH KEYWORDS
command, delete, namespace, rename

.SH CATEGORY
Tcl Variables and Procedures

}
.CE
.SH "SEE ALSO"
break(n), catch(n), continue(n), dict(n), error(n), proc(n),
source(n), tclvars(n), throw(n), try(n)
.SH KEYWORDS
break, catch, continue, error, exception, procedure, result, return
.SH CATEGORY
Tcl Control Constructs
.\" Local Variables:
.\" mode: nroff
.\" End:

an \fBauto_reset\fR is automatically evaluated in the safe interpreter
to synchronize its \fBauto_index\fR with the new token list.
.SH "SEE ALSO"
interp(n), library(n), load(n), package(n), source(n), unknown(n)
.SH KEYWORDS
alias, auto\-loading, auto_mkindex, load, master interpreter, safe
interpreter, slave interpreter, source
.SH CATEGORY
General
'\" Local Variables:
'\" mode: nroff
'\" End:

\fI%\fR scan 20000000000000000000 %lld
20000000000000000000
.CE
.SH "SEE ALSO"
format(n), sscanf(3)
.SH KEYWORDS
conversion specifier, parse, scan
.SH CATEGORY
Tcl String Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

set data [read $f 10]
close $f
.CE
.SH "SEE ALSO"
file(n), open(n), close(n), gets(n), tell(n), Tcl_StandardChannels(3)
.SH KEYWORDS
access position, file, seek
.SH CATEGORY
Tcl Input/Output
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

        \fI\(-> Cls: {{method x object method} {method x ::c method}} 1\fR
        \fI\(-> Obj: {{method x object method} {method x ::c method}} 0\fR
.CE
.SH "SEE ALSO"
info(n), next(n)
.SH KEYWORDS
call, introspection, object
.SH CATEGORY
Tcl Object Orientation
.\" Local variables:
.\" mode: nroff
.\" fill-column: 78
.\" End:

\fBset\fR vbl in[expr {rand() >= 0.5}]
\fBset\fR out [\fBset\fR $vbl]
.CE
.SH "SEE ALSO"
expr(n), global(n), namespace(n), proc(n), trace(n), unset(n), upvar(n), variable(n)
.SH KEYWORDS
read, write, variable

.SH CATEGORY
Tcl Variables and Procedures

.CE
.SH "HISTORY"
Support for IPv6 was added in Tcl 8.6.
.SH "SEE ALSO"
chan(n), flush(n), open(n), read(n)
.SH KEYWORDS
asynchronous I/O, bind, channel, connection, domain name, host, network address, socket, tcp
.SH CATEGORY
Tcl Input/Output
'\" Local Variables:
'\" mode: nroff
'\" End:

    \fBsource\fR $scriptFile
}
.CE
.SH "SEE ALSO"
file(n), cd(n), encoding(n), info(n)
.SH KEYWORDS
file, script

.SH CATEGORY
Tcl Packages and Source files

    puts "$longName uses [file tail $shell] for a login shell"
}
.CE
.SH "SEE ALSO"
join(n), list(n), string(n)
.SH KEYWORDS
list, split, string
.SH CATEGORY
Tcl List Handling
'\" Local Variables:
'\" mode: nroff
'\" End:

}
.CE
.SH "SEE ALSO"
expr(n), list(n)
.SH KEYWORDS
case conversion, compare, index, match, pattern, string, word, equal,
ctype, character, reverse
.SH CATEGORY
Tcl String Handling
.\" Local Variables:
.\" mode: nroff
.\" End:

.QW \fBabc,foo,def\fR ,
not
.QW \fBabc,3,def\fR .
.SH "SEE ALSO"
Tcl(n), eval(n), break(n), continue(n)
.SH KEYWORDS
backslash substitution, command substitution, quoting, substitution, variable substitution
.SH CATEGORY
Tcl String Handling
.\" Local Variables:
.\" mode: nroff
.\" End:

    }
}
.CE
.SH "SEE ALSO"
for(n), if(n), regexp(n)
.SH KEYWORDS
switch, match, regular expression
.SH CATEGORY
Tcl Control Constructs
.\" Local Variables:
.\" mode: nroff
.\" End:

    }
}
.CE
.SH "SEE ALSO"
apply(n), proc(n), uplevel(n)
.SH KEYWORDS
call, recursion, tail recursion
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

.SH "STANDARD CHANNELS"
.PP
See \fBTcl_StandardChannels\fR for more explanations.
.SH "SEE ALSO"
encoding(n), fconfigure(n), tclvars(n)
.SH KEYWORDS
application, argument, interpreter, prompt, script file, shell

.SH CATEGORY
General

script is being run.  Errors thrown by C procedures or printed
directly from C applications will not be caught by the \fBtest\fR command.
Therefore, usage of the \fB\-output\fR and \fB\-errorOutput\fR
options to \fBtest\fR is useful only for pure Tcl applications
that use \fBputs\fR to produce output. 
.SH KEYWORDS
test, test harness, test suite
.SH CATEGORY
General
.\" Local Variables:
.\" mode: nroff
.\" End:

}
.CE
.SH "SEE ALSO"
eval(n), library(n), tclsh(1), tkvars(n), wish(1)
.SH KEYWORDS
arithmetic, bytecode, compiler, error, environment, POSIX, precision,
subprocess, user, variables
.SH CATEGORY
Predefined variables
'\" Local Variables:
'\" mode: nroff
'\" End:

    seek $chan $offset
}
.CE
.SH "SEE ALSO"
file(n), open(n), close(n), gets(n), seek(n), Tcl_StandardChannels(3)
.SH KEYWORDS
access position, channel, seeking

.SH CATEGORY
Tcl Input/Output

.CS
\fBthrow\fR {ARITH DIVZERO {divide by zero}} {divide by zero}
.CE
.SH "SEE ALSO"
catch(n), error(n), return(n), tclvars(n), try(n)
.SH "KEYWORDS"
error, exception
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

    }
}
.CE
.SH "SEE ALSO"
clock(n)
.SH KEYWORDS
script, time
.SH CATEGORY
Tcl System Related
.\" Local Variables:
.\" mode: nroff
.\" End:

package(n), Tcl Improvement Proposal #189
.QW "\fITcl Modules\fR"
(online at http://tip.tcl.tk/189.html), Tcl Improvement Proposal #190
.QW "\fIImplementation Choices for Tcl Modules\fR"
(online at http://tip.tcl.tk/190.html)
.SH "KEYWORDS"
modules, package
.SH CATEGORY
Tcl Packages and Source files
.\" Local Variables:
.\" mode: nroff
.\" End:

    \fIreport {puts hello} enterstep\fR
    \fIhello\fR
.CE
.SH "SEE ALSO"
set(n), unset(n)
.SH KEYWORDS
read, command, rename, variable, write, trace, unset
.SH CATEGORY
Tcl Variables and Procedures
.\" Local Variables:
.\" mode: nroff
.\" End:

written to it right now. It is allowed to store this data in internal buffers
and to defer the actual transformation until it has more data.
.RE
.SH "SEE ALSO"
chan(n), refchan(n)
.SH KEYWORDS
API, channel, ensemble, prefix, transformation
.SH CATEGORY
Tcl Input/Output
'\" Local Variables:
'\" mode: nroff
'\" End:

    puts "failed to open /some/file/name: it doesn't exist"
}
.CE
.SH "SEE ALSO"
catch(n), error(n), return(n), throw(n)
.SH "KEYWORDS"
cleanup, error, exception, final, resource management
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" End:

    uplevel 1 [list _original_unknown {*}$args]
}
.CE
.SH "SEE ALSO"
info(n), proc(n), interp(n), library(n), namespace(n)
.SH KEYWORDS
error, non-existent command, unknown

.SH CATEGORY
Tcl Interpreter Routines

long-running Tcl program and then removed again (either because it is
no longer needed or because it is being updated with a new version)
without having to shut down the overall Tcl process.
.SH "SEE ALSO"
info sharedlibextension, load(n), safe(n)
.SH KEYWORDS
binary code, unloading, safe interpreter, shared library
.SH CATEGORY
Tcl Packages and Source files
.\" Local Variables:
.\" mode: nroff
.\" End:

puts "The prime squares are:"
parray squares
.CE
.SH "SEE ALSO"
set(n), trace(n), upvar(n)
.SH KEYWORDS
remove, variable
.SH CATEGORY
Tcl Variables and Procedures
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

    \fBupdate\fR
}
.CE
.SH "SEE ALSO"
after(n), interp(n)
.SH KEYWORDS
asynchronous I/O, event, flush, handler, idle, update

.SH CATEGORY
Tcl Control Constructs

    }
}
.CE
.SH "SEE ALSO"
apply(n), namespace(n), upvar(n)
.SH KEYWORDS
context, level, namespace, stack frame, variable
.SH CATEGORY
Tcl Control Constructs
.\" Local Variables:
.\" mode: nroff
.\" End:

    incr var [expr {-$decrement}]
}
.CE
.SH "SEE ALSO"
global(n), namespace(n), uplevel(n), variable(n)
.SH KEYWORDS
context, frame, global, level, namespace, procedure, upvar, variable
.SH CATEGORY
Tcl Variables and Procedures
.\" Local Variables:
.\" mode: nroff
.\" End:

    }
}
.CE
.SH "SEE ALSO"
global(n), namespace(n), upvar(n)
.SH KEYWORDS
global, namespace, procedure, variable

.SH CATEGORY
Tcl Variables and Procedures

}
\fBvwait\fR done
.CE
.SH "SEE ALSO"
global(n), update(n)
.SH KEYWORDS
asynchronous I/O, event, variable, wait
.SH CATEGORY
Tcl Control Constructs
'\" Local Variables:
'\" mode: nroff
'\" fill-column: 78
'\" End:

    puts "[incr lineCount]: $line"
}
.CE
.SH "SEE ALSO"
break(n), continue(n), for(n), foreach(n)
.SH KEYWORDS
boolean, loop, test, while

.SH CATEGORY
Tcl Control Constructs

set compData [$\fIstrm \fBget\fR]
$\fIstrm \fBclose\fR
.CE
.SH "SEE ALSO"
binary(n), chan(n), encoding(n), Tcl_ZlibDeflate(3), RFC1950 \- RFC1952
.SH "KEYWORDS"
compress, decompress, deflate, gzip, inflate, zlib
.SH CATEGORY
Tcl Library Procedures
'\" Local Variables:
'\" mode: nroff
'\" End:

##
## Utility functions for Man->HTML converter. Note that these
## functions are specifically intended to work with the format as used
## by Tcl and Tk; they do not cope with arbitrary nroff markup.
##
## Copyright (c) 1995-1997 Roger E. Critchlow Jr
## Copyright (c) 2004-2011 Donal K. Fellows

set ::STATUSOUT stdout ;# status outputs 
set ::manual(report-level) 1

proc manerror {msg} {
    global manual
    set name {}
    set subj {}
    set procname [lindex [info level -1] 0]
    if {[info exists manual(name)]} {
	set name $manual(name)
    }
    if {[info exists manual(section)] && [string length $manual(section)]} {
	puts stderr "$name: $manual(section): $procname: $msg"
	puts stderr "\n$name: $manual(section): $procname: $msg"
    } else {
	puts stderr "$name: $procname: $msg"
	puts stderr "\n$name: $procname: $msg"
    }
}

proc manreport {level msg} {
    global manual
    if {$level < $manual(report-level)} {
	uplevel 1 [list manerror $msg]

	    {\(mu}	"×" \
	    {\(mi}	"−" \
	    {\(->}	"<font size=\"+1\">&#8594;</font>" \
	    {\fP}	{\fR} \
	    {\.}	. \
	    {\(bu}	"&#8226;" \
	    {\*(qo}	"&ocirc;" \
	    {\'}	"'" \
	    ]
    lappend charmap {\-\|\-} --        ; # two hyphens
    lappend charmap {\-} -             ; # a hyphen

    set text [htmlize-text $text $charmap]
    set origtext [htmlize-text $text $charmap]
    # General quoted entity
    regsub -all {\\N'(\d+)'} $text "\\&#\\1;" text
    while {[string first "\\" $text] >= 0} {
	# C R
	if {[regsub {^([^\\]*)\\fC([^\\]*)\\fR(.*)$} $text \
		{\1<TT>\2</TT>\3} text]} continue
	# B R
	if {[regsub {^([^\\]*)\\fB([^\\]*)\\fR(.*)$} $text \
    regsub -all {\\N'(\d+)'} $origtext "\\&#\\1;" text
    
    # Font changes
    set parts {}
    set endCurrentFont {}
    set FONT_MAP {
      R {"" ""}
		{\1<B>\2</B>\3} text]} continue
	# B I
      B {"<B>" "</B>"}
	if {[regsub {^([^\\]*)\\fB([^\\]*)\\fI(.*)$} $text \
		{\1<B>\2</B>\\fI\3} text]} continue
	# I R
      I {"<I>" "</I>"}
	if {[regsub {^([^\\]*)\\fI([^\\]*)\\fR(.*)$} $text \
		{\1<I>\2</I>\3} text]} continue
	# I B
	if {[regsub {^([^\\]*)\\fI([^\\]*)\\fB(.*)$} $text \
		{\1<I>\2</I>\\fB\3} text]} continue
	# B B, I I, R R
	if {
	    [regsub {^([^\\]*)\\fB([^\\]*)\\fB(.*)$} $text \
      C {"<TT>" "</TT>"}
    }
    while {[string first "\\f" $text] >= 0} {
		{\1\\fB\2\3} ntext]
	    || [regsub {^([^\\]*)\\fI([^\\]*)\\fI(.*)$} $text \
	if { ! [regexp -- {^([^\\]*)\\f(.|\(..)(.*)$} $text -> part font text] } {
		    {\1\\fI\2\3} ntext]
	    || [regsub {^([^\\]*)\\fR([^\\]*)\\fR(.*)$} $text \
		    {\1\\fR\2\3} ntext]
	} {
	    manerror "impotent font change: $text"
	    set text $ntext
	    manerror "unrecognised font change \\f: $origtext"
        }
        if { ! [dict exists $FONT_MAP $font] } {
	    manerror "unrecognised font change \\f${font}: $origtext"
        }
        lassign [dict get $FONT_MAP $font] startFontHtml endFontHtml
        lappend parts $part $endCurrentFont $startFontHtml
        set endCurrentFont $endFontHtml
    }
    lappend parts $text $endCurrentFont
    set text [join $parts {}]
	    continue
	}
    
    if {[string first "\\" $text] >= 0} {
	# unrecognized
	set text [string map [list "\\" "&#92;"] $text]
	manerror "uncaught backslash: $text"
    }
    if {[string match ".*" $text]} {
	# leading period could get confused for a directive later
	set text [string map [list "\\" "&#92;"] $text]
	set text [string replace $text 0 0 "&#46;"]
    }
    return $text
}

##
## pass 2 text input and matching
##

## there's only one line in the NAME section,
## consisting of a comma separated list of names,
## followed by a hyphen and a short description.
##
proc output-name {line} {
    global manual
    # split name line into pieces
    regexp {^([^-]+) - (.*)$} [regsub -all {[ \n\r\t]+} $line " "] -> head tail
    if { ! [regexp {^([^-]+) -\s?(.*)$} [regsub -all {[ \n\r\t]+} $line " "] -> head tail] } {
	    manerror "bad section name: $line"
    }
    # output line to manual page untouched
    man-puts "$head — $tail"
    # output line to long table of contents
    lappend manual(section-toc) "<DL><DD>$head &mdash; $tail</DD></DL>"
    # separate out the names for future reference
    foreach name [split $head ,] {
	set name [string trim $name]
	if {[llength $name] > 1} {
	    manerror "name has a space: {$name}\nfrom: $line"
	}
	lappend manual(wing-toc) $name
	lappend manual(name-$name) $manual(wing-file)/$manual(name)
	set manual(descrip-$name) $tail
	set manual(cat-master-$name) $manual(name)
    }
    set manual(tooltip-$manual(wing-file)/$manual(name).htm) $line
}

##
## build a cross-reference link if appropriate
##

	    set tk_ref [lindex $manref $tk_i]
	    return "<A HREF=\"../$tk_ref.htm\">$ref</A>"
	}
	if {$lref eq "exit" && $mantail eq "tclsh.1" && $tcl_i >= 0} {
	    set tcl_ref [lindex $manref $tcl_i]
	    return "<A HREF=\"../$tcl_ref.htm\">$ref</A>"
	}
	puts stderr "multiple cross reference to $ref in $manref from $manual(wing-file)/$mantail"
	puts stderr "\nmultiple cross reference to $ref in $manref from $manual(wing-file)/$mantail"
	return $ref
    }
    ##
    ## exceptions, sigh, to the rule
    ##
    if {[info exists exclude_when_followed_by_map($mantail)]} {
	upvar 1 text tail

}

##
## reference generation errors
##
proc reference-error {msg text} {
    global manual
    puts stderr "$manual(tail): $msg: {$text}"
    puts stderr "\n$manual(tail): reference error: $msg: {$text}"
    return $text
}

##
## insert as many cross references into this text string as are appropriate
##
proc insert-cross-references {text} {

		regexp -indices -start $off {http://[\w/.]+} $text range
		set url [string range $text {*}$range]
		append result "<A HREF=\"$url\">" $url "</A>"
		set text [string range $text[set text ""] \
			      [expr {[lindex $range 1]+1}] end]
		continue
	    }
	    end-anchor - end-bold - end-quote {
	    end-anchor - end-bold {
		return [reference-error "Out of place $invert([lindex $offsets 0])" $text]
	    }
	    end-quote {
		# '' is valid text
		append result ''
		set text [string range $text[set text ""] \
			      [expr {$offset(end-quote)+1}] end]
		continue
	    }
	}
    }
}

##
## process formatting directives

				    $manual(wing-file)/$manual(name).htm]
			    set initial [string toupper [string index $key 0]]
			    lappend keys "<A href=\"../Keywords/$initial.htm\#$key\">$key</A>"
			}
			man-puts [join $keys {, }]
		    }
		    return
		}
		H:CATEGORY {
		    while {[more-text]} {
			if {[next-op-is .SH rest] || [next-op-is .SS rest]} {
			    backup-text 1
			    return
			}
			set more [next-text]
			if {[is-a-directive $more]} {
			    manerror "$more"
			    backup-text 1
			    return
			}
                        set manual(category-$manual(name)) $more
			man-puts $more
		    }
		    return
		}
	    }
	    if {[next-op-is .IP rest]} {
		output-IP-list $code .IP $rest
		return
	    }
	    if {[next-op-is .PP rest]} {

	    manerror "unexpected $code"
	    return
	}
	.ta - .fi - .na - .ad - .UL - .ie - .el - .ne {
	    manerror "ignoring $line"
	}
	default {
	    manerror "unrecognized format directive: $line"
	    manerror "unrecognized directive: $line"
	}
    }
}

##
## merge copyright listings
##
proc merge-copyrights {l1 l2} {
    set merge {}
    # Preferred format
    set re1 {^Copyright +(?:\(c\)|\\\(co|©) +(\w.*?)(?:all rights reserved)?(?:\. )*$}
    set re2 {^(\d+) +(?:by +)?(\w.*)$}         ;# date who
    set re3 {^(\d+)-(\d+) +(?:by +)?(\w.*)$}   ;# from to who
    set re4 {^(\d+), *(\d+) +(?:by +)?(\w.*)$} ;# date1 date2 who
    set re1 {^Copyright +(?:\(c\)|\\\(co|©) +([0-9\-, ]+) +(?:by +)?(\w.*?)$}
    # Relaxed format (will warn): allow \u2013 and '/' in dates, part clause
    set re2 {^Copyright +(?:\(c\)|\\\(co|©) +([0-9\-\u2013,/]+) +(?:\([^)]+\) +)?(?:by +)?(\w.*?)$}
    # Single year date term
    set re3 {^\s*(\d\d\d\d)\s*$}
    # YYYY-YYYY or YYYY-Y date term
    set re4 {^\s*(\d\d\d\d)[\-\u2013,/](\d+)\s*$}
    # Recognised trailing copyright terms
    set re5 {(.*)(all rights reserved|see license.txt for terms)\.?\s*$}

    foreach copyright [concat $l1 $l2] {
	# Parse into date and info; the copyright identifier must be present
	# (but is ignored); a part clause (e.g. '(docs)') and/or 'by' are
        # permissed before the info and are also ignored. 
	if {[regexp -nocase -- $re1 $copyright -> info]} {
	    set info [string trimright $info ". "] ; # remove extra period
	    if {[regexp -- $re2 $info -> date who]} {
	if {! [regexp -nocase -- $re1 $copyright -> date info]} {
	    if {! [regexp -nocase -- $re2 $copyright -> date info]} {
		manerror "unrecognised format: $copyright"
                continue
            }
	}
	# Info consists of period-separated terms.  The first term identifies
        # the copyright owner. 
	while { [regexp -nocase -- $re5 $info -> info] } {
	    # loop
	}
	set who [string trimright $info ". "]
        # Date consists of single year dates or date ranges (YYYY-YYYY|YYYY-Y) 
        # separated by comma.
	foreach dateterm [split [string trimright $date ,] ,] {
	    if {[regexp -- $re3 $dateterm -> date]} {
		lappend dates($who) $date
		continue
	    } elseif {[regexp -- $re3 $info -> from to who]} {
	    } elseif {[regexp -- $re4 $dateterm -> from to]} {
		set to "[string range $from 0 \
                  [expr {[string length $from]-[string length $to]-1}]]$to"
		for {set date $from} {$date <= $to} {incr date} {
		    lappend dates($who) $date
		}
		continue
	    } elseif {[regexp -- $re3 $info -> date1 date2 who]} {
		lappend dates($who) $date1 $date2
	    } else { 
		manerror "unrecognised date format: $copyright"
		continue
	    }
	    } 
	}
	puts "oops: $copyright"
    }
    foreach who [array names dates] {
	set list [lsort -dictionary $dates($who)]
	if {[llength $list] == 1 || [lindex $list 0] eq [lrange $list end end]} {
	    lappend merge "Copyright &copy; [lindex $list 0] $who"
	} else {
	    lappend merge "Copyright &copy; [lindex $list 0]-[lrange $list end end] $who"

	manual(wing-name) \
	manual(wing-file) \
	manual(wing-description)
    set manual(wing-copyrights) {}
    makedirhier $outputDir/$manual(wing-file)
    set manual(wing-toc-fp) [open $outputDir/$manual(wing-file)/[indexfile] w]
    # whistle
    puts stderr "scanning section $manual(wing-name)"
    puts $::STATUSOUT "\nscanning section $manual(wing-name)"
    # put the entry for this section into the short table of contents
    if {[regexp {^(.+), version (.+)$} $manual(wing-name) -> name version]} {
	puts $manual(short-toc-fp) "<DT><A HREF=\"$manual(wing-file)/[indexfile]\" TITLE=\"version $version\">$name</A></DT><DD>$manual(wing-description)</DD>"
    } else {
	puts $manual(short-toc-fp) "<DT><A HREF=\"$manual(wing-file)/[indexfile]\">$manual(wing-name)</A></DT><DD>$manual(wing-description)</DD>"
    }
    # initialize the wing table of contents

    # get the manual pages for this section
    set manual(pages) [lsort -dictionary [glob -nocomplain $manual(wing-glob)]]
    # Some pages have to go first so that their links override others
    foreach pat $process_first_patterns {
	set n [lsearch -glob $manual(pages) $pat]
	if {$n >= 0} {
	    set f [lindex $manual(pages) $n]
	    puts stderr "shuffling [file tail $f] to front of processing queue"
	    puts $::STATUSOUT "shuffling [file tail $f] to front of processing queue"
	    set manual(pages) \
		[linsert [lreplace $manual(pages) $n $n] 0 $f]
	}
    }
    # set manual(pages) [lrange $manual(pages) 0 5]
    foreach manual_page $manual(pages) {
	set manual(page) [file normalize $manual_page]
	# whistle
	if {$verbose} {
	    puts stderr "scanning page $manual(page)"
	    puts $::STATUSOUT "scanning page $manual(page)"
	} else {
	    puts -nonewline stderr .
	    puts -nonewline $::STATUSOUT .
	}
	set manual(tail) [file tail $manual(page)]
	set manual(name) [file root $manual(tail)]
	set manual(section) {}
	if {$manual(name) in $excluded_pages} {
	    # obsolete
	    if {!$verbose} {
		puts stderr ""
	    }
	    manerror "discarding $manual(name)"
	    continue
	}
	set manual(infp) [open $manual(page)]
	set manual(text) {}
	set manual(partial-text) {}
	foreach p {.RS .DS .CS .SO} {

		    # ignore
		    continue
		}
	    }
	    switch -exact -- $code {
		.SH - .SS {
		    flushbuffer
		    if {[llength $rest] == 0} {
		    if {$rest eq {}} {
			gets $manual(infp) rest
		    }
		    lappend manual(text) "$code [unquote $rest]"
		}
		.TH {
		    flushbuffer
		    lappend manual(text) "$code [unquote $rest]"

		.HS - .UL - .ta {
		    flushbuffer
		    lappend manual(text) "$code [unquote $rest]"
		}
		.BS - .BE - .br - .fi - .sp - .nf {
		    flushbuffer
		    if {$rest ne ""} {
			if {!$verbose} {
			    puts stderr ""
			}
			manerror "unexpected argument: $line"
		    }
		    lappend manual(text) $code
		}
		.AP {
		    flushbuffer
		    lappend manual(text) [concat .IP [process-text \
			    "[lindex $rest 0] \\fB[lindex $rest 1]\\fR ([lindex $rest 2])"]]
		}
		.IP {
		    flushbuffer
		    regexp {^(.*) +\d+$} $rest all rest
		    lappend manual(text) ".IP [process-text \
			    [unquote [string trim $rest]]]"
		}
		.TP {
		    flushbuffer
		    while {[is-a-directive [set next [gets $manual(infp)]]]} {
			if {!$verbose} {
			    puts stderr ""
			}
			manerror "ignoring $next after .TP"
		    }
		    if {"$next" ne {'}} {
			lappend manual(text) ".IP [process-text $next]"
		    }
		}
		.OP {

		}
		.CS {
		    flushbuffer
		    incr manual(.CS)
		    lappend manual(text) $code
		}
		.CE {
		    flushbuffer
		    flushbuffer true
		    incr manual(.CS) -1
		    lappend manual(text) $code
		}
		.de {
		    while {[gets $manual(infp) line] >= 0} {
			if {[string match "..*" $line]} {
			    break
			}
		    }
		}
		.. {
		    if {!$verbose} {
			puts stderr ""
		    }
		    error "found .. outside of .de"
		}
		default {
		    if {!$verbose} {
			puts stderr ""
		    }
		    flushbuffer
		    manerror "unrecognized format directive: $line"
                    if { $manual(.CS) > 0 } {
			addbuffer $line
			manerror "unrecognized format directive in .CS (treating as text): $line"
		    } else {
			flushbuffer
			manerror "unrecognized format directive: $line"
		    }
		}
	    }
	}
	flushbuffer
	close $manual(infp)
	# fixups
	if {$manual(.RS) != 0} {
	    if {!$verbose} {
		puts stderr ""
	    }
	    puts "unbalanced .RS .RE"
	    manerror "unbalanced .RS .RE"
	}
	if {$manual(.DS) != 0} {
	    if {!$verbose} {
		puts stderr ""
	    }
	    puts "unbalanced .DS .DE"
	    manerror "unbalanced .DS .DE"
	}
	if {$manual(.CS) != 0} {
	    if {!$verbose} {
		puts stderr ""
	    }
	    puts "unbalanced .CS .CE"
	    manerror "unbalanced .CS .CE"
	}
	if {$manual(.SO) != 0} {
	    if {!$verbose} {
		puts stderr ""
	    }
	    puts "unbalanced .SO .SE"
	    manerror "unbalanced .SO .SE"
	}
	# output conversion
	open-text
	set haserror 0
	if {[next-op-is .HS rest]} {
	    set manual($manual(wing-file)-$manual(name)-title) \
		"[join [lrange $rest 1 end] { }] [lindex $rest 0] manual page"
	} elseif {[next-op-is .TH rest]} {
	    set manual($manual(wing-file)-$manual(name)-title) \
		"[lindex $rest 0] manual page - [join [lrange $rest 4 end] { }]"
	} else {
	    set haserror 1
	    if {!$verbose} {
		puts stderr ""
	    }
	    manerror "no .HS or .TH record found"
	}
	if {!$haserror} {
	    while {[more-text]} {
		set line [next-text]
		if {[is-a-directive $line]} {
		    output-directive $line

	}
	#
	# make the long table of contents for this page
	#
	set manual(toc-$manual(wing-file)-$manual(name)) \
	    [concat <DL> $manual(section-toc) </DL>]
    }
    if {!$verbose} {
	puts stderr ""
    }

    #
    # make the wing table of contents for the section
    #
    set width 0
    foreach name $manual(wing-toc) {
	if {[string length $name] > $width} {
	    set width [string length $name]
	}
    }
    set perline [expr {118 / $width}]
    set perline [expr { max(1, min(5, 118 / $width)) }] ;# stylesheet allows 1 to 5 cols
    set nrows [expr {([llength $manual(wing-toc)]+$perline)/$perline}]
    set n 0
    catch {unset rows}
    foreach name [lsort -dictionary $manual(wing-toc)] {
    catch { unset toc }
    catch { unset idx }
    foreach name [lsort $manual(wing-toc)] {
	set tail $manual(name-$name)
	if {[llength $tail] > 1} {
	    manerror "$name is defined in more than one file: $tail"
	    puts stderr "\n$name is defined in more than one file: $tail"
	    set tail [lindex $tail [expr {[llength $tail]-1}]]
	}
        # Assign man page to a category
	set category "Uncategorized"
	set catMaster $name
	if {[info exists manual(cat-master-$name)]} {
	    set catMaster $manual(cat-master-$name)
	}
	if {[info exists manual(category-$catMaster)]} {
	    set category $manual(category-$catMaster)
	} else {
	    #puts stderr "\n$tail has no .SH CATEGORY"
	}
        # Render link
	set tail [file tail $tail]
	if {[info exists manual(tooltip-$manual(wing-file)/$tail.htm)]} {
	    set tooltip $manual(tooltip-$manual(wing-file)/$tail.htm)
	    set tooltip [string map {[ {\[} ] {\]} $ {\$} \\ \\\\} $tooltip]
	    regsub {^[^-]+-\s*(.)} $tooltip {[string totitle \1]} tooltip
	    append rows([expr {$n%$nrows}]) \
		"<td> <a href=\"$tail.htm\" title=\"[subst $tooltip]\">$name</a> </td>"
	    lappend toc($category) \
              "<TD class='command'> <A href=\"$tail.htm\" title=\"[subst $tooltip]\">$name</A> </TD><TD>$manual(descrip-$name)</TD>"
            lappend idx "<LI> <A href=\"$tail.htm\" title=\"[subst $tooltip]\">$name</A> </LI>"
	} else {
	    append rows([expr {$n%$nrows}]) \
		"<td> <a href=\"$tail.htm\">$name</a> </td>"
	    lappend toc($category) \
              "<TD class='command'> <A href=\"$tail.htm\">$name</A> </TD><TD>$manual(descrip-$name)</TD>"
            lappend idx "<LI> <A href=\"$tail.htm\">$name</A> </LI>"
	}
	incr n
    }
    # Render the alphabetical index
    puts $manual(wing-toc-fp) "<H4>Alphabetical Index</H4>"
    puts $manual(wing-toc-fp) "<UL class='multicolumn ncols${perline}'>"
    puts $manual(wing-toc-fp) <table>
    puts $manual(wing-toc-fp) [join $idx \n]
    foreach row [lsort -integer [array names rows]] {
	puts $manual(wing-toc-fp) <tr>$rows($row)</tr>
    puts $manual(wing-toc-fp) "</UL>"
    # Render the category lists    
    puts $manual(wing-toc-fp) "<TABLE>"
    foreach category [lsort [array names toc]] {
	puts $manual(wing-toc-fp) "<TR><TD colspan='2'><H4>$category</H4></TD></TR>"
	puts $manual(wing-toc-fp) "<TR>[join $toc($category) "</TR>\n<TR>"]</TR>"
    }
    puts $manual(wing-toc-fp) </table>
    puts $manual(wing-toc-fp) "</TABLE>"

    #
    # insert wing copyrights
    #
    puts $manual(wing-toc-fp) [copyout $manual(wing-copyrights) "../"]
    puts $manual(wing-toc-fp) "</BODY></HTML>"
    close $manual(wing-toc-fp)

proc addbuffer {args} {
    global manual
    if {$manual(partial-text) ne ""} {
	append manual(partial-text) \n
    }
    append manual(partial-text) [join $args ""]
}
proc flushbuffer {} {
proc flushbuffer {{force false}} {
    global manual
    if {$manual(partial-text) ne ""} {
    if {$manual(partial-text) ne "" || $force} {
	lappend manual(text) [process-text $manual(partial-text)]
	set manual(partial-text) ""
    }
}

return

source [file join [file dirname [info script]] tcltk-man2html-utils.tcl]

proc parse_command_line {} {
    global argv Version

    # These variables determine where the man pages come from and where
    # the converted pages go to.
    global tcltkdir tkdir tcldir webdir build_tcl build_tk verbose
    global tcltkdir tkdir tcldir webdir pkgsDir build_tcl build_tk verbose

    # Set defaults based on original code.
    set tcltkdir ../..
    set tkdir {}
    set tcldir {}
    set webdir ../html
    set pkgsDir {}
    set build_tcl 0
    set build_tk 0
    set verbose 0
    # Default search version is a glob pattern
    set useversion {{,[8-9].[0-9]{,[.ab][0-9]{,[0-9]}}}}

    # Handle arguments a la GNU:

	    --help {
		puts "usage: tcltk-man-html \[OPTION\] ...\n"
		puts "  --help              print this help, then exit"
		puts "  --version           print version number, then exit"
		puts "  --srcdir=DIR        find tcl and tk source below DIR"
		puts "  --htmldir=DIR       put generated HTML in DIR"
                puts "  --pkgdir=DIR        find package sources below DIR"
		puts "  --tcl               build tcl help"
		puts "  --tk                build tk help"
		puts "  --useversion        version of tcl/tk to search for"
		puts "  --verbose           whether to print longer messages"
		exit 0
	    }

	    --srcdir=* {
		# length of "--srcdir=" is 9.
		set tcltkdir [string range $option 9 end]
	    }

	    --htmldir=* {
		# length of "--htmldir=" is 10
		set webdir [string range $option 10 end]
	    }
            
            --pkgdir=* {
		# length of "--pkgdir=" is 9
		set pkgsDir [string range $option 9 end]
            }

	    --useversion=* {
		# length of "--useversion=" is 13
		set useversion [string range $option 13 end]
	    }

	    --tcl {

		-directory $tcltkdir tk$useversion]] end]
	if {$tkdir eq ""} {
	    puts stderr "tcltk-man-html: couldn't find Tk below $tcltkdir"
	    exit 1
	}
	puts "using Tk source directory $tkdir"
    }
    
    if { $pkgsDir eq {} } {
	# Use default packages dir.
	set pkgsDir [file join $tcltkdir $tcldir pkgs]
    }
    set pkgsDir [file normalize $pkgsDir] 
    puts "using Packages source directory $pkgsDir"

    puts "verbose messages are [expr {$verbose ? {on} : {off}}]"

    # the title for the man pages overall
    global overall_title
    set overall_title ""
    if {$build_tcl} {

	border-top:        $hBd;
    }
    css-style h3 {
	font-size: 12px;
    }
    css-style h4 {
	font-size: 11px;
    }
    css-style ul.multicolumn {
	list-style-type: none;
	padding-left: 1em;
	margin: 0;    
	column-fill: balance;
        column-gap: 20px;
	-moz-column-gap: 20px;
	-webkit-column-gap: 20px;
    }
    css-style ul.ncols1 { column-count: 1; -moz-column-count: 1; -webkit-column-count: 1; }
    css-style ul.ncols2 { column-count: 2; -moz-column-count: 2; -webkit-column-count: 2; }
    css-style ul.ncols3 { column-count: 3; -moz-column-count: 3; -webkit-column-count: 3; }
    css-style ul.ncols4 { column-count: 4; -moz-column-count: 4; -webkit-column-count: 4; }
    css-style ul.ncols5 { column-count: 5; -moz-column-count: 5; -webkit-column-count: 5; }
    css-style td.command {
	padding-left: 1em;
    }
    css-style ".keylist dt" ".arguments dt" {
	width: 20em;
	float: left;
	padding: 2px;
	border-top: 1px solid #999;
    }

	}
    }

    ##
    ## build the keyword index.
    ##
    if {!$verbose} {
	puts stderr "Assembling index"
	puts $::STATUSOUT "\nAssembling index"
    }
    file delete -force -- $html/Keywords
    makedirhier $html/Keywords
    set keyfp [open $html/Keywords/[indexfile] w]
    puts $keyfp [htmlhead "$tcltkdesc Keywords" "$tcltkdesc Keywords" \
		     $overall_title "../[indexfile]"]
    set letters {A B C D E F G H I J K L M N O P Q R S T U V W X Y Z}

    close $manual(short-toc-fp)

    ##
    ## output man pages
    ##
    unset manual(section)
    if {!$verbose} {
	puts stderr "Rescanning [llength $manual(all-pages)] pages to build cross links and write out"
	puts $::STATUSOUT "\nRescanning [llength $manual(all-pages)] pages to build cross links and write out"
    }
    foreach path $manual(all-pages) wing_name $manual(all-page-domains) {
	set manual(wing-file) [file dirname $path]
	set manual(tail) [file tail $path]
	set manual(name) [file root $manual(tail)]
	try {
	    set text $manual(output-$manual(wing-file)-$manual(name))
	    set ntext 0
	    foreach item $text {
		incr ntext [llength [split $item \n]]
		incr ntext
	    }
	    set toc $manual(toc-$manual(wing-file)-$manual(name))
	    set ntoc 0
	    foreach item $toc {
		incr ntoc [llength [split $item \n]]
		incr ntoc
	    }
	    if {$verbose} {
		puts stderr "rescanning page $manual(name) $ntoc/$ntext"
		puts $::STATUSOUT "rescanning page $manual(name) $ntoc/$ntext"
	    } else {
		puts -nonewline stderr .
		puts -nonewline $::STATUSOUT .
	    }
	    set outfd [open $html/$manual(wing-file)/$manual(name).htm w]
	    puts $outfd [htmlhead "$manual($manual(wing-file)-$manual(name)-title)" \
		    $manual(name) $wing_name "[indexfile]" \
		    $overall_title "../[indexfile]"]
	    if {($ntext > 60) && ($ntoc > 32)} {
		foreach item $toc {
		    puts $outfd $item
		}
	    } elseif {$manual(name) in $forced_index_pages} {
		if {!$verbose} {puts stderr ""}
		manerror "forcing index generation"
		foreach item $toc {
		    puts $outfd $item
		}
	    }
	    foreach item $text {
		puts $outfd [insert-cross-references $item]
	    }
	    puts $outfd "</BODY></HTML>"
	} on error msg {
	    if {$verbose} {
		puts stderr $msg
	    } else {
		puts stderr "\nError when processing $manual(name): $msg"
	    }
	} finally {
	    catch {close $outfd}
	}
    }
    if {!$verbose} {
	puts stderr "\nDone"
	puts $::STATUSOUT "\nDone"
    }
    return {}
}

##
## Helper for assembling the descriptions of base packages (i.e., Tcl and Tk).
##

    }
}

##
## Helper for assembling the descriptions of contributed packages.
##
proc plus-pkgs {type args} {
    global build_tcl tcltkdir tcldir
    global build_tcl tcltkdir tcldir pkgsDir
    if {$type ni {n 3}} {
	error "unknown type \"$type\": must be 3 or n"
    }
    if {!$build_tcl} return
    set result {}
    set pkgsdir $tcltkdir/$tcldir/pkgs
    foreach {dir name version} $args {
	set globpat $pkgsdir/$dir/doc/*.$type
	set globpat [file join $pkgsDir $dir doc *.$type]
	if {![llength [glob -type f -nocomplain $globpat]]} {
	    # Fallback for manpages generated using doctools
	    set globpat $pkgsdir/$dir/doc/man/*.$type
	    set globpat [file join $pkgsDir $dir doc man *.$type]
	    if {![llength [glob -type f -nocomplain $globpat]]} {
		continue
	    }
	}
	switch $type {
	    n {
		set title "$name Package Commands"

	append appdir "$tkdir"
    }


    # When building docs for Tcl, try to build docs for bundled packages too
    set packageBuildList {}
    if  {$build_tcl} {
	set pkgsDir [file join $tcltkdir $tcldir pkgs]
	set subdirs [glob -nocomplain -types d -tails -directory $pkgsDir *]

	foreach dir [lsort $subdirs] {
	    # Parse the subdir name into (name, version) as fallback...
	    set description [split $dir -]
	    if {2 != [llength $description]} {
		regexp {([^0-9]*)(.*)} $dir -> n v
		set description [list $n $v]
	    }

	    # ... but try to extract (name, version) from subdir contents
	    try {
		set f [open [file join $pkgsDir $dir configure.in]]
		foreach line [split [read $f] \n] {
		    if {2 == [scan $line \
			    { AC_INIT ( [%[^]]] , [%[^]]] ) } n v]} {
			set description [list $n $v]
			break
		    }
		}
	    } finally {
		catch {close $f; unset f}
		glob -directory [file join $pkgsDir $dir] -- \
                  configure.in configure.ac unix/configure.in 
	    } trap {TCL OPERATION GLOB NOMATCH} {e} {
		puts stderr "warning: no 'configure.in' (or .ac) under '[file nativename [file join $pkgsDir $dir]]'"
	    } on ok {flist} {
		try {
		    set f [open [lindex $flist 0]]
		    foreach line [split [read $f] \n] {
			if {2 == [scan $line \
				{ AC_INIT ( [%[^]]] , [%[^]]] ) } n v]} {
			    set description [list $n $v]
			    break
			}
		    }
        	} finally {
		    catch {close $f; unset f}
		}
	    }

	    if {[file exists [file join $pkgsDir $dir configure]]} {
		# Looks like a package, record our best extraction attempt
		lappend packageBuildList $dir {*}$description
	    }
	}
    }

    # Get the list of packages to try, and what their human-readable names
    # are. Note that the package directory list should be version-less.
    try {
	set packageDirNameMap {}
	if {$build_tcl} {
	    set f [open $tcltkdir/$tcldir/pkgs/package.list.txt]
    set packageDirNameMap {}
    if {$build_tcl} {
	set packageDirNameMap {
	    itcl {[incr Tcl]}
	    tdbc {TDBC}
	    thread Thread
	}
	foreach pkglistfile [list \
    	    [file join $pkgsDir "package.list.txt"] \
    	    "$tcltkdir/$tcldir/pkgs/package.list.txt" \
	] {
	    puts "checking for package map in '[file nativename [file normalize $pkglistfile]]'"
	    if { ! [file exists $pkglistfile] } continue
	    set f [open $pkglistfile r]
	    try {
		foreach line [split [read $f] \n] {
		    if {[string trim $line] eq ""} continue
		    if {[string match #* $line]} continue
		    lappend packageDirNameMap {*}$line
		    dict set packageDirNameMap {*}$line
		}
	    } finally {
		close $f
	    }
	}
    } trap {POSIX ENOENT} {} {
	set packageDirNameMap {
	    itcl {[incr Tcl]}
	    tdbc {TDBC}
	    thread Thread
	}
    }

    # Convert to human readable names, if applicable
    for {set idx 0} {$idx < [llength $packageBuildList]} {incr idx 3} {
	lassign [lrange $packageBuildList $idx $idx+2] d n v
	if {[dict exists $packageDirNameMap $n]} {
	    lset packageBuildList $idx+1 [dict get $packageDirNameMap $n]